| |
========================================================================================== */
#include <dlog.h>
-#include <mm_attrs_private.h>
#include <mm_attrs.h>
#include "mm_player_utils.h"
#include "mm_player_priv.h"
result = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, args_list);
- if ( result != MM_ERROR_NONE)
- LOGE("failed to get %s attribute\n", attribute_name);
+ if (result != MM_ERROR_NONE)
+ LOGE("failed to get %s attribute", attribute_name);
return result;
}
/* set attributes and commit them */
result = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, args_list);
- if (result != MM_ERROR_NONE)
- {
- LOGE("failed to set %s attribute\n", attribute_name);
+ if (result != MM_ERROR_NONE) {
+ LOGE("failed to set %s attribute", attribute_name);
return result;
}
result = __mmplayer_apply_attribute(handle, attribute_name);
- if (result != MM_ERROR_NONE)
- {
- LOGE("failed to apply attributes\n");
+ if (result != MM_ERROR_NONE) {
+ LOGE("failed to apply attributes");
return result;
}
}
int
-_mmplayer_get_attributes_info(MMHandleType handle, const char *attribute_name, MMPlayerAttrsInfo *dst_info)
+_mmplayer_get_attributes_info(MMHandleType handle, const char *attribute_name, mmplayer_attrs_info_t *dst_info)
{
int result = MM_ERROR_NONE;
MMHandleType attrs = 0;
result = mm_attrs_get_info_by_name(attrs, attribute_name, &src_info);
- if ( result != MM_ERROR_NONE)
- {
- LOGE("failed to get attribute info\n");
+ if (result != MM_ERROR_NONE) {
+ LOGE("failed to get attribute info");
return result;
}
- memset(dst_info, 0x00, sizeof(MMPlayerAttrsInfo));
+ memset(dst_info, 0x00, sizeof(mmplayer_attrs_info_t));
dst_info->type = src_info.type;
dst_info->flag = src_info.flag;
- dst_info->validity_type= src_info.validity_type;
+ dst_info->validity_type = src_info.validity_type;
- switch(src_info.validity_type)
- {
- case MM_ATTRS_VALID_TYPE_INT_ARRAY:
- dst_info->int_array.array = src_info.int_array.array;
- dst_info->int_array.count = src_info.int_array.count;
- dst_info->int_array.d_val = src_info.int_array.dval;
+ switch (src_info.validity_type) {
+ case MM_ATTRS_VALID_TYPE_INT_ARRAY:
+ dst_info->int_array.array = src_info.int_array.array;
+ dst_info->int_array.count = src_info.int_array.count;
+ dst_info->int_array.d_val = src_info.int_array.dval;
break;
- case MM_ATTRS_VALID_TYPE_INT_RANGE:
- dst_info->int_range.min = src_info.int_range.min;
- dst_info->int_range.max = src_info.int_range.max;
- dst_info->int_range.d_val = src_info.int_range.dval;
+ case MM_ATTRS_VALID_TYPE_INT_RANGE:
+ dst_info->int_range.min = src_info.int_range.min;
+ dst_info->int_range.max = src_info.int_range.max;
+ dst_info->int_range.d_val = src_info.int_range.dval;
break;
- case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
- dst_info->double_array.array = src_info.double_array.array;
- dst_info->double_array.count = src_info.double_array.count;
- dst_info->double_array.d_val = src_info.double_array.dval;
+ case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
+ dst_info->double_array.array = src_info.double_array.array;
+ dst_info->double_array.count = src_info.double_array.count;
+ dst_info->double_array.d_val = src_info.double_array.dval;
break;
- case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
- dst_info->double_range.min = src_info.double_range.min;
- dst_info->double_range.max = src_info.double_range.max;
- dst_info->double_range.d_val = src_info.double_range.dval;
+ case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
+ dst_info->double_range.min = src_info.double_range.min;
+ dst_info->double_range.max = src_info.double_range.max;
+ dst_info->double_range.d_val = src_info.double_range.dval;
break;
- default:
+ default:
break;
}
int
__mmplayer_apply_attribute(MMHandleType handle, const char *attribute_name)
{
- mm_player_t* player = 0;
+ mmplayer_t *player = 0;
MMPLAYER_RETURN_VAL_IF_FAIL(handle, MM_ERROR_COMMON_INVALID_ARGUMENT);
MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
player = MM_PLAYER_CAST(handle);
+ mmplayer_pipeline_info_t *pipeline = player->pipeline;
- if ( g_strrstr(attribute_name, "display") )
- {
- int pipeline_type = 0;
- MMPlayerGstPipelineInfo *pipeline = player->pipeline;
+ /* before preparing, just keep the attr value */
+ MMPLAYER_RETURN_VAL_IF_FAIL(pipeline && pipeline->mainbin, MM_ERROR_NONE);
- /* check videosink element is created */
- if(!pipeline)
- return MM_ERROR_NONE;
- mm_attrs_get_int_by_name(player->attrs, "pipeline_type", &pipeline_type);
- if (pipeline_type == MM_PLAYER_PIPELINE_CLIENT) {
- if(!pipeline->mainbin || !pipeline->mainbin[MMPLAYER_M_V_SINK].gst)
- return MM_ERROR_NONE;
- } else {
- if(!pipeline->videobin || !pipeline->videobin[MMPLAYER_V_SINK].gst)
- return MM_ERROR_NONE;
- }
+ if (g_strrstr(attribute_name, MM_PLAYER_PITCH_VALUE)) {
+ int pitch_control = 0;
+ double pitch_value = 0;
- if ( MM_ERROR_NONE != _mmplayer_update_video_param( player ) )
- {
+ mm_attrs_multiple_get(player->attrs, NULL,
+ MM_PLAYER_PITCH_CONTROL, &pitch_control,
+ MM_PLAYER_PITCH_VALUE, &pitch_value,
+ NULL);
+
+ if (!pitch_control || !pipeline->audiobin[MMPLAYER_A_PITCH].gst)
+ return MM_ERROR_PLAYER_NO_OP;
+
+ LOGD("set pitch value to %1.3f", pitch_value);
+ g_object_set(pipeline->audiobin[MMPLAYER_A_PITCH].gst, "pitch", (gdouble)pitch_value, NULL);
+ }
+
+ /* Currently, there are only display related implementation at below */
+ if (!pipeline->videobin ||
+ !pipeline->videobin[MMPLAYER_V_SINK].gst) {
+ /*
+ * The attribute should be committed even though videobin is not created yet.
+ * So, true should be returned here.
+ * Otherwise, video can be diaplayed abnormal.
+ */
+ return MM_ERROR_NONE;
+ }
+
+ if (g_strrstr(attribute_name, "display")) {
+ char *param_name = NULL;
+ int str_len = strlen(attribute_name);
+ param_name = g_malloc0(str_len + 1);
+ if (!param_name) {
+ LOGE("failed to alloc param_name");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+ strncpy(param_name, attribute_name, str_len);
+ param_name[str_len] = '\0';
+ LOGD(" param_name: %s", param_name);
+ if (MM_ERROR_NONE != _mmplayer_update_video_param(player, param_name)) {
+ MMPLAYER_FREEIF(param_name);
LOGE("failed to update video param");
return MM_ERROR_PLAYER_INTERNAL;
}
+ MMPLAYER_FREEIF(param_name);
+ }
+
+ if (g_strrstr(attribute_name, MM_PLAYER_GAPLESS_MODE)) {
+ int gapless = 0;
+
+ mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_GAPLESS_MODE, &gapless);
+ if (gapless > 0) {
+ LOGD("disable last-sample at videosink");
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "enable-last-sample", FALSE, NULL);
+ }
+ }
+
+ if (g_strrstr(attribute_name, MM_PLAYER_ENABLE_VIDEO_DECODED_CB)) {
+ if (!player->set_mode.video_export) {
+ LOGE("there is no callback to export video");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+ int enable = 0;
+ mm_attrs_get_int_by_name(player->attrs, "enable_video_decoded_cb", &enable);
+ g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "signal-handoffs", enable ? TRUE : FALSE, NULL);
}
return MM_ERROR_NONE;
MMHandleType
_mmplayer_construct_attribute(MMHandleType handle)
{
- mm_player_t *player = NULL;
+ int result = MM_ERROR_NONE;
int idx = 0;
MMHandleType attrs = 0;
int num_of_attrs = 0;
- mmf_attrs_construct_info_t *base = NULL;
-
- MMPLAYER_RETURN_VAL_IF_FAIL (handle, 0);
+ MMAttrsConstructInfo *base = NULL;
- player = MM_PLAYER_CAST(handle);
+ MMPLAYER_RETURN_VAL_IF_FAIL(handle, 0);
- MMPlayerAttrsSpec player_attrs[] =
- {
+ mmplayer_attrs_spec_t player_attrs[] = {
{
"profile_uri", // name
MM_ATTRS_TYPE_STRING, // type
MM_ATTRS_FLAG_RW, // flag
- (void *) NULL, // default value
+ (void *)NULL, // default value
MM_ATTRS_VALID_TYPE_NONE, // validity type
0, // validity min value
0 // validity max value
"profile_user_param",
MM_ATTRS_TYPE_DATA,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"profile_play_count",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 1, // -1 : repeat continually
+ (void *)1, /* -1 : repeat continually */
MM_ATTRS_VALID_TYPE_INT_RANGE,
-1,
- MMPLAYER_MAX_INT
+ 1
},
{
"profile_prepare_async",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- 1
- },
- { /* update registry for downloadable codec */
- "profile_update_registry",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1
},
{
- "streaming_type",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) STREAMING_SERVICE_NONE,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- STREAMING_SERVICE_VOD,
- STREAMING_SERVICE_NUM
- },
- {
- "streaming_udp_timeout",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 10000,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
"streaming_user_agent",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
- "streaming_wap_profile",
- MM_ATTRS_TYPE_STRING,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
},
{
- "streaming_network_bandwidth",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 128000,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
"streaming_cookie",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
},
{
- "streaming_proxy",
- MM_ATTRS_TYPE_STRING,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
- "streaming_timeout",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) -1, // DEFAULT_HTTP_TIMEOUT
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- -1,
- MMPLAYER_MAX_INT
- },
- {
"subtitle_uri",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
},
{
- "content_duration",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
"content_bitrate",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"content_max_bitrate",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"content_video_found",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1
"content_video_codec",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"content_video_bitrate",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"content_video_fps",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"content_video_width",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"content_video_height",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
},
{
- "content_video_track_num",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "content_audio_found",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- 1
- },
- {
"content_audio_codec",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"content_audio_bitrate",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"content_audio_channels",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"content_audio_samplerate",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
},
{
- "content_audio_track_num",
- MM_ATTRS_TYPE_INT,
+ "content_audio_format",
+ MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
+ (void *)NULL,
+ MM_ATTRS_VALID_TYPE_NONE,
0,
- MMPLAYER_MAX_INT
+ 0
},
{
- "content_audio_format",
+ "content_text_track_num",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
},
{
- "content_text_track_num",
+ "current_text_track_index",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)-1,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ -1,
MMPLAYER_MAX_INT
},
{
"tag_artist",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"tag_title",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"tag_album",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL
+ (void *)NULL
},
{
"tag_genre",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"tag_author",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"tag_copyright",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"tag_date",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"tag_description",
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
"tag_track_num",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
"tag_album_cover",
MM_ATTRS_TYPE_DATA,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
},
{
- "display_src_crop_x",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_src_crop_y",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_src_crop_width",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_src_crop_height",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_roi_x",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_roi_y",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_roi_width",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 480,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_roi_height",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 800,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_roi_mode",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) MM_DISPLAY_METHOD_CUSTOM_ROI_FULL_SCREEN,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- MM_DISPLAY_METHOD_CUSTOM_ROI_FULL_SCREEN,
- MM_DISPLAY_METHOD_CUSTOM_ROI_LETER_BOX
- },
- {
"display_rotation",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) MM_DISPLAY_ROTATION_NONE,
+ (void *)MM_DISPLAY_ROTATION_NONE,
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_DISPLAY_ROTATION_NONE,
MM_DISPLAY_ROTATION_270
"display_visible",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) FALSE,
+ (void *)FALSE,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1
"display_method",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) MM_DISPLAY_METHOD_LETTER_BOX,
+ (void *)MM_DISPLAY_METHOD_LETTER_BOX,
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_DISPLAY_METHOD_LETTER_BOX,
MM_DISPLAY_METHOD_CUSTOM_ROI
"display_overlay",
MM_ATTRS_TYPE_DATA,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
},
-#ifdef HAVE_WAYLAND
{
- "wl_display",
- MM_ATTRS_TYPE_DATA,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
- "wl_window_render_x",
+ "display_win_roi_x",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ MMPLAYER_MIN_INT,
MMPLAYER_MAX_INT
},
{
- "wl_window_render_y",
+ "display_win_roi_y",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ MMPLAYER_MIN_INT,
MMPLAYER_MAX_INT
},
{
- "wl_window_render_width",
+ "display_win_roi_width",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
},
{
- "wl_window_render_height",
+ "display_win_roi_height",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
},
{
- "use_wl_surface",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) FALSE,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- FALSE,
- TRUE
- },
-
-#endif
- {
- "display_overlay_user_data",
- MM_ATTRS_TYPE_DATA,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
"display_surface_type",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) MM_DISPLAY_SURFACE_NULL,
+ (void *)MM_DISPLAY_SURFACE_NULL,
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_DISPLAY_SURFACE_OVERLAY,
MM_DISPLAY_SURFACE_NUM - 1
},
{
- "display_evas_surface_sink",
+ "sound_stream_type",
MM_ATTRS_TYPE_STRING,
- MM_ATTRS_FLAG_READABLE,
- (void *) player->ini.videosink_element_evas,
+ MM_ATTRS_FLAG_RW,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
},
{
- "display_force_aspect_ration",
+ "sound_stream_index",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 1,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ -1,
MMPLAYER_MAX_INT
},
{
- "display_width", // dest width of fimcconvert ouput
+ "sound_latency_mode",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)1, // 0: low latency, 1: middle latency 2: high latency
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
- MMPLAYER_MAX_INT
+ 2
},
{
- "display_height", // dest height of fimcconvert ouput
+ "pcm_extraction_samplerate", // set samplerate for pcm extraction
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)44100, // hz
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MMPLAYER_MAX_INT
},
{
- "display_evas_do_scaling",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) TRUE,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- FALSE,
- TRUE
- },
- {
- "sound_fadeup",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) FALSE,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- FALSE,
- TRUE
- },
- {
- "sound_fadedown",
+ "pcm_extraction_channels", // set channels for pcm extraction
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) FALSE,
+ (void *)1,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- FALSE,
- TRUE
+ 0,
+ MMPLAYER_MAX_INT
},
{
- "sound_volume_type",
+ "accurate_seek",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) MM_SOUND_VOLUME_TYPE_MEDIA,
+ (void *)0,
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
- MMPLAYER_MAX_INT
+ 1
},
{
- "sound_stream_type",
+ "content_video_orientation", // orientation of video content
MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void *) NULL,
+ (void *)NULL,
MM_ATTRS_VALID_TYPE_NONE,
0,
0
},
{
- "sound_stream_index",
- MM_ATTRS_TYPE_INT,
+ "pcm_extraction_format",
+ MM_ATTRS_TYPE_STRING,
MM_ATTRS_FLAG_RW,
+ (void *)NULL,
+ MM_ATTRS_VALID_TYPE_NONE,
0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- -1,
- MMPLAYER_MAX_INT
- },
- {
- "sound_route",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) MM_AUDIOROUTE_USE_EXTERNAL_SETTING,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- MM_AUDIOROUTE_USE_EXTERNAL_SETTING,
- MM_AUDIOROUTE_CAPTURE_STEREOMIC_ONLY
+ 0
},
{
- "sound_stop_when_unplugged",
+ "drc_mode",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) TRUE,
+ (void *)FALSE,
MM_ATTRS_VALID_TYPE_INT_RANGE,
FALSE,
TRUE
},
{
- "sound_application_pid",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "sound_spk_out_only",
+ "gapless_mode",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) FALSE,
+ (void *)FALSE,
MM_ATTRS_VALID_TYPE_INT_RANGE,
FALSE,
TRUE
},
{
- "sound_priority",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0, // 0: normal, 1: high 2: high with sound transition 3: mix with others regardless of priority
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- 3
- },
- {
- "sound_close_resource",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- 1
- },
- {
- "sound_latency_mode",
+ "enable_video_decoded_cb",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 1, // 0: low latency, 1: middle latency 2: high latency
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- 2
- },
- {
- "pcm_extraction", // enable pcm extraction
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) FALSE,
+ (void *)FALSE,
MM_ATTRS_VALID_TYPE_INT_RANGE,
FALSE,
TRUE
},
{
- "pcm_extraction_samplerate", // set samplerate for pcm extraction
+ "content_video_is_spherical",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 44100, // hz
+ (void *)-1,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ -1,
MMPLAYER_MAX_INT
},
{
- "pcm_extraction_depth", // set depth for pcm extraction
+ "video_codec_type",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 16, // bits
+ (void *)MM_PLAYER_CODEC_TYPE_DEFAULT,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
+ MM_PLAYER_CODEC_TYPE_DEFAULT,
+ MM_PLAYER_CODEC_TYPE_SW
},
{
- "pcm_extraction_channels", // set channels for pcm extraction
+ "audio_codec_type",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 1,
+ (void *)MM_PLAYER_CODEC_TYPE_DEFAULT,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
+ MM_PLAYER_CODEC_TYPE_DEFAULT,
+ MM_PLAYER_CODEC_TYPE_SW
},
{
- "pcm_extraction_start_msec", // set start position to extract pcm
+ "video_buffer_total_size",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)DEFAULT_NUM_OF_V_OUT_BUFFER,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ MMPLAYER_MIN_INT,
MMPLAYER_MAX_INT
},
{
- "pcm_extraction_end_msec", // set end position to extract pcm
+ "video_buffer_extra_size",
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 0,
+ (void *)DEFAULT_NUM_OF_V_OUT_BUFFER,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ MMPLAYER_MIN_INT,
MMPLAYER_MAX_INT
},
{
- "profile_smooth_repeat",
+ "prebuffer_ms", /* user setting */
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) FALSE,
+ (void *) MIN_BUFFERING_TIME,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ MIN_BUFFERING_TIME,
MMPLAYER_MAX_INT
},
{
- "profile_progress_interval", // will be deprecated
+ "rebuffer_ms", /* user setting */
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) 500,
+ (void *) MIN_BUFFERING_TIME,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
+ MIN_BUFFERING_TIME,
MMPLAYER_MAX_INT
},
{
- "display_x",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "display_y",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- MMPLAYER_MAX_INT
- },
- {
- "pd_mode",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) MM_PLAYER_PD_MODE_NONE,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- MM_PLAYER_PD_MODE_NONE,
- MM_PLAYER_PD_MODE_URI // not tested yet, because of no fixed scenario
- },
- {
- "pd_location", // location of the file to write
- MM_ATTRS_TYPE_STRING,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
- "accurate_seek",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) 0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- 0,
- 1
- },
- {
- "content_video_orientation", // orientation of video content
- MM_ATTRS_TYPE_STRING,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
- "pcm_audioformat",
- MM_ATTRS_TYPE_STRING,
- MM_ATTRS_FLAG_RW,
- (void *) NULL,
- MM_ATTRS_VALID_TYPE_NONE,
- 0,
- 0
- },
- {
- "display_surface_client_type",
+ "audio_offload", /* MM_PLAYER_AUDIO_OFFLOAD */
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) MM_DISPLAY_SURFACE_NULL,
+ (void *)FALSE,
MM_ATTRS_VALID_TYPE_INT_RANGE,
- MM_DISPLAY_SURFACE_OVERLAY,
- MM_DISPLAY_SURFACE_NUM - 1
- },
- {
- "pipeline_type",
- MM_ATTRS_TYPE_INT,
- MM_ATTRS_FLAG_RW,
- (void *) MM_PLAYER_PIPELINE_LEGACY,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- MM_PLAYER_PIPELINE_LEGACY,
- MM_PLAYER_PIPELINE_MAX - 1
+ FALSE,
+ TRUE
},
{
- "drc_mode",
+ "pitch_control", /* MM_PLAYER_PITCH_CONTROL */
MM_ATTRS_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void *) FALSE,
+ (void *)FALSE,
MM_ATTRS_VALID_TYPE_INT_RANGE,
FALSE,
TRUE
},
{
- "gapless_mode",
- MM_ATTRS_TYPE_INT,
+ "pitch_value", /* MM_PLAYER_PITCH_VALUE */
+ MM_ATTRS_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void *) FALSE,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
- FALSE,
- TRUE
- }
+ (void *)1,
+ MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
+ 0.5,
+ 2
+ },
};
num_of_attrs = ARRAY_SIZE(player_attrs);
- base = (mmf_attrs_construct_info_t* )malloc(num_of_attrs * sizeof(mmf_attrs_construct_info_t));
-
- if ( !base )
- {
+ base = g_try_new(MMAttrsConstructInfo, num_of_attrs);
+ if (!base) {
LOGE("failed to alloc attrs constructor");
return 0;
}
/* initialize values of attributes */
- for ( idx = 0; idx < num_of_attrs; idx++ )
- {
+ for (idx = 0; idx < num_of_attrs; idx++) {
base[idx].name = player_attrs[idx].name;
base[idx].value_type = player_attrs[idx].value_type;
base[idx].flags = player_attrs[idx].flags;
base[idx].default_value = player_attrs[idx].default_value;
}
- attrs = mmf_attrs_new_from_data(
- "mmplayer_attrs",
- base,
- num_of_attrs,
- NULL,
- NULL);
+ result = mm_attrs_new(base, num_of_attrs, "mmplayer_attrs",
+ NULL, NULL, &attrs);
/* clean */
MMPLAYER_FREEIF(base);
- if ( !attrs )
- {
+ if (result) {
LOGE("failed to create player attrs");
return 0;
}
/* set validity type and range */
- for ( idx = 0; idx < num_of_attrs; idx++ )
- {
- switch ( player_attrs[idx].valid_type)
+ for (idx = 0; idx < num_of_attrs; idx++) {
+ switch (player_attrs[idx].valid_type) {
+ case MM_ATTRS_VALID_TYPE_INT_RANGE:
{
- case MM_ATTRS_VALID_TYPE_INT_RANGE:
- {
- mmf_attrs_set_valid_type (attrs, idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
- mmf_attrs_set_valid_range (attrs, idx,
- player_attrs[idx].value_min,
- player_attrs[idx].value_max,
- (int)(intptr_t)(player_attrs[idx].default_value));
- }
+ mm_attrs_set_valid_type(attrs, idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
+ mm_attrs_set_valid_range(attrs, idx,
+ player_attrs[idx].value_min,
+ player_attrs[idx].value_max,
+ (int)(intptr_t)(player_attrs[idx].default_value));
+ }
break;
- case MM_ATTRS_VALID_TYPE_INT_ARRAY:
- case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
- case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
- default:
+ case MM_ATTRS_VALID_TYPE_INT_ARRAY:
+ case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
+ case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
+ default:
break;
}
}
/* commit */
- mmf_attrs_commit(attrs);
+ if (mm_attrs_commit_all(attrs)) {
+ LOGE("failed to update attributes");
+ mm_attrs_free(attrs);
+ return 0;
+ }
return attrs;
}
bool
_mmplayer_deconstruct_attribute(MMHandleType handle) // @
{
- mm_player_t *player = MM_PLAYER_CAST(handle);
+ mmplayer_t *player = MM_PLAYER_CAST(handle);
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- if (player->attrs)
- {
- mmf_attrs_free (player->attrs);
+ if (player->attrs) {
+ mm_attrs_free(player->attrs);
player->attrs = 0;
}
projects / platform / core / multimedia / libmm-player.git / blobdiff