From ec9e785b7b5dc8888d108fe316250fcea2901e8f Mon Sep 17 00:00:00 2001 From: Eunhae Choi Date: Thu, 10 Jan 2019 19:37:49 +0900 Subject: [PATCH] [0.6.167] use new buffering properties - replace the deprecated buffering properties with new one - consider the max byte size of each buffering type when player get the new buffering byte size Change-Id: I472b182e99d4a07e051cc2a33925362d8a3da72c --- packaging/libmm-player.spec | 2 +- src/include/mm_player_streaming.h | 24 ++++---- src/mm_player_streaming.c | 123 ++++++++++++++++++-------------------- 3 files changed, 72 insertions(+), 77 deletions(-) diff --git a/packaging/libmm-player.spec b/packaging/libmm-player.spec index c93a330..d75648c 100644 --- a/packaging/libmm-player.spec +++ b/packaging/libmm-player.spec @@ -1,6 +1,6 @@ Name: libmm-player Summary: Multimedia Framework Player Library -Version: 0.6.166 +Version: 0.6.167 Release: 0 Group: Multimedia/Libraries License: Apache-2.0 diff --git a/src/include/mm_player_streaming.h b/src/include/mm_player_streaming.h index 11ff576..cc91918 100644 --- a/src/include/mm_player_streaming.h +++ b/src/include/mm_player_streaming.h @@ -31,11 +31,12 @@ #include "mm_player.h" #define MAX_FILE_BUFFER_NAME_LEN 256 - -#define DEFAULT_BUFFER_HIGH_PERCENT 99.0 -#define MIN_BUFFER_PERCENT 0.0 #define MAX_BUFFER_PERCENT 100.0 +#define DEFAULT_BUFFER_HIGH_WATERMARK 0.99 +#define MIN_BUFFER_WATERMARK 0.0 +#define MAX_BUFFER_WATERMARK 1.0 + /* buffering time criteria (ms) */ #define DEFAULT_BUFFERING_TIME (3 * 1000) #define MIN_BUFFERING_TIME (0) @@ -56,13 +57,13 @@ #define GET_BYTE_FROM_BIT(bit) (bit / 8) #define GET_BIT_FROM_BYTE(byte) (byte * 8) -#define CALC_PERCENT(a, b) ((gdouble)(a) * 100 / (gdouble)(b)) -#define GET_PERCENT(a, b, c, d) \ +#define CALC_WATERMARK(a, b) ((gdouble)(a) / (gdouble)(b)) +#define GET_WATERMARK(a, b, c, d) \ do { \ if (((a) > 0) && ((b) > 0)) { \ - d = CALC_PERCENT(a, b); \ + d = CALC_WATERMARK(a, b); \ } else { \ - LOGW("set default per info"); \ + LOGW("set default watermark value %f", c); \ d = c; \ } \ } while (0) @@ -77,7 +78,8 @@ #define IS_MUXED_BUFFERING_MODE(sr) (PLAYER_STREAM_CAST(sr)->streaming_buffer_type == BUFFER_TYPE_MUXED) ? (TRUE) : (FALSE) #define IS_DEMUXED_BUFFERING_MODE(sr) (PLAYER_STREAM_CAST(sr)->streaming_buffer_type == BUFFER_TYPE_DEMUXED) ? (TRUE) : (FALSE) -#define GET_NEW_BUFFERING_BYTE(size) ((size) < MAX_BUFFER_SIZE_BYTES) ? (size) : (MAX_BUFFER_SIZE_BYTES) +#define GET_MAX_BYTE_BUFFER_SIZE(type) ((type == BUFFER_TYPE_MUXED) ? (DEFAULT_RING_BUFFER_SIZE_BYTES) : (MAX_BUFFER_SIZE_BYTES)) +#define GET_NEW_BUFFERING_BYTE(size, max) ((size) < (max)) ? (size) : (max) typedef enum { BUFFER_TYPE_DEFAULT, @@ -110,9 +112,9 @@ typedef struct { GstElement *buffer; /* buffering element of playback pipeline */ guint buffering_bytes; - gint buffering_time; // mq : max buffering time value till now - gdouble buffer_high_percent; - gdouble buffer_low_percent; + gint buffering_time; /* mq : max buffering time value till now */ + gdouble buffer_high_watermark; + gdouble buffer_low_watermark; gboolean is_live; } streaming_buffer_t; diff --git a/src/mm_player_streaming.c b/src/mm_player_streaming.c index 986e997..999ed33 100644 --- a/src/mm_player_streaming.c +++ b/src/mm_player_streaming.c @@ -42,11 +42,11 @@ typedef struct { typedef struct { guint buffering_bytes; // bytes gint buffering_time; // ms - gdouble percent_byte; - gdouble percent_time; + gdouble watermark_byte; + gdouble watermark_time; } streaming_buffer_info_t; -static void streaming_set_buffer_percent(mm_player_streaming_t *streamer, BufferType type, gdouble high_percent_byte, gdouble high_percent_time); +static void streaming_set_buffer_watermark(mm_player_streaming_t *streamer, BufferType type, gdouble high_watermark_byte, gdouble high_watermark_time); static void streaming_set_queue2_queue_type(mm_player_streaming_t *streamer, MuxedBufferType type, guint64 content_size); static void streaming_set_buffer_size(mm_player_streaming_t *streamer, BufferType type, guint buffering_bytes, gint buffering_time); static void streaming_update_buffering_status(mm_player_streaming_t *streamer, GstMessage *buffering_msg, gint64 position); @@ -96,7 +96,7 @@ static void streaming_buffer_initialize(streaming_buffer_t *buffer_handle, gbool buffer_handle->buffering_bytes = DEFAULT_BUFFER_SIZE_BYTES; buffer_handle->buffering_time = DEFAULT_BUFFERING_TIME; - buffer_handle->buffer_high_percent = DEFAULT_BUFFER_HIGH_PERCENT; + buffer_handle->buffer_high_watermark = DEFAULT_BUFFER_HIGH_WATERMARK; buffer_handle->is_live = FALSE; } @@ -188,10 +188,10 @@ void __mm_player_streaming_set_content_bitrate( return; } -static void streaming_set_buffer_percent(mm_player_streaming_t *streamer, - BufferType type, gdouble high_percent_byte, gdouble high_percent_time) +static void streaming_set_buffer_watermark(mm_player_streaming_t *streamer, + BufferType type, gdouble high_watermark_byte, gdouble high_watermark_time) { - gdouble high_percent = 0.0; + gdouble high_watermark = 0.0; streaming_buffer_t *buffer_handle = NULL; gchar *factory_name = NULL; @@ -214,22 +214,22 @@ static void streaming_set_buffer_percent(mm_player_streaming_t *streamer, } if (type == BUFFER_TYPE_MUXED) - high_percent = high_percent_byte; + high_watermark = high_watermark_byte; else - high_percent = MAX(high_percent_time, high_percent_byte); + high_watermark = MAX(high_watermark_time, high_watermark_byte); - if (high_percent <= MIN_BUFFER_PERCENT || high_percent >= MAX_BUFFER_PERCENT) - high_percent = DEFAULT_BUFFER_HIGH_PERCENT; + if (high_watermark <= MIN_BUFFER_WATERMARK || high_watermark >= MAX_BUFFER_WATERMARK) + high_watermark = DEFAULT_BUFFER_HIGH_WATERMARK; /* if use-buffering is disabled, this settings do not have any meaning. */ - LOGD("target buffer elem : %s (~ %2.3f)", - GST_ELEMENT_NAME(buffer_handle->buffer), high_percent); + LOGD("target buffer elem : %s (~ %1.3f)", + GST_ELEMENT_NAME(buffer_handle->buffer), high_watermark); - if ((high_percent == DEFAULT_BUFFER_HIGH_PERCENT) || - (buffer_handle->buffer_high_percent != high_percent)) - g_object_set(G_OBJECT(buffer_handle->buffer), "high-percent", (gint)high_percent, NULL); + if ((high_watermark == DEFAULT_BUFFER_HIGH_WATERMARK) || + (buffer_handle->buffer_high_watermark != high_watermark)) + g_object_set(G_OBJECT(buffer_handle->buffer), "high-watermark", high_watermark, NULL); - buffer_handle->buffer_high_percent = high_percent; + buffer_handle->buffer_high_watermark = high_watermark; MMPLAYER_FLEAVE(); return; @@ -240,7 +240,6 @@ static void streaming_set_queue2_queue_type(mm_player_streaming_t *streamer, { streaming_buffer_t *buffer_handle = NULL; guint64 buffer_size = 0; /* bytes */ - gchar *factory_name = NULL; MMPLAYER_FENTER(); MMPLAYER_RETURN_IF_FAIL(streamer); @@ -253,20 +252,7 @@ static void streaming_set_queue2_queue_type(mm_player_streaming_t *streamer, return; } - factory_name = GST_OBJECT_NAME(gst_element_get_factory(buffer_handle->buffer)); - if (!factory_name) { - LOGE("Fail to get factory name!"); - return; - } - - LOGD("target buffer elem : %s", GST_ELEMENT_NAME(buffer_handle->buffer)); - - if (!g_strrstr(factory_name, "queue2")) { - LOGD("only queue2 can use file buffer. not decodebin2 or multiQ"); - return; - } - - if (type == MUXED_BUFFER_TYPE_MEM_QUEUE) { + if (type == MUXED_BUFFER_TYPE_MEM_QUEUE) { /* ts */ LOGD("use memory queue for buffering. streaming is played on push-based. \n" "buffering position would not be updated.\n" "buffered data would be flushed after played.\n" @@ -274,9 +260,10 @@ static void streaming_set_queue2_queue_type(mm_player_streaming_t *streamer, return; } + /* @see ini->http_ring_buffer_size */ buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE_BYTES); - LOGW("[Queue2] set ring buffer size: %"G_GUINT64_FORMAT, buffer_size); + LOGW("ring buffer size: %"G_GUINT64_FORMAT, buffer_size); g_object_set(G_OBJECT(buffer_handle->buffer), "ring-buffer-max-size", buffer_size, NULL); MMPLAYER_FLEAVE(); @@ -302,7 +289,7 @@ static void streaming_set_buffer_size(mm_player_streaming_t *streamer, buffering_time = GET_CURRENT_BUFFERING_TIME(buffer_handle); g_object_set(G_OBJECT(buffer_handle->buffer), - "max-size-bytes", MAX_BUFFER_SIZE_BYTES, /* mq size is fixed, control it with high/low percent value*/ + "max-size-bytes", MAX_BUFFER_SIZE_BYTES, /* mq size is fixed, control it with high/low watermark value*/ "max-size-time", (guint64)(buffering_time * GST_MSECOND), "max-size-buffers", 0, NULL); /* disable */ @@ -345,7 +332,7 @@ void __mm_player_streaming_set_queue2(mm_player_streaming_t *streamer, GstElemen MMPLAYER_FENTER(); MMPLAYER_RETURN_IF_FAIL(streamer && buffer); - LOGD("use queue2 buffering %d", use_buffering); + LOGD("use buffering %d, type %d, content_size %"G_GUINT64_FORMAT, use_buffering, type, content_size); streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer = buffer; @@ -380,7 +367,7 @@ void __mm_player_streaming_set_queue2(mm_player_streaming_t *streamer, GstElemen LOGD("buffer time: %d ms, buffer bytes: %d", queue_size_time, queue_size_bytes); streaming_set_buffer_size(streamer, BUFFER_TYPE_MUXED, queue_size_bytes, queue_size_time); - streaming_set_buffer_percent(streamer, BUFFER_TYPE_MUXED, DEFAULT_BUFFER_HIGH_PERCENT, 0); + streaming_set_buffer_watermark(streamer, BUFFER_TYPE_MUXED, DEFAULT_BUFFER_HIGH_WATERMARK, 0); MMPLAYER_FLEAVE(); return; @@ -400,7 +387,7 @@ void __mm_player_streaming_sync_property(mm_player_streaming_t *streamer, GstEle g_object_set(G_OBJECT(decodebin), "max-size-bytes", buffer_handle->buffering_bytes, "max-size-time", (guint64)(buffer_handle->buffering_time * GST_MSECOND), - "high-percent", (gint)buffer_handle->buffer_high_percent, NULL); + "high-percent", (gint)(buffer_handle->buffer_high_watermark * 100), NULL); } streamer->need_sync = FALSE; @@ -409,7 +396,7 @@ void __mm_player_streaming_sync_property(mm_player_streaming_t *streamer, GstEle void __mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer, GstElement *buffer) { streaming_buffer_t *buffer_handle = NULL; - gdouble high_percent = 0.0; + gdouble high_watermark = 0.0; MMPLAYER_FENTER(); MMPLAYER_RETURN_IF_FAIL(streamer && buffer); @@ -425,12 +412,12 @@ void __mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer, GstEl if (streamer->buffering_req.prebuffer_time <= MIN_BUFFERING_TIME) streamer->buffering_req.prebuffer_time = DEFAULT_PREBUFFERING_TIME; - high_percent = (gdouble)(streamer->buffering_req.prebuffer_time * 100) / MAX_BUFFER_SIZE_TIME; - LOGD("high_percent %2.3f %%", high_percent); + high_watermark = (gdouble)(streamer->buffering_req.prebuffer_time * 100) / MAX_BUFFER_SIZE_TIME; + LOGD("high_watermark %1.3f %%", high_watermark); /* initial setting */ streaming_set_buffer_size(streamer, BUFFER_TYPE_DEMUXED, MAX_BUFFER_SIZE_BYTES, MAX_BUFFER_SIZE_TIME); - streaming_set_buffer_percent(streamer, BUFFER_TYPE_DEMUXED, 0, high_percent); + streaming_set_buffer_watermark(streamer, BUFFER_TYPE_DEMUXED, 0, high_watermark); streamer->need_sync = TRUE; @@ -518,8 +505,8 @@ static void streaming_handle_fixed_buffering_mode(mm_player_streaming_t *streame guint buffering_bytes = 0; gint buffering_time = 0; - gdouble per_byte = 0.0; - gdouble per_time = 0.0; + gdouble wm_byte = 0.0; + gdouble wm_time = 0.0; MMPLAYER_RETURN_IF_FAIL(streamer); MMPLAYER_RETURN_IF_FAIL(buffer_info); @@ -530,7 +517,8 @@ static void streaming_handle_fixed_buffering_mode(mm_player_streaming_t *streame LOGD("buffering time: %d ms, out rate: %d", buffering_time, byte_out_rate); if ((buffering_time > 0) && (byte_out_rate > 0)) { - buffering_bytes = (guint)GET_NEW_BUFFERING_BYTE((gdouble)(byte_out_rate * buffering_time) / 1000); + guint max_size_byte = GET_MAX_BYTE_BUFFER_SIZE(streamer->streaming_buffer_type); + buffering_bytes = (guint)GET_NEW_BUFFERING_BYTE((gdouble)(byte_out_rate * buffering_time) / 1000, max_size_byte); } else { if (buffering_time <= 0) buffering_time = GET_CURRENT_BUFFERING_TIME(buffer_handle); @@ -539,15 +527,15 @@ static void streaming_handle_fixed_buffering_mode(mm_player_streaming_t *streame buffering_bytes = GET_CURRENT_BUFFERING_BYTE(buffer_handle); } - GET_PERCENT(buffering_time, GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_handle->buffer_high_percent, per_time); - GET_PERCENT(buffering_bytes, GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_handle->buffer_high_percent, per_byte); + GET_WATERMARK(buffering_time, GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_handle->buffer_high_watermark, wm_time); + GET_WATERMARK(buffering_bytes, GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_handle->buffer_high_watermark, wm_byte); - LOGD("bytes %d, time %d, per_byte %f, per_time %f", buffering_bytes, buffering_time, per_byte, per_time); + LOGD("bytes %d, time %d, wm_byte %f, wm_time %f", buffering_bytes, buffering_time, wm_byte, wm_time); (*buffer_info).buffering_bytes = buffering_bytes; (*buffer_info).buffering_time = buffering_time; - (*buffer_info).percent_byte = per_byte; - (*buffer_info).percent_time = per_time; + (*buffer_info).watermark_byte = wm_byte; + (*buffer_info).watermark_time = wm_time; } static void streaming_handle_adaptive_buffering_mode(mm_player_streaming_t *streamer, @@ -559,8 +547,8 @@ static void streaming_handle_adaptive_buffering_mode(mm_player_streaming_t *stre gint buffering_bytes = 0; gint adj_buffering_bytes = 0; gint buffer_buffering_time = 0; - gdouble per_byte = 0.0; - gdouble per_time = 0.0; + gdouble wm_byte = 0.0; + gdouble wm_time = 0.0; gdouble portion = 0.0; gint default_buffering_time = 0; @@ -586,9 +574,11 @@ static void streaming_handle_adaptive_buffering_mode(mm_player_streaming_t *stre buffer_handle = &(streamer->buffer_handle[streamer->streaming_buffer_type]); if (bitrate_info.byte_in_rate < bitrate_info.byte_out_rate) { + guint max_size_byte = GET_MAX_BYTE_BUFFER_SIZE(streamer->streaming_buffer_type); portion = (double)(expected_play_time * GST_MSECOND) / (double)content_info.duration; - buffering_bytes = GET_NEW_BUFFERING_BYTE(((double)content_info.content_size * portion) \ - * (1 - (double)bitrate_info.byte_in_rate / (double)bitrate_info.byte_out_rate)); + buffering_bytes = GET_NEW_BUFFERING_BYTE( + (((double)content_info.content_size * portion) * + (1 - (double)bitrate_info.byte_in_rate / (double)bitrate_info.byte_out_rate)), max_size_byte); } else { /* buffering_bytes will be set as streamer->default_val.buffering_time * * receiving rate is bigger than avg content bitrate @@ -609,6 +599,8 @@ static void streaming_handle_adaptive_buffering_mode(mm_player_streaming_t *stre } if (buffer_buffering_time < default_buffering_time) { + guint max_size_byte = GET_MAX_BYTE_BUFFER_SIZE(streamer->streaming_buffer_type); + LOGD("adjusted time: %d -> %d ms", buffer_buffering_time, default_buffering_time); LOGD("adjusted bytes : %d or %d or %d", buffering_bytes, @@ -620,21 +612,22 @@ static void streaming_handle_adaptive_buffering_mode(mm_player_streaming_t *stre streamer->default_val.buffering_monitor = TRUE; buffer_buffering_time = default_buffering_time; - adj_buffering_bytes = GET_NEW_BUFFERING_BYTE(bitrate_info.byte_out_rate * (gint)ceil((gdouble)buffer_buffering_time / 1000)); + adj_buffering_bytes = GET_NEW_BUFFERING_BYTE( + (bitrate_info.byte_out_rate * (gint)ceil((gdouble)buffer_buffering_time / 1000)), max_size_byte); buffering_bytes = MAX(buffering_bytes, adj_buffering_bytes); } - GET_PERCENT(buffering_bytes, GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_handle->buffer_high_percent, per_byte); - GET_PERCENT(buffer_buffering_time, GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_handle->buffer_high_percent, per_time); + GET_WATERMARK(buffering_bytes, GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_handle->buffer_high_watermark, wm_byte); + GET_WATERMARK(buffer_buffering_time, GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_handle->buffer_high_watermark, wm_time); - LOGD("monitor %d, bytes %d, time %d, per_byte %f, per_time %f", + LOGD("monitor %d, bytes %d, time %d, wm_byte %f, wm_time %f", streamer->default_val.buffering_monitor, - buffering_bytes, buffer_buffering_time, per_byte, per_time); + buffering_bytes, buffer_buffering_time, wm_byte, wm_time); (*buffer_info).buffering_bytes = buffering_bytes; (*buffer_info).buffering_time = buffer_buffering_time; - (*buffer_info).percent_byte = per_byte; - (*buffer_info).percent_time = per_time; + (*buffer_info).watermark_byte = wm_byte; + (*buffer_info).watermark_time = wm_time; } @@ -680,8 +673,8 @@ static void streaming_update_buffer_setting(mm_player_streaming_t *streamer, buffer_info.buffering_bytes = buffer_handle->buffering_bytes; buffer_info.buffering_time = buffer_handle->buffering_time; - buffer_info.percent_byte = buffer_handle->buffer_high_percent; - buffer_info.percent_time = buffer_handle->buffer_high_percent; + buffer_info.watermark_byte = buffer_handle->buffer_high_watermark; + buffer_info.watermark_time = buffer_handle->buffer_high_watermark; content_info.position = position; content_info.duration = duration; @@ -719,12 +712,12 @@ static void streaming_update_buffer_setting(mm_player_streaming_t *streamer, streaming_set_buffer_size(streamer, streamer->streaming_buffer_type, buffer_info.buffering_bytes, buffer_info.buffering_time); } - streaming_set_buffer_percent(streamer, streamer->streaming_buffer_type, buffer_info.percent_byte, buffer_info.percent_time); + streaming_set_buffer_watermark(streamer, streamer->streaming_buffer_type, buffer_info.watermark_byte, buffer_info.watermark_time); - LOGD("buffer setting: size %d, time %d, per %f", + LOGD("buffer setting: size %d, time %d, watermark %f", GET_CURRENT_BUFFERING_BYTE(buffer_handle), GET_CURRENT_BUFFERING_TIME(buffer_handle), - buffer_handle->buffer_high_percent); + buffer_handle->buffer_high_watermark); streamer->need_sync = TRUE; } -- 2.7.4