[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

diff --git a/packaging/libmm-player.spec b/packaging/libmm-player.spec
index c93a330..d75648c 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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;
 }