*
*/
-#include <sys/vfs.h>
#include <dlog.h>
#include "mm_player_utils.h"
#include "mm_player_streaming.h"
+#define ESTIMATED_BUFFER_UNIT (1 * 1024 * 1024) /* 1 MBytes */
+
typedef struct {
gint byte_in_rate; // byte
gint byte_out_rate; // byte
gint time_rate; // ms
- guint buffer_criteria; // byte
} streaming_bitrate_info_t;
typedef struct {
typedef struct {
guint buffering_bytes; // bytes
gint buffering_time; // ms
- gdouble percent_byte;
- gdouble percent_time;
+ gdouble low_watermark;
+ gdouble high_watermark;
} streaming_buffer_info_t;
-static void streaming_check_buffer_percent(gdouble in_low, gdouble in_high, gdouble *out_low, gdouble *out_high);
-static void streaming_set_buffer_percent(mm_player_streaming_t* streamer, BufferType type, gdouble low_percent, gdouble high_percent_byte, gdouble high_percent_time);
-static void streaming_set_queue2_queue_type(mm_player_streaming_t* streamer, MuxedBufferType type, gchar * file_path, 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);
-static void streaming_get_current_bitrate_info(mm_player_streaming_t* streamer,
- GstMessage *buffering_msg,
- streaming_content_info_t content_info,
- streaming_bitrate_info_t* bitrate_info);
-static void
-streaming_handle_fixed_buffering_mode(mm_player_streaming_t* streamer,
- gint byte_out_rate,
- gint fixed_buffering_time,
- streaming_buffer_info_t* buffer_info);
-static void
-streaming_handle_adaptive_buffering_mode(mm_player_streaming_t* streamer,
- streaming_content_info_t content_info,
- streaming_bitrate_info_t bitrate_info,
- streaming_buffer_info_t* buffer_info,
- gint expected_play_time);
static void
-streaming_update_buffer_setting(mm_player_streaming_t* streamer,
- GstMessage *buffering_msg,
- guint64 content_size,
- gint64 position,
- gint64 duration);
-
-mm_player_streaming_t *
-__mm_player_streaming_create(void)
+__streaming_update_buffer_setting(mmplayer_streaming_t *streamer,
+ GstMessage *buffering_msg,
+ guint64 content_size,
+ gint64 position,
+ gint64 duration);
+
+mmplayer_streaming_t *_mm_player_streaming_create(void)
{
- mm_player_streaming_t *streamer = NULL;
+ mmplayer_streaming_t *streamer = NULL;
MMPLAYER_FENTER();
- streamer = (mm_player_streaming_t *) g_malloc0(sizeof(mm_player_streaming_t));
+ streamer = (mmplayer_streaming_t *)g_try_malloc0(sizeof(mmplayer_streaming_t));
if (!streamer) {
- LOGE("fail to create streaming player handle..\n");
+ LOGE("fail to create streaming player handle..");
return NULL;
}
return streamer;
}
-static void
-streaming_buffer_initialize(streaming_buffer_t* buffer_handle, gboolean buffer_init)
+static void __streaming_buffer_initialize(streaming_buffer_t *buffer_handle, gboolean buffer_init)
{
if (buffer_init)
buffer_handle->buffer = NULL;
buffer_handle->buffering_bytes = DEFAULT_BUFFER_SIZE_BYTES;
buffer_handle->buffering_time = DEFAULT_BUFFERING_TIME;
- buffer_handle->buffer_low_percent = DEFAULT_BUFFER_LOW_PERCENT;
- buffer_handle->buffer_high_percent = DEFAULT_BUFFER_HIGH_PERCENT;
+ buffer_handle->buffer_high_watermark = DEFAULT_BUFFER_HIGH_WATERMARK;
+ buffer_handle->buffer_low_watermark = DEFAULT_BUFFER_LOW_WATERMARK;
buffer_handle->is_live = FALSE;
-
-}
-
-void __mm_player_streaming_initialize(mm_player_streaming_t* streamer)
-{
- MMPLAYER_FENTER();
-
- streamer->streaming_buffer_type = BUFFER_TYPE_DEFAULT; // multi-queue
-
- streaming_buffer_initialize(&(streamer->buffer_handle[BUFFER_TYPE_MUXED]), TRUE);
- streaming_buffer_initialize(&(streamer->buffer_handle[BUFFER_TYPE_DEMUXED]), TRUE);
-
- streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_ADAPTIVE;
- streamer->buffering_req.is_pre_buffering = FALSE;
- streamer->buffering_req.prebuffer_time = 0;
- streamer->buffering_req.rebuffer_time = 0;
-
- streamer->default_val.buffering_monitor = FALSE;
- streamer->default_val.buffering_time = DEFAULT_BUFFERING_TIME;
-
- streamer->buffer_avg_bitrate = 0;
- streamer->buffer_max_bitrate = 0;
- streamer->need_update = FALSE;
- streamer->need_sync = FALSE;
-
- streamer->buffering_state = MM_PLAYER_BUFFERING_DEFAULT;
- streamer->is_adaptive_streaming = FALSE;
-
- streamer->buffering_percent = -1;
- streamer->ring_buffer_size = DEFAULT_RING_BUFFER_SIZE;
-
- MMPLAYER_FLEAVE();
- return;
}
-void __mm_player_streaming_deinitialize(mm_player_streaming_t* streamer)
+void _mm_player_streaming_initialize(mmplayer_streaming_t *streamer, gboolean buffer_init)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer);
- streamer->streaming_buffer_type = BUFFER_TYPE_DEFAULT; // multi-queue
+ streamer->streaming_buffer_type = BUFFER_TYPE_DEFAULT;
- streaming_buffer_initialize(&(streamer->buffer_handle[BUFFER_TYPE_MUXED]), FALSE);
- streaming_buffer_initialize(&(streamer->buffer_handle[BUFFER_TYPE_DEMUXED]), FALSE);
+ __streaming_buffer_initialize(&(streamer->buffer_handle[BUFFER_TYPE_MUXED]), buffer_init);
+ __streaming_buffer_initialize(&(streamer->buffer_handle[BUFFER_TYPE_DEMUXED]), buffer_init);
streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_ADAPTIVE;
- streamer->buffering_req.is_pre_buffering = FALSE;
+ streamer->buffering_req.is_pre_buffering = TRUE;
streamer->buffering_req.prebuffer_time = 0;
streamer->buffering_req.rebuffer_time = 0;
streamer->is_adaptive_streaming = FALSE;
streamer->buffering_percent = -1;
- streamer->ring_buffer_size = DEFAULT_RING_BUFFER_SIZE;
+ streamer->ring_buffer_size = DEFAULT_RING_BUFFER_SIZE_BYTES;
MMPLAYER_FLEAVE();
return;
}
-void __mm_player_streaming_destroy(mm_player_streaming_t* streamer)
+void _mm_player_streaming_destroy(mmplayer_streaming_t *streamer)
{
MMPLAYER_FENTER();
- g_free(streamer);
+ MMPLAYER_FREEIF(streamer);
MMPLAYER_FLEAVE();
return;
}
-void __mm_player_streaming_set_content_bitrate(mm_player_streaming_t* streamer, guint max_bitrate, guint avg_bitrate)
+void _mm_player_streaming_set_content_bitrate(
+ mmplayer_streaming_t *streamer, guint max_bitrate, guint avg_bitrate)
{
- MMPLAYER_FENTER();
+ gboolean is_update = FALSE;
+ MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer);
- /* Note : Update buffering criterion bytes
- * 1. maximum bitrate is considered first.
- * 2. average bitrage * 3 is next.
- * 3. if there are no updated bitrate, use default buffering limit.
- */
- if (max_bitrate > 0 && streamer->buffer_max_bitrate != max_bitrate) {
- LOGD("set maximum bitrate(%dbps).\n", max_bitrate);
+ if (max_bitrate > 0 && max_bitrate != streamer->buffer_max_bitrate) {
+ is_update = TRUE;
streamer->buffer_max_bitrate = max_bitrate;
- if (streamer->buffering_req.is_pre_buffering == FALSE) {
- streamer->need_update = TRUE;
- } else {
- LOGD("pre-buffering...\n");
-
- if (IS_MUXED_BUFFERING_MODE(streamer))
- streaming_update_buffer_setting(streamer, NULL, 0, 0, 0);
- }
}
- if (avg_bitrate > 0 && streamer->buffer_avg_bitrate != avg_bitrate) {
- LOGD("set averate bitrate(%dbps).\n", avg_bitrate);
+ if (avg_bitrate > 0 && avg_bitrate != streamer->buffer_avg_bitrate) {
+ is_update = TRUE;
streamer->buffer_avg_bitrate = avg_bitrate;
+ }
- if (streamer->buffering_req.is_pre_buffering == FALSE) {
- streamer->need_update = TRUE;
- } else {
- LOGD("pre-buffering...\n");
-
+ if (is_update) {
+ if (streamer->buffering_req.is_pre_buffering) {
+ /* have to recalc queue2 size value after getting bitrate information */
if (IS_MUXED_BUFFERING_MODE(streamer))
- streaming_update_buffer_setting(streamer, NULL, 0, 0, 0);
+ __streaming_update_buffer_setting(streamer, NULL, 0, 0, 0);
+ } else {
+ streamer->need_update = TRUE;
}
}
return;
}
-static void
-streaming_check_buffer_percent(gdouble in_low, gdouble in_high, gdouble *out_low, gdouble *out_high)
+static void __streaming_calc_watermark(mmplayer_streaming_t *streamer,
+ guint expected_play_bytes, gint expected_play_time, gdouble *low_wm, gdouble *high_wm)
{
- gdouble buffer_low_percent = DEFAULT_BUFFER_LOW_PERCENT;
- gdouble buffer_high_percent = DEFAULT_BUFFER_HIGH_PERCENT;
+#define PORTION_OF_HIGH_WM 1.1 /* need to compensate about low level */
+#define PORTION_OF_LOW_WM 0.1
- MMPLAYER_FENTER();
+ streaming_buffer_t *buffer_handle = NULL;
+ gdouble wm_byte = 0.0, wm_time = 0.0;
+ gint current_buffering_size = 0;
- MMPLAYER_RETURN_IF_FAIL(out_low && out_high);
+ MMPLAYER_RETURN_IF_FAIL(streamer && low_wm && high_wm);
- if (in_low <= MIN_BUFFER_PERCENT || in_low >= MAX_BUFFER_PERCENT)
- LOGW("buffer low percent is out of range. use defaut value.");
- else
- buffer_low_percent = in_low;
+ buffer_handle = &(streamer->buffer_handle[streamer->streaming_buffer_type]);
- if (in_high <= MIN_BUFFER_PERCENT || in_high >= MAX_BUFFER_PERCENT)
- LOGW("buffer high percent is out of range. use defaut value.");
- else
- buffer_high_percent = in_high;
+ LOGD("type %d, bytes %d / %d, time %d / %d", streamer->streaming_buffer_type,
+ expected_play_bytes, GET_CURRENT_BUFFERING_BYTE(buffer_handle),
+ expected_play_time, GET_CURRENT_BUFFERING_TIME(buffer_handle));
- if (buffer_high_percent <= buffer_low_percent)
- buffer_high_percent = buffer_low_percent + 1.0;
+ if (expected_play_bytes > 0) {
+ /* and buffer size will be increased */
+ current_buffering_size = MAX(GET_CURRENT_BUFFERING_BYTE(buffer_handle), (expected_play_bytes * PORTION_OF_HIGH_WM));
+ GET_WATERMARK((expected_play_bytes * PORTION_OF_HIGH_WM), current_buffering_size, buffer_handle->buffer_high_watermark, wm_byte);
+ wm_byte = MIN(wm_byte, DEFAULT_BUFFER_HIGH_WATERMARK);
+ }
+
+ if (IS_MUXED_BUFFERING_MODE(streamer)) {
+ *high_wm = wm_byte;
+ *low_wm = wm_byte * PORTION_OF_LOW_WM;
+
+ /* If user set the very low level buffering time,
+ buffer underrun could be occurred even if the min range is considered. */
+ GET_VALID_VALUE((*low_wm), LOW_WATERMARK_MIN_BYTE_LEVEL, DEFAULT_BUFFER_LOW_WATERMARK);
+ } else {
+ gdouble prev_low_wm_time = 0.0;
+ gdouble low_wm_time = 0.0, high_wm_time = 0.0;
+
+ expected_play_time = MAX(expected_play_time, LOW_WATERMARK_MIN_TIME_VALUE);
+ low_wm_time = expected_play_time * PORTION_OF_LOW_WM;
+ high_wm_time = expected_play_time * PORTION_OF_HIGH_WM;
+
+ /* 1. Get min watermark value */
+ /* 1-1. get max buffer size, expected time could be greater than current one */
+ LOGE("low wm time : %.3f ms", low_wm_time);
+ current_buffering_size = MAX(GET_CURRENT_BUFFERING_TIME(buffer_handle), high_wm_time);
+
+ /* 1-2. get previous low time value to keep the minimum watermark */
+ prev_low_wm_time = GET_CURRENT_BUFFERING_TIME(buffer_handle) * buffer_handle->buffer_low_watermark;
+ GET_VALID_VALUE(low_wm_time, LOW_WATERMARK_MIN_TIME_VALUE, prev_low_wm_time);
+
+ /* 1-3. get min watermark value based on the max buffer size */
+ GET_WATERMARK(low_wm_time, current_buffering_size, buffer_handle->buffer_low_watermark, *low_wm);
+ *low_wm = MIN(*low_wm, DEFAULT_BUFFER_LOW_WATERMARK);
+
+ /* 2. Get high watermark value.
+ If the expected time is greater than current one, the buffer size will be increased after */
+ GET_WATERMARK(high_wm_time, current_buffering_size, buffer_handle->buffer_high_watermark, wm_time);
+ *high_wm = MAX(wm_byte, wm_time);
+ *high_wm = MIN(*high_wm, DEFAULT_BUFFER_HIGH_WATERMARK);
+ }
- LOGD("set buffer percent to %2.3f ~ %2.3f.", buffer_low_percent, buffer_high_percent);
+ if (*low_wm >= *high_wm) {
+ LOGW("invalid high wm value %1.3f", *high_wm);
+ *high_wm = DEFAULT_BUFFER_HIGH_WATERMARK;
+ }
- *out_low = buffer_low_percent;
- *out_high = buffer_high_percent;
+ LOGD("new watermark value [%f ~ %f]", *low_wm, *high_wm);
}
-static void
-streaming_set_buffer_percent(mm_player_streaming_t* streamer,
- BufferType type,
- gdouble low_percent,
- gdouble high_percent_byte,
- gdouble high_percent_time)
+static void __streaming_set_buffer_watermark(mmplayer_streaming_t *streamer,
+ buffer_type_e type, gdouble low_watermark, gdouble high_watermark)
{
- gdouble confirmed_low = DEFAULT_BUFFER_LOW_PERCENT;
- gdouble confirmed_high = DEFAULT_BUFFER_HIGH_PERCENT;
- gdouble high_percent = 0.0;
-
- streaming_buffer_t* buffer_handle = NULL;
- gchar* factory_name = NULL;
+ streaming_buffer_t *buffer_handle = NULL;
+ gchar *factory_name = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer);
return;
}
- if (type == BUFFER_TYPE_MUXED)
- high_percent = high_percent_byte;
- else
- high_percent = MAX(high_percent_time, high_percent_byte);
+ if (high_watermark <= MIN_BUFFER_WATERMARK || high_watermark >= MAX_BUFFER_WATERMARK)
+ high_watermark = DEFAULT_BUFFER_HIGH_WATERMARK;
- streaming_check_buffer_percent(low_percent, high_percent, &confirmed_low, &confirmed_high);
+ if (low_watermark <= MIN_BUFFER_WATERMARK || low_watermark >= MAX_BUFFER_WATERMARK)
+ low_watermark = DEFAULT_BUFFER_LOW_WATERMARK;
/* if use-buffering is disabled, this settings do not have any meaning. */
- LOGD("target buffer elem : %s (%2.3f ~ %2.3f)",
- GST_ELEMENT_NAME(buffer_handle->buffer), confirmed_low, confirmed_high);
-
- if ((confirmed_low == DEFAULT_BUFFER_LOW_PERCENT) ||
- (buffer_handle->buffer_low_percent != confirmed_low))
- g_object_set(G_OBJECT(buffer_handle->buffer), "low-percent", (gint)confirmed_low, NULL);
+ if ((high_watermark == DEFAULT_BUFFER_HIGH_WATERMARK) ||
+ (buffer_handle->buffer_high_watermark != high_watermark) ||
+ (buffer_handle->buffer_low_watermark != low_watermark))
+ g_object_set(G_OBJECT(buffer_handle->buffer), "high-watermark", high_watermark,
+ "low-watermark", low_watermark, NULL);
- if ((confirmed_high == DEFAULT_BUFFER_HIGH_PERCENT) ||
- (buffer_handle->buffer_high_percent != confirmed_high))
- g_object_set(G_OBJECT(buffer_handle->buffer), "high-percent", (gint)confirmed_high, NULL);
+ LOGD("update elem:%s, wm:%1.3f ~ %1.3f", GST_ELEMENT_NAME(buffer_handle->buffer), low_watermark, high_watermark);
- buffer_handle->buffer_low_percent = confirmed_low;
- buffer_handle->buffer_high_percent = confirmed_high;
+ buffer_handle->buffer_high_watermark = high_watermark;
+ buffer_handle->buffer_low_watermark = low_watermark;
MMPLAYER_FLEAVE();
return;
}
-static void
-streaming_set_queue2_queue_type(mm_player_streaming_t* streamer, MuxedBufferType type, gchar * file_path, guint64 content_size)
+static void __streaming_set_queue2_queue_type(mmplayer_streaming_t *streamer, muxed_buffer_type_e type)
{
- streaming_buffer_t* buffer_handle = NULL;
- guint64 storage_available_size = 0; /* bytes */
+ streaming_buffer_t *buffer_handle = NULL;
guint64 buffer_size = 0; /* bytes */
- gchar file_buffer_name[MM_MAX_URL_LEN] = {0};
- struct statfs buf = {0};
- gchar* factory_name = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer);
buffer_handle = &(streamer->buffer_handle[BUFFER_TYPE_MUXED]);
- if (!(buffer_handle && buffer_handle->buffer)) {
- LOGE("buffer_handle->buffer is NULL!");
- 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\n");
- 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"
return;
}
- LOGD("[Queue2] buffering type : %d. streaming is played on pull-based. \n", type);
- if (type == MUXED_BUFFER_TYPE_FILE && file_path && strlen(file_path) > 0) {
- if (statfs((const char *)file_path, &buf) < 0) {
- LOGW("[Queue2] fail to get available storage capacity. set mem ring buffer instead of file buffer.\n");
- buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE);
- } else {
- storage_available_size = (guint64)buf.f_bavail * (guint64)buf.f_bsize; //bytes
-
- LOGD("[Queue2] the number of available blocks : %"G_GUINT64_FORMAT
- ", the block size is %"G_GUINT64_FORMAT".\n",
- (guint64)buf.f_bavail, (guint64)buf.f_bsize);
+ /* @see ini->http_ring_buffer_size */
+ buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE_BYTES);
- LOGD("[Queue2] calculated available storage size is %"
- G_GUINT64_FORMAT" Bytes.\n", storage_available_size);
-
- if (content_size <= 0 || content_size >= storage_available_size)
- buffer_size = storage_available_size;
- else
- buffer_size = 0L;
-
- g_snprintf(file_buffer_name, MM_MAX_URL_LEN, "%sXXXXXX", file_path);
- SECURE_LOGD("[Queue2] the buffering file name is %s.\n", file_buffer_name);
-
- g_object_set(G_OBJECT(buffer_handle->buffer), "temp-template", file_buffer_name, NULL);
- }
- } else {
- buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE);
- }
-
- 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();
return;
}
-static void
-streaming_set_buffer_size(mm_player_streaming_t* streamer, BufferType type, guint buffering_bytes, gint buffering_time)
+static void __streaming_set_buffer_size(mmplayer_streaming_t *streamer,
+ buffer_type_e type, guint buffering_bytes, gint buffering_time)
{
- streaming_buffer_t* buffer_handle = NULL;
+ streaming_buffer_t *buffer_handle = NULL;
MMPLAYER_FENTER();
buffering_time = GET_CURRENT_BUFFERING_TIME(buffer_handle);
g_object_set(G_OBJECT(buffer_handle->buffer),
- "max-size-bytes", GET_MAX_BUFFER_BYTES(streamer), /* 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 */
+ "max-size-buffers", 0, /* disable */
+ "use-interleave", FALSE, NULL);
- buffer_handle->buffering_time = buffering_time;
- buffer_handle->buffering_bytes = GET_MAX_BUFFER_BYTES(streamer);
+ GET_CURRENT_BUFFERING_TIME(buffer_handle) = buffering_time;
+ GET_CURRENT_BUFFERING_BYTE(buffer_handle) = MAX_BUFFER_SIZE_BYTES;
- LOGD("max-size-time : %d ms", buffering_time);
+ LOGD("byte: %d, max-size-time : %d ms", buffering_bytes, buffering_time);
} else {
/* queue2 */
if (buffer_handle->is_live)
g_object_set(G_OBJECT(buffer_handle->buffer),
"max-size-bytes", buffering_bytes,
- "max-size-time", (guint64)(buffering_time*GST_MSECOND),
+ "max-size-time", (guint64)(buffering_time * GST_MSECOND),
"max-size-buffers", 0,
"use-rate-estimate", TRUE, NULL);
else
"max-size-buffers", 0,
"use-rate-estimate", FALSE, NULL);
- buffer_handle->buffering_bytes = buffering_bytes;
- buffer_handle->buffering_time = buffering_time;
+ GET_CURRENT_BUFFERING_BYTE(buffer_handle) = buffering_bytes;
+ GET_CURRENT_BUFFERING_TIME(buffer_handle) = buffering_time;
- LOGD("max-size-bytes : %d", buffering_bytes);
+ LOGD("max-size-bytes : %d, time : %d", buffering_bytes, buffering_time);
}
}
return;
}
-void __mm_player_streaming_set_queue2(mm_player_streaming_t* streamer,
- GstElement* buffer,
- gboolean use_buffering,
- guint buffering_bytes,
- gint buffering_time,
- gdouble low_percent,
- gdouble high_percent,
- MuxedBufferType type,
- gchar* file_path,
- guint64 content_size)
+void _mm_player_streaming_set_queue2(mmplayer_streaming_t *streamer, GstElement *buffer,
+ gboolean use_buffering, muxed_buffer_type_e type, guint64 content_size)
{
+ guint queue_size_bytes = 0;
+ guint queue_size_time = 0;
+
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL(streamer);
+ MMPLAYER_RETURN_IF_FAIL(streamer && buffer);
- if (buffer) {
- LOGD("USE-BUFFERING : %s", (use_buffering) ? "OOO" : "XXX");
+ LOGD("use buffering %d, type %d, content_size %"G_GUINT64_FORMAT, use_buffering, type, content_size);
- streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer = buffer;
+ streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer = buffer;
- if (use_buffering) {
- streamer->streaming_buffer_type = BUFFER_TYPE_MUXED;
+ if (use_buffering) { /* audio only content use queue2 for buffering */
+ streamer->streaming_buffer_type = BUFFER_TYPE_MUXED;
- if (content_size > 0) {
- if (streamer->buffering_req.prebuffer_time > 0)
- streamer->buffering_req.is_pre_buffering = TRUE;
- else
- streamer->buffering_req.prebuffer_time = buffering_time;
- } else {
- LOGD("live streaming without mq");
+ if (streamer->buffering_req.prebuffer_time <= MIN_BUFFERING_TIME)
+ streamer->buffering_req.prebuffer_time = DEFAULT_PREBUFFERING_TIME;
- streamer->buffer_handle[BUFFER_TYPE_MUXED].is_live = TRUE;
- streamer->buffering_req.prebuffer_time = buffering_time = DEFAULT_BUFFERING_TIME;
- }
+ if (content_size == 0) {
+ LOGD("live streaming without mq");
+ streamer->buffer_handle[BUFFER_TYPE_MUXED].is_live = TRUE;
+ }
+
+ /* keep estimated value till the pipeline share the bitrate information */
+ queue_size_bytes = (guint)(streamer->buffering_req.prebuffer_time / 1000) * ESTIMATED_BUFFER_UNIT; /* temp size */
+ queue_size_bytes = MAX(queue_size_bytes, DEFAULT_BUFFER_SIZE_BYTES);
+ queue_size_time = streamer->buffering_req.prebuffer_time;
+ } else {
+ if (type >= MUXED_BUFFER_TYPE_MAX) {
+ LOGE("invalid queue type");
+ return;
}
- g_object_set(G_OBJECT(streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), "use-buffering", use_buffering, NULL);
+ /* set the simple queue size */
+ queue_size_bytes = DEFAULT_BUFFER_SIZE_BYTES;
+ __streaming_set_queue2_queue_type(streamer, type);
+ queue_size_time = 0; /* set in case of use-buffering */
}
- /* initial setting */
- streaming_set_buffer_size(streamer, BUFFER_TYPE_MUXED, buffering_bytes, buffering_time);
- streaming_set_buffer_percent(streamer, BUFFER_TYPE_MUXED, low_percent, high_percent, 0);
- if (type < MUXED_BUFFER_TYPE_MAX)
- streaming_set_queue2_queue_type(streamer, type, file_path, content_size);
+ g_object_set(G_OBJECT(streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), "use-buffering", use_buffering, NULL);
+
+ 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_watermark(streamer, BUFFER_TYPE_MUXED, DEFAULT_BUFFER_LOW_WATERMARK, DEFAULT_BUFFER_HIGH_WATERMARK);
MMPLAYER_FLEAVE();
return;
}
-void __mm_player_streaming_sync_property(mm_player_streaming_t* streamer, GstElement* decodebin)
+void _mm_player_streaming_sync_property(mmplayer_streaming_t *streamer, GstElement *decodebin)
{
- streaming_buffer_t* buffer_handle = NULL;
+ streaming_buffer_t *buffer_handle = NULL;
MMPLAYER_FENTER();
-
MMPLAYER_RETURN_IF_FAIL(streamer && decodebin);
+ if ((!streamer->need_sync) || (streamer->streaming_buffer_type != BUFFER_TYPE_DEMUXED)) {
+ streamer->need_sync = FALSE;
+ return;
+ }
+
buffer_handle = &(streamer->buffer_handle[BUFFER_TYPE_DEMUXED]);
- if ((streamer->need_sync) && (streamer->streaming_buffer_type == BUFFER_TYPE_DEMUXED)) {
- g_object_set(G_OBJECT(decodebin),
- "max-size-bytes", buffer_handle->buffering_bytes,
- "max-size-time", (guint64)(buffer_handle->buffering_time * GST_MSECOND),
- "low-percent", (gint)buffer_handle->buffer_low_percent,
- "high-percent", (gint)buffer_handle->buffer_high_percent, NULL);
- }
+ LOGD("sync : %1.3f ~ %1.3f", buffer_handle->buffer_low_watermark, buffer_handle->buffer_high_watermark);
+ g_object_set(G_OBJECT(decodebin),
+ "max-size-bytes", GET_CURRENT_BUFFERING_BYTE(buffer_handle),
+ "max-size-time", (guint64)(GET_CURRENT_BUFFERING_TIME(buffer_handle) * GST_MSECOND),
+ "high-percent", (gint)(buffer_handle->buffer_high_watermark * 100),
+ "low-percent", (gint)(buffer_handle->buffer_low_watermark * 100), NULL);
streamer->need_sync = FALSE;
}
-void __mm_player_streaming_set_multiqueue(mm_player_streaming_t* streamer,
- GstElement* buffer,
- gint buffering_time,
- gdouble low_percent,
- gdouble high_percent)
+void _mm_player_streaming_set_multiqueue(mmplayer_streaming_t *streamer, GstElement *buffer)
{
- streaming_buffer_t* buffer_handle = NULL;
+ streaming_buffer_t *buffer_handle = NULL;
+ gdouble high_wm = 0.0, low_wm = 0.0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer && buffer);
buffer_handle = &(streamer->buffer_handle[BUFFER_TYPE_DEMUXED]);
-
buffer_handle->buffer = buffer;
+ LOGD("pre_buffering: %d ms", streamer->buffering_req.prebuffer_time);
+
streamer->streaming_buffer_type = BUFFER_TYPE_DEMUXED;
g_object_set(G_OBJECT(buffer_handle->buffer), "use-buffering", TRUE, NULL);
-
- LOGD("pre_buffering: %d ms, during playing: %d ms\n", streamer->buffering_req.prebuffer_time, buffering_time);
-
- if (streamer->buffering_req.prebuffer_time > 0)
- streamer->buffering_req.is_pre_buffering = TRUE;
- else
- streamer->buffering_req.prebuffer_time = GET_DEFAULT_PLAYING_TIME(streamer);
-
- high_percent = (gdouble)(streamer->buffering_req.prebuffer_time * 100) / GET_MAX_BUFFER_TIME(streamer);
- LOGD("high_percent %2.3f %%\n", high_percent);
+ if (streamer->buffering_req.prebuffer_time <= MIN_BUFFERING_TIME)
+ streamer->buffering_req.prebuffer_time = DEFAULT_PREBUFFERING_TIME;
/* initial setting */
- streaming_set_buffer_size(streamer, BUFFER_TYPE_DEMUXED, GET_MAX_BUFFER_BYTES(streamer), GET_MAX_BUFFER_TIME(streamer));
- streaming_set_buffer_percent(streamer, BUFFER_TYPE_DEMUXED, low_percent, 0, high_percent);
+ __streaming_set_buffer_size(streamer, BUFFER_TYPE_DEMUXED, MAX_BUFFER_SIZE_BYTES, MAX_BUFFER_SIZE_TIME);
+
+ __streaming_calc_watermark(streamer, 0, streamer->buffering_req.prebuffer_time, &low_wm, &high_wm);
+ __streaming_set_buffer_watermark(streamer, BUFFER_TYPE_DEMUXED, low_wm, high_wm);
streamer->need_sync = TRUE;
return;
}
-static void
-streaming_get_current_bitrate_info(mm_player_streaming_t* streamer,
- GstMessage *buffering_msg,
- streaming_content_info_t content_info,
- streaming_bitrate_info_t* bitrate_info)
+static void __streaming_get_current_bitrate_info(mmplayer_streaming_t *streamer,
+ GstMessage *buffering_msg, streaming_content_info_t content_info, streaming_bitrate_info_t *bitrate_info)
{
-
GstQuery *query = NULL;
GstBufferingMode mode = GST_BUFFERING_STREAM;
gint in_rate = 0;
gint out_rate = 0;
gint64 buffering_left = -1;
- guint buffer_criteria = 0;
guint estimated_content_bitrate = 0;
gint buffer_buffering_time = DEFAULT_BUFFERING_TIME;
LOGD("Streaming Info : in %d, out %d, left %"G_GINT64_FORMAT, in_rate, out_rate, buffering_left);
- if ((content_info.content_size > 0) && (content_info.duration > 0) && ((content_info.duration/GST_SECOND) > 0))
- estimated_content_bitrate = GET_BIT_FROM_BYTE((guint)(content_info.content_size / (content_info.duration/GST_SECOND)));
+ if ((content_info.content_size > 0) && (content_info.duration > 0) && ((content_info.duration / GST_SECOND) > 0))
+ estimated_content_bitrate = GET_BIT_FROM_BYTE((guint)(content_info.content_size / (content_info.duration / GST_SECOND)));
if (streamer->buffer_max_bitrate > 0) {
streamer->buffer_max_bitrate = MAX(streamer->buffer_max_bitrate, streamer->buffer_avg_bitrate);
streamer->buffer_max_bitrate = MAX(streamer->buffer_max_bitrate, estimated_content_bitrate);
+ }
- buffer_criteria = GET_BYTE_FROM_BIT(streamer->buffer_max_bitrate);
-
- if (streamer->buffer_avg_bitrate > estimated_content_bitrate)
- out_rate = GET_BYTE_FROM_BIT(streamer->buffer_avg_bitrate);
- else if (estimated_content_bitrate != 0)
- out_rate = GET_BYTE_FROM_BIT(estimated_content_bitrate);
- else
- out_rate = GET_BYTE_FROM_BIT(streamer->buffer_max_bitrate/3);
-
- LOGD("(max)content_max_byte_rate %d, byte_out_rate %d\n", buffer_criteria, out_rate);
- } else if (streamer->buffer_avg_bitrate > 0) {
- buffer_criteria = GET_BYTE_FROM_BIT(streamer->buffer_avg_bitrate * 3);
+ if (streamer->buffer_avg_bitrate > 0)
out_rate = GET_BYTE_FROM_BIT(MAX(streamer->buffer_avg_bitrate, estimated_content_bitrate));
+ else if (estimated_content_bitrate > 0)
+ out_rate = GET_BYTE_FROM_BIT(estimated_content_bitrate);
+ else if (streamer->buffer_max_bitrate > 0)
+ out_rate = GET_BYTE_FROM_BIT(streamer->buffer_max_bitrate/3);
+ else
+ LOGW("There is no content information");
- LOGD("(avg)content_max_byte_rate %d, byte_out_rate %d\n", buffer_criteria, out_rate);
- } else {
- LOGW("There is no content bitrate information\n");
- }
+ LOGD("byte_out_rate %d", out_rate);
if ((in_rate > 0) && (out_rate > 0))
- buffer_buffering_time = (gint)(out_rate / in_rate)*1000;
+ buffer_buffering_time = (gint)(out_rate / in_rate) * 1000;
else if ((in_rate <= 0) && (out_rate > 0))
buffer_buffering_time = MAX_BUFFERING_TIME;
else
(*bitrate_info).byte_in_rate = in_rate;
(*bitrate_info).byte_out_rate = out_rate;
(*bitrate_info).time_rate = buffer_buffering_time;
- (*bitrate_info).buffer_criteria = buffer_criteria;
}
-static void
-streaming_handle_fixed_buffering_mode(mm_player_streaming_t* streamer,
- gint byte_out_rate,
- gint fixed_buffering_time,
- streaming_buffer_info_t* buffer_info)
+static void __streaming_handle_fixed_buffering_mode(mmplayer_streaming_t *streamer,
+ gint byte_out_rate, gint expected_play_time, streaming_buffer_info_t *buffer_info)
{
- streaming_buffer_t* buffer_handle = NULL;
+ streaming_buffer_t *buffer_handle = NULL;
- guint buffering_bytes = 0;
- gint buffering_time = 0;
- gdouble per_byte = 0.0;
- gdouble per_time = 0.0;
+ guint expected_play_bytes = 0;
+ gdouble high_wm = 0.0, low_wm = 0.0;
MMPLAYER_RETURN_IF_FAIL(streamer);
MMPLAYER_RETURN_IF_FAIL(buffer_info);
buffer_handle = &(streamer->buffer_handle[streamer->streaming_buffer_type]);
- buffering_time = fixed_buffering_time;
- LOGD("buffering time: %d ms, out rate: %d\n", buffering_time, byte_out_rate);
+ LOGD("buffering time: %d ms, out rate: %d", expected_play_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);
+ if (byte_out_rate > 0) {
+ guint max_size_byte = GET_MAX_BUFFER_SIZE_BYTES(streamer->streaming_buffer_type);
+ expected_play_bytes = (guint)GET_NEW_BUFFERING_BYTE((gdouble)(byte_out_rate * expected_play_time) / 1000, max_size_byte);
} else {
- if (buffering_time <= 0)
- buffering_time = GET_CURRENT_BUFFERING_TIME(buffer_handle);
-
- LOGW("content bitrate is not updated yet.\n");
- buffering_bytes = GET_CURRENT_BUFFERING_BYTE(buffer_handle);
+ LOGW("content bitrate is not updated yet.");
+ expected_play_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);
+ __streaming_calc_watermark(streamer, expected_play_bytes, expected_play_time, &low_wm, &high_wm);
- LOGD("bytes %d, time %d, per_byte %f, per_time %f\n", buffering_bytes, buffering_time, per_byte, per_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).buffering_bytes = expected_play_bytes;
+ (*buffer_info).buffering_time = expected_play_time;
+ (*buffer_info).high_watermark = high_wm;
+ (*buffer_info).low_watermark = low_wm;
}
-static void
-streaming_handle_adaptive_buffering_mode(mm_player_streaming_t* streamer,
- streaming_content_info_t content_info,
- streaming_bitrate_info_t bitrate_info,
- streaming_buffer_info_t* buffer_info,
- gint expected_play_time)
+static void __streaming_handle_adaptive_buffering_mode(mmplayer_streaming_t *streamer,
+ streaming_content_info_t content_info, streaming_bitrate_info_t bitrate_info,
+ streaming_buffer_info_t *buffer_info, gint expected_play_time)
{
- streaming_buffer_t* buffer_handle = NULL;
-
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 high_wm = 0.0, low_wm = 0.0;
gdouble portion = 0.0;
gint default_buffering_time = 0;
MMPLAYER_RETURN_IF_FAIL(streamer);
MMPLAYER_RETURN_IF_FAIL(buffer_info);
- LOGD("pos %"G_GINT64_FORMAT", dur %"G_GINT64_FORMAT", size %"G_GUINT64_FORMAT", in/out:%d/%d, buffer_criteria:%d, time_rate:%d, need:%d ms\n",
- content_info.position, content_info.duration, content_info.content_size,
- bitrate_info.byte_in_rate, bitrate_info.byte_out_rate,
- bitrate_info.buffer_criteria, bitrate_info.time_rate, expected_play_time);
+ LOGD("monitor %d, pos %"G_GINT64_FORMAT", dur %"G_GINT64_FORMAT", size %"G_GUINT64_FORMAT", in/out:%d/%d, time_rate:%d, need:%d ms",
+ streamer->default_val.buffering_monitor, content_info.position, content_info.duration, content_info.content_size,
+ bitrate_info.byte_in_rate, bitrate_info.byte_out_rate, bitrate_info.time_rate, expected_play_time);
if ((content_info.duration <= 0) ||
(content_info.content_size <= 0)) {
- LOGW("keep previous setting.\n");
+ LOGW("keep previous setting.");
return;
}
- if ((bitrate_info.byte_out_rate <= 0) || (bitrate_info.buffer_criteria == 0)) {
- LOGW("keep previous setting.\n");
+ if (bitrate_info.byte_out_rate <= 0) {
+ LOGW("keep previous setting.");
return;
}
- 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_BUFFER_SIZE_BYTES(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
* so there is no reason to buffering. if the buffering msg is posted
* in-rate or contents bitrate has wrong value. */
- LOGW("don't need to do buffering.\n");
+ LOGW("don't need to do buffering.");
}
if (buffering_bytes > 0)
- buffer_buffering_time = (gint)(buffering_bytes / bitrate_info.byte_out_rate)*1000;
+ buffer_buffering_time = (gint)(buffering_bytes / bitrate_info.byte_out_rate) * 1000;
if (content_info.position <= 0) {
/* if the buffer is filled under 50%, MSL use the original default buffering time.
if not, MSL use just 2 sec as a default buffering time. (to reduce initial buffering time) */
- default_buffering_time = streamer->default_val.buffering_time - ((gdouble)streamer->buffering_percent/50)*1000;
+ default_buffering_time = streamer->default_val.buffering_time - ((gdouble)streamer->buffering_percent / 50) * 1000;
} else {
default_buffering_time = streamer->default_val.buffering_time;
}
if (buffer_buffering_time < default_buffering_time) {
- LOGD("adjusted time: %d -> %d ms\n", buffer_buffering_time, default_buffering_time);
- LOGD("adjusted bytes : %d or %d or %d\n",
- buffering_bytes,
- (gint)(bitrate_info.byte_out_rate * buffer_buffering_time/1000),
- (gint)(bitrate_info.buffer_criteria * buffer_buffering_time/1000));
+ guint max_size_byte = GET_MAX_BUFFER_SIZE_BYTES(streamer->streaming_buffer_type);
+
+ LOGD("adjusted time: %d -> %d ms", buffer_buffering_time, default_buffering_time);
+ LOGD("adjusted bytes : %d or %d", buffering_bytes,
+ (gint)(bitrate_info.byte_out_rate * buffer_buffering_time / 1000));
- /* start monitoring the abmormal state */
+ /* start monitoring the abnormal state */
if (content_info.position > 0)
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);
-
- LOGD("monitor %d, bytes %d, time %d, per_byte %f, per_time %f\n",
- streamer->default_val.buffering_monitor,
- buffering_bytes, buffer_buffering_time, per_byte, per_time);
+ __streaming_calc_watermark(streamer, buffering_bytes, buffer_buffering_time, &low_wm, &high_wm);
(*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).high_watermark = high_wm;
+ (*buffer_info).low_watermark = low_wm;
}
-static void
-streaming_update_buffer_setting(mm_player_streaming_t* streamer,
- GstMessage *buffering_msg, /* can be null */
- guint64 content_size,
- gint64 position,
- gint64 duration)
+static void __streaming_update_buffer_setting(mmplayer_streaming_t *streamer,
+ GstMessage *buffering_msg, guint64 content_size, gint64 position, gint64 duration)
{
- streaming_buffer_t* buffer_handle = NULL;
- MMPlayerBufferingMode buffering_mode = MM_PLAYER_BUFFERING_MODE_ADAPTIVE;
+ streaming_buffer_t *buffer_handle = NULL;
+ mmplayer_buffering_mode_e buffering_mode = MM_PLAYER_BUFFERING_MODE_ADAPTIVE;
+ gint expected_play_time = DEFAULT_REBUFFERING_TIME;
- streaming_buffer_info_t buffer_info;
- streaming_content_info_t content_info;
- streaming_bitrate_info_t bitrate_info;
-
- gdouble low_percent = 0.0;
+ streaming_buffer_info_t buffer_info = {0,};
+ streaming_content_info_t content_info = {0,};
+ streaming_bitrate_info_t bitrate_info = {0,};
MMPLAYER_FENTER();
-
MMPLAYER_RETURN_IF_FAIL(streamer);
- memset(&buffer_info, 0x00, sizeof(streaming_buffer_info_t));
- memset(&content_info, 0x00, sizeof(streaming_content_info_t));
- memset(&bitrate_info, 0x00, sizeof(streaming_bitrate_info_t));
-
buffer_handle = &(streamer->buffer_handle[streamer->streaming_buffer_type]);
- if (streamer->buffering_req.is_pre_buffering == TRUE)
+ if (streamer->buffering_req.is_pre_buffering == TRUE) {
buffering_mode = MM_PLAYER_BUFFERING_MODE_FIXED;
- else
- buffering_mode = streamer->buffering_req.mode;
+ expected_play_time = streamer->buffering_req.prebuffer_time;
+ } else {
+ if (content_size == 0 || duration == 0) /* can not support adaptive mode */
+ buffering_mode = MM_PLAYER_BUFFERING_MODE_FIXED;
+ else
+ buffering_mode = streamer->buffering_req.mode;
+
+ if (buffering_mode == MM_PLAYER_BUFFERING_MODE_FIXED) {
+ if (streamer->buffering_req.rebuffer_time > 0)
+ expected_play_time = streamer->buffering_req.rebuffer_time;
+ else
+ expected_play_time = DEFAULT_LIVE_REBUFFER_TIME;
+ }
+ }
- 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;
+ LOGD("buffering mode: %d, time: %d", buffering_mode, expected_play_time);
content_info.position = position;
content_info.duration = duration;
content_info.content_size = content_size;
- streaming_get_current_bitrate_info(streamer, buffering_msg, content_info, &bitrate_info);
+ __streaming_get_current_bitrate_info(streamer, buffering_msg, content_info, &bitrate_info);
- LOGD("buffering mode %d, new info in_r:%d, out_r:%d, cb:%d, bt:%d\n",
- buffering_mode, bitrate_info.byte_in_rate, bitrate_info.byte_out_rate,
- bitrate_info.buffer_criteria, bitrate_info.time_rate);
-
- /* calculate buffer low/high percent */
- low_percent = DEFAULT_BUFFER_LOW_PERCENT;
+ LOGD("in_r:%d, out_r:%d", bitrate_info.byte_in_rate, bitrate_info.byte_out_rate);
if (buffering_mode == MM_PLAYER_BUFFERING_MODE_FIXED) {
- /********************
- * (1) fixed mode *
- ********************/
- gint buffering_time = 0;
-
- if (streamer->buffering_req.is_pre_buffering == TRUE)
- buffering_time = streamer->buffering_req.prebuffer_time;
- else
- buffering_time = streamer->buffering_req.rebuffer_time;
-
- streaming_handle_fixed_buffering_mode(streamer, bitrate_info.byte_out_rate, buffering_time, &buffer_info);
+ __streaming_handle_fixed_buffering_mode(streamer, bitrate_info.byte_out_rate, expected_play_time, &buffer_info);
} else {
- /*********************************
- * (2) adaptive mode (default) *
- *********************************/
- gint expected_play_time = DEFAULT_PLAYING_TIME;
-
- if (streamer->buffering_req.rebuffer_time > 0)
- expected_play_time = streamer->buffering_req.rebuffer_time;
- else if ((position == 0) && (streamer->buffering_state & MM_PLAYER_BUFFERING_IN_PROGRESS))
- expected_play_time = streamer->buffering_req.prebuffer_time;
+ __streaming_handle_adaptive_buffering_mode(streamer, content_info, bitrate_info, &buffer_info, expected_play_time);
- if (expected_play_time <= 0)
- expected_play_time = DEFAULT_PLAYING_TIME;
-
- streaming_handle_adaptive_buffering_mode(streamer, content_info, bitrate_info, &buffer_info, expected_play_time);
-
- if (IS_MUXED_BUFFERING_MODE(streamer)) // even if new byte size is smaller than the previous one, time need to be updated.
- buffer_handle->buffering_time = buffer_info.buffering_time;
+ /* even if new byte size is smaller than the previous one, time need to be updated. */
+ if (IS_MUXED_BUFFERING_MODE(streamer))
+ GET_CURRENT_BUFFERING_TIME(buffer_handle) = buffer_info.buffering_time;
}
- LOGD("adj buffer(%d) %d->%d bytes/%d->%d ms\n",
- streamer->streaming_buffer_type,
- GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_info.buffering_bytes,
- GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_info.buffering_time);
+ LOGD("adj buffer(%d) %d->%d bytes/%d->%d ms",
+ streamer->streaming_buffer_type,
+ GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_info.buffering_bytes,
+ GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_info.buffering_time);
/* queue2 : bytes, multiqueue : time */
if (((GET_CURRENT_BUFFERING_BYTE(buffer_handle) < buffer_info.buffering_bytes) && IS_MUXED_BUFFERING_MODE(streamer)) ||
((GET_CURRENT_BUFFERING_TIME(buffer_handle) < buffer_info.buffering_time) && IS_DEMUXED_BUFFERING_MODE(streamer))) {
if (duration > 0 && position > 0) {
- gint buffering_time_limit = (gint)(duration - position)/GST_MSECOND;
+ gint buffering_time_limit = (gint)(duration - position) / GST_MSECOND;
if (buffer_info.buffering_time > buffering_time_limit)
buffer_info.buffering_time = buffering_time_limit;
}
-
- streaming_set_buffer_size(streamer, streamer->streaming_buffer_type, buffer_info.buffering_bytes, buffer_info.buffering_time);
+ __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, low_percent, buffer_info.percent_byte, buffer_info.percent_time);
+ __streaming_set_buffer_watermark(streamer, streamer->streaming_buffer_type, buffer_info.low_watermark, buffer_info.high_watermark);
- LOGD("buffer setting: size %d, time %d, per %f\n",
- GET_CURRENT_BUFFERING_BYTE(buffer_handle),
- GET_CURRENT_BUFFERING_TIME(buffer_handle),
- buffer_handle->buffer_high_percent);
+ 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_watermark);
streamer->need_sync = TRUE;
}
-static void
-streaming_adjust_min_threshold(mm_player_streaming_t* streamer, gint64 position)
+static void __streaming_adjust_min_threshold(mmplayer_streaming_t *streamer, gint64 position)
{
#define DEFAULT_TIME_PAD 1000 /* ms */
gint playing_time = 0;
LOGD("buffering monitor = %s", (streamer->default_val.buffering_monitor) ? "ON" : "OFF");
LOGD("playing_time (%d ms) = %"G_GINT64_FORMAT" - %"G_GINT64_FORMAT, playing_time, position, streamer->default_val.prev_pos);
LOGD("default time : %d, prev buffering t : %d",
- streamer->default_val.buffering_time, streamer->buffer_handle[streamer->streaming_buffer_type].buffering_time);
+ streamer->default_val.buffering_time, streamer->buffer_handle[streamer->streaming_buffer_type].buffering_time);
if ((streamer->default_val.buffering_monitor) && (playing_time <= streamer->default_val.buffering_time)) {
gint time_gap = 0;
if (time_gap <= 0)
time_gap = DEFAULT_TIME_PAD;
- streamer->default_val.buffering_time += time_gap*2;
+ streamer->default_val.buffering_time += time_gap * 2;
streamer->default_val.buffering_time = MIN(streamer->default_val.buffering_time, MAX_BUFFERING_TIME);
} else {
streamer->default_val.buffering_time = DEFAULT_BUFFERING_TIME;
}
- LOGD("new default min value %d \n", streamer->default_val.buffering_time);
+ LOGD("new default min value %d", streamer->default_val.buffering_time);
streamer->default_val.buffering_monitor = FALSE;
streamer->default_val.prev_pos = position;
}
-static void
-streaming_update_buffering_status(mm_player_streaming_t* streamer, GstMessage *buffering_msg, gint64 position)
+static void __streaming_update_buffering_status(mmplayer_streaming_t *streamer, GstMessage *buffering_msg, gint64 position)
{
gint buffer_percent = 0;
MMPLAYER_RETURN_IF_FAIL(streamer);
MMPLAYER_RETURN_IF_FAIL(buffering_msg);
+ MMPLAYER_RETURN_IF_FAIL(GST_IS_MESSAGE(buffering_msg));
+ MMPLAYER_RETURN_IF_FAIL((GST_MESSAGE_TYPE(buffering_msg) == GST_MESSAGE_BUFFERING));
/* update when buffering has started. */
if (!(streamer->buffering_state & MM_PLAYER_BUFFERING_IN_PROGRESS)) {
if (!streamer->buffering_req.is_pre_buffering) {
streamer->need_update = TRUE;
- streaming_adjust_min_threshold(streamer, position);
+ __streaming_adjust_min_threshold(streamer, position);
}
}
if (streamer->buffering_percent == MAX_BUFFER_PERCENT) {
streamer->buffering_state = MM_PLAYER_BUFFERING_DEFAULT;
streamer->buffering_req.is_pre_buffering = FALSE;
+ streamer->need_update = TRUE;
} else if (streamer->buffering_state & MM_PLAYER_BUFFERING_COMPLETE) {
streamer->buffering_state = MM_PLAYER_BUFFERING_COMPLETE; /* have to keep state to ignore remained msg till get 100% msg */
streamer->buffering_req.is_pre_buffering = FALSE;
}
}
-void __mm_player_streaming_buffering(mm_player_streaming_t* streamer,
- GstMessage *buffering_msg,
- guint64 content_size,
- gint64 position,
- gint64 duration)
+void _mm_player_streaming_buffering(mmplayer_streaming_t *streamer, GstMessage *buffering_msg,
+ guint64 content_size, gint64 position, gint64 duration)
{
MMPLAYER_FENTER();
-
MMPLAYER_RETURN_IF_FAIL(streamer);
- MMPLAYER_RETURN_IF_FAIL(buffering_msg);
- MMPLAYER_RETURN_IF_FAIL(GST_IS_MESSAGE(buffering_msg));
- MMPLAYER_RETURN_IF_FAIL((GST_MESSAGE_TYPE(buffering_msg) == GST_MESSAGE_BUFFERING));
- if (position > (gint64)(streamer->buffering_req.prebuffer_time * GST_MSECOND))
- streamer->buffering_req.is_pre_buffering = FALSE;
+ if (buffering_msg) {
+ if (position > (gint64)(streamer->buffering_req.prebuffer_time * GST_MSECOND))
+ streamer->buffering_req.is_pre_buffering = FALSE;
- streaming_update_buffering_status(streamer, buffering_msg, position);
+ __streaming_update_buffering_status(streamer, buffering_msg, position);
- if (!streamer->need_update)
- return;
+ if (!streamer->need_update)
+ return;
+ }
streamer->need_update = FALSE;
- streaming_update_buffer_setting(streamer, buffering_msg, content_size, position, duration);
+ __streaming_update_buffer_setting(streamer, buffering_msg, content_size, position, duration);
return;
}
projects / platform / core / multimedia / libmm-player.git / blobdiff