#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 MIN_BUFFERING_TIME 3.0
-#define MAX_BUFFERING_TIME (10 * 1000) /* ms */
-#define MAX_DECODEBIN_BUFFER_BYTES (32 * 1024 * 1024) /* byte */
-#define MAX_DECODEBIN_BUFFER_TIME (15 * 1000) /* ms */
-#define MAX_DECODEBIN_ADAPTIVE_BUFFER_BYTES (2 * 1024 * 1024) /* byte */
-#define MAX_DECODEBIN_ADAPTIVE_BUFFER_TIME (5 * 1000) /* ms */
+/* buffering time criteria (ms) */
+#define DEFAULT_BUFFERING_TIME (3 * 1000)
+#define MIN_BUFFERING_TIME (0)
+#define MAX_BUFFERING_TIME (10 * 1000)
-#define DEFAULT_BUFFER_SIZE_BYTES 4194304 /* 4 MBytes */
-#define DEFAULT_PLAYING_TIME (10 * 1000) /* ms */
-#define DEFAULT_ADAPTIVE_PLAYING_TIME (3 * 1000) /* ms */
+#define DEFAULT_PREBUFFERING_TIME (3 * 1000)
+#define DEFAULT_REBUFFERING_TIME (10 * 1000)
+#define DEFAULT_ADAPTIVE_REBUFFER_TIME (5 * 1000)
+#define DEFAULT_LIVE_REBUFFER_TIME (3 * 1000)
-#define DEFAULT_BUFFERING_TIME (3 * 1000) /* ms */
-#define DEFAULT_BUFFER_HIGH_PERCENT 99.0
-#define DEFAULT_RING_BUFFER_SIZE (20 * 1024 * 1024) /* 20MBytes */
+/* buffer size */
+#define DEFAULT_BUFFER_SIZE_BYTES (5 * 1024 * 1024) /* 5 MBytes */
+#define DEFAULT_RING_BUFFER_SIZE_BYTES (20 * 1024 * 1024) /* 20 MBytes, for queue2 */
+#define MIN_BUFFER_SIZE_BYTES (1 * 1024 * 1024) /* 1 MBytes */
+#define MAX_BUFFER_SIZE_BYTES (32 * 1024 * 1024) /* 32 MBytes */
+#define MAX_BUFFER_SIZE_TIME (15 * 1000) /* 15 sec, for mq */
-#define STREAMING_USE_FILE_BUFFER
-#define STREAMING_USE_MEMORY_BUFFER
#define GET_BYTE_FROM_BIT(bit) (bit / 8)
#define GET_BIT_FROM_BYTE(byte) (byte * 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_DECODEBIN_BUFFER_BYTES) ? (size) : (MAX_DECODEBIN_BUFFER_BYTES)
-#define GET_MAX_BUFFER_BYTES(sr) ((PLAYER_STREAM_CAST(sr)->is_adaptive_streaming) ? (MAX_DECODEBIN_ADAPTIVE_BUFFER_BYTES) : (MAX_DECODEBIN_BUFFER_BYTES))
-#define GET_MAX_BUFFER_TIME(sr) ((PLAYER_STREAM_CAST(sr)->is_adaptive_streaming) ? (MAX_DECODEBIN_ADAPTIVE_BUFFER_TIME) : (MAX_DECODEBIN_BUFFER_TIME))
-#define GET_DEFAULT_PLAYING_TIME(sr) ((PLAYER_STREAM_CAST(sr)->is_adaptive_streaming) ? (DEFAULT_ADAPTIVE_PLAYING_TIME) : (DEFAULT_PLAYING_TIME))
+#define GET_NEW_BUFFERING_BYTE(size) ((size) < MAX_BUFFER_SIZE_BYTES) ? (size) : (MAX_BUFFER_SIZE_BYTES)
typedef enum {
BUFFER_TYPE_DEFAULT,
mm_player_streaming_t *__mm_player_streaming_create(void);
-void __mm_player_streaming_initialize(mm_player_streaming_t *streaming_player);
-void __mm_player_streaming_deinitialize(mm_player_streaming_t *streaming_player);
+
+void __mm_player_streaming_initialize(mm_player_streaming_t *streaming_player, gboolean buffer_init);
+
void __mm_player_streaming_destroy(mm_player_streaming_t *streaming_player);
-void __mm_player_streaming_set_queue2(mm_player_streaming_t *streamer,
- GstElement *buffer,
- gboolean use_buffering,
- guint buffering_bytes,
- gint buffering_time,
- MuxedBufferType type,
- gchar *file_path,
- guint64 content_size);
-void __mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer,
- GstElement *buffer,
- gint buffering_time);
+
+void __mm_player_streaming_set_queue2(mm_player_streaming_t *streamer, GstElement *buffer,
+ gboolean use_buffering, MuxedBufferType type, gchar *file_path, guint64 content_size);
+
+void __mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer, GstElement *buffer);
+
void __mm_player_streaming_sync_property(mm_player_streaming_t *streamer, GstElement *decodebin);
-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(mm_player_streaming_t *streamer, GstMessage *buffering_msg,
+ guint64 content_size, gint64 position, gint64 duration);
+
void __mm_player_streaming_set_content_bitrate(mm_player_streaming_t *streaming_player, guint max_bitrate, guint avg_bitrate);
#endif
static gboolean
__mmplayer_gst_set_queue2_buffering(mm_player_t *player)
{
-#define ESTIMATED_BUFFER_UNIT (1 * 1024 * 1024)
-
- gint init_buffering_time = 0;
- guint buffer_bytes = 0;
gint64 dur_bytes = 0L;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline &&
player->pipeline->mainbin && player->streamer, FALSE);
- init_buffering_time = player->streamer->buffering_req.prebuffer_time;
- buffer_bytes = (guint)(init_buffering_time / 1000) * ESTIMATED_BUFFER_UNIT;
-
- buffer_bytes = MAX(buffer_bytes, player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffering_bytes);
- LOGD("pre buffer time: %d ms, buffer size : %d", init_buffering_time, buffer_bytes);
-
- init_buffering_time = (init_buffering_time != 0) ? init_buffering_time : player->ini.http_buffering_time;
-
if (!gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
LOGE("fail to get duration.");
__mm_player_streaming_set_queue2(player->streamer,
player->pipeline->mainbin[MMPLAYER_M_MUXED_S_BUFFER].gst,
TRUE, /* use_buffering */
- buffer_bytes,
- init_buffering_time,
MUXED_BUFFER_TYPE_MAX, /* use previous buffer type setting */
NULL,
((dur_bytes > 0) ? ((guint64)dur_bytes) : 0));
__mmplayer_reset_gapless_state(player);
if (player->streamer) {
- __mm_player_streaming_deinitialize(player->streamer);
+ __mm_player_streaming_initialize(player->streamer, FALSE);
__mm_player_streaming_destroy(player->streamer);
player->streamer = NULL;
}
if ((MMPLAYER_IS_STREAMING(player)) && (player->streamer == NULL)) {
player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
+ __mm_player_streaming_initialize(player->streamer, TRUE);
}
/* realize pipeline */
if (__mmplayer_is_midi_type(player->type)) {
player->bypass_audio_effect = TRUE;
- } else if (g_strrstr(player->type, "application/x-hls")) {
+ return;
+ }
+
+ if (!player->streamer) {
+ LOGD("no need to check streaming type");
+ return;
+ }
+
+ if (g_strrstr(player->type, "application/x-hls")) {
/* If it can't know exact type when it parses uri because of redirection case,
* it will be fixed by typefinder or when doing autoplugging.
*/
player->profile.uri_type = MM_PLAYER_URI_TYPE_HLS;
- if (player->streamer) {
- player->streamer->is_adaptive_streaming = TRUE;
- player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
- player->streamer->buffering_req.rebuffer_time = 5 * 1000;
- }
+ player->streamer->is_adaptive_streaming = TRUE;
} else if (g_strrstr(player->type, "application/dash+xml")) {
player->profile.uri_type = MM_PLAYER_URI_TYPE_DASH;
- if (player->streamer) {
- player->streamer->is_adaptive_streaming = TRUE;
- player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
- }
+ player->streamer->is_adaptive_streaming = TRUE;
+ }
+
+ if (player->streamer->is_adaptive_streaming) {
+ player->streamer->buffering_req.mode = MM_PLAYER_BUFFERING_MODE_FIXED;
+
+ if (player->streamer->buffering_req.rebuffer_time <= MIN_BUFFERING_TIME) /* if user did not set the rebuffer value */
+ player->streamer->buffering_req.rebuffer_time = DEFAULT_ADAPTIVE_REBUFFER_TIME;
}
- LOGD("uri type : %d", player->profile.uri_type);
+ LOGD("uri type : %d, %d", player->profile.uri_type, player->streamer->buffering_req.rebuffer_time);
MMPLAYER_FLEAVE();
}
{
GstElement *queue2 = NULL;
gint64 dur_bytes = 0L;
- guint max_buffer_size_bytes = 0;
MMPlayerGstElement *mainbin = NULL;
MuxedBufferType type = MUXED_BUFFER_TYPE_MEM_QUEUE;
return NULL;
}
+ /* NOTE : in case of ts streaming, player could not get the correct duration info *
+ * skip the pull mode(file or ring buffering) setting. */
+ if (g_strrstr(player->type, "video/mpegts"))
+ return queue2;
+
if (!gst_element_query_duration(mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
- LOGE("failed to get duration from source %s", GST_ELEMENT_NAME(mainbin[MMPLAYER_M_SRC].gst));
+ LOGW("failed to get duration from source %s", GST_ELEMENT_NAME(mainbin[MMPLAYER_M_SRC].gst));
LOGD("dur_bytes = %"G_GINT64_FORMAT, dur_bytes);
dur_bytes = 0;
}
- /* NOTE : in case of ts streaming, player cannot get the correct duration info *
- * skip the pull mode(file or ring buffering) setting. */
- if (!g_strrstr(player->type, "video/mpegts")) {
- max_buffer_size_bytes = (type == MUXED_BUFFER_TYPE_FILE) ? (player->ini.http_max_size_bytes) : (5 * 1024 * 1024);
- LOGD("max_buffer_size_bytes = %d", max_buffer_size_bytes);
-
- __mm_player_streaming_set_queue2(player->streamer,
- queue2,
- FALSE,
- max_buffer_size_bytes,
- player->ini.http_buffering_time,
- type,
- player->http_file_buffering_path,
- (guint64)dur_bytes);
- }
+ __mm_player_streaming_set_queue2(player->streamer,
+ queue2,
+ FALSE,
+ type,
+ player->http_file_buffering_path,
+ (guint64)dur_bytes);
return queue2;
}
GstElement *queue2 = NULL;
GstPad *sinkpad = NULL;
GstPad *qsrcpad = NULL;
- gint init_buffering_time = player->streamer->buffering_req.prebuffer_time;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin, FALSE);
* in case of HLS/DASH, it does not need to have big buffer *
* because it is kind of adaptive streaming. */
if (MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING(player) || MMPLAYER_IS_DASH_STREAMING(player)) {
- gdouble high_percent = 0.0;
+ gint init_buffering_time = DEFAULT_PREBUFFERING_TIME;
+ gint high_percent = 0;
+
+ if (player->streamer->buffering_req.prebuffer_time > MIN_BUFFERING_TIME)
+ init_buffering_time = player->streamer->buffering_req.prebuffer_time;
- init_buffering_time = (init_buffering_time != 0) ? init_buffering_time : player->ini.http_buffering_time;
- high_percent = (gdouble)(init_buffering_time * 100) / GET_MAX_BUFFER_TIME(player->streamer);
+ high_percent = (gint)ceil((gdouble)(init_buffering_time * 100) / MAX_BUFFER_SIZE_TIME);
- LOGD("decodebin setting - bytes: %d, time: %d ms, per: 1~%d",
- GET_MAX_BUFFER_BYTES(player->streamer), GET_MAX_BUFFER_TIME(player->streamer), (gint)high_percent);
+ LOGD("buffering time %d, per: 1~%d", init_buffering_time, high_percent);
g_object_set(G_OBJECT(decodebin), "use-buffering", TRUE,
- "high-percent", (gint)high_percent,
- "max-size-bytes", GET_MAX_BUFFER_BYTES(player->streamer),
- "max-size-time", (guint64)(GET_MAX_BUFFER_TIME(player->streamer) * GST_MSECOND),
+ "high-percent", high_percent,
+ "max-size-bytes", MAX_BUFFER_SIZE_BYTES,
+ "max-size-time", (guint64)(MAX_BUFFER_SIZE_TIME * GST_MSECOND),
"max-size-buffers", 0, NULL); // disable or automatic
}
- if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(decodebin)) {
+ if (gst_element_sync_state_with_parent(decodebin) == GST_STATE_CHANGE_FAILURE) {
LOGE("failed to sync decodebin state with parent");
goto ERROR;
}
if (MMPLAYER_IS_HTTP_STREAMING(player)) {
if (player->streamer == NULL) {
player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
+ __mm_player_streaming_initialize(player->streamer, TRUE);
}
elem_idx = MMPLAYER_M_TYPEFIND;
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_AUTOPLUG);
if (player->streamer) {
- __mm_player_streaming_deinitialize(player->streamer);
+ __mm_player_streaming_initialize(player->streamer, FALSE);
__mm_player_streaming_destroy(player->streamer);
player->streamer = NULL;
}
(MMPLAYER_IS_HTTP_LIVE_STREAMING(player)) ||
(MMPLAYER_IS_DASH_STREAMING(player))) {
/* in case of multiqueue, max bytes size is defined with fixed value in mm_player_streaming.h*/
- __mm_player_streaming_set_multiqueue(player->streamer, element, player->ini.http_buffering_time);
+ __mm_player_streaming_set_multiqueue(player->streamer, element);
__mm_player_streaming_sync_property(player->streamer, player->pipeline->mainbin[MMPLAYER_M_AUTOPLUG].gst);
}
if (player->streamer == NULL) {
player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
+ __mm_player_streaming_initialize(player->streamer, TRUE);
}
if (buffer_ms >= 0)
if (player->streamer == NULL) {
player->streamer = __mm_player_streaming_create();
- __mm_player_streaming_initialize(player->streamer);
+ __mm_player_streaming_initialize(player->streamer, TRUE);
}
*buffer_ms = player->streamer->buffering_req.prebuffer_time;
#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
gint64 position,
gint64 duration);
-mm_player_streaming_t *
-__mm_player_streaming_create(void)
+mm_player_streaming_t *__mm_player_streaming_create(void)
{
mm_player_streaming_t *streamer = 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;
}
-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(mm_player_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(mm_player_streaming_t *streamer)
{
MMPLAYER_FENTER();
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(
+ mm_player_streaming_t *streamer, guint max_bitrate, guint avg_bitrate)
{
MMPLAYER_FENTER();
}
if (avg_bitrate > 0 && streamer->buffer_avg_bitrate != avg_bitrate) {
- LOGD("set averate bitrate(%dbps).", avg_bitrate);
+ LOGD("set average bitrate(%dbps).", avg_bitrate);
streamer->buffer_avg_bitrate = avg_bitrate;
if (streamer->buffering_req.is_pre_buffering == FALSE) {
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_percent(mm_player_streaming_t *streamer,
+ BufferType type, gdouble high_percent_byte, gdouble high_percent_time)
{
gdouble high_percent = 0.0;
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(mm_player_streaming_t *streamer,
+ MuxedBufferType type, gchar *file_path, guint64 content_size)
{
streaming_buffer_t *buffer_handle = NULL;
guint64 storage_available_size = 0; /* bytes */
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.");
- buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE);
+ buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE_BYTES);
} else {
storage_available_size = (guint64)buf.f_bavail * (guint64)buf.f_bsize; //bytes
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);
+ 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);
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(mm_player_streaming_t *streamer,
+ BufferType type, guint buffering_bytes, gint buffering_time)
{
streaming_buffer_t *buffer_handle = NULL;
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 percent value*/
"max-size-time", (guint64)(buffering_time * GST_MSECOND),
"max-size-buffers", 0, NULL); /* disable */
buffer_handle->buffering_time = buffering_time;
- buffer_handle->buffering_bytes = GET_MAX_BUFFER_BYTES(streamer);
+ buffer_handle->buffering_bytes = MAX_BUFFER_SIZE_BYTES;
LOGD("max-size-time : %d ms", buffering_time);
} else {
return;
}
-void
-__mm_player_streaming_set_queue2(mm_player_streaming_t *streamer,
- GstElement *buffer,
- gboolean use_buffering,
- guint buffering_bytes,
- gint buffering_time,
- MuxedBufferType type,
- gchar *file_path,
- guint64 content_size)
+void __mm_player_streaming_set_queue2(mm_player_streaming_t *streamer, GstElement *buffer,
+ gboolean use_buffering, MuxedBufferType type, gchar *file_path, 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 queue2 buffering %d", use_buffering);
- 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;
+ }
+
+ queue_size_bytes = (guint)(streamer->buffering_req.prebuffer_time / 1000) * ESTIMATED_BUFFER_UNIT;
+ queue_size_bytes = MAX(queue_size_bytes, DEFAULT_BUFFER_SIZE_BYTES);
+ } 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 */
+ if (type == MUXED_BUFFER_TYPE_FILE)
+ queue_size_bytes = MIN_BUFFER_SIZE_BYTES;
+ else
+ queue_size_bytes = DEFAULT_BUFFER_SIZE_BYTES;
+
+ streaming_set_queue2_queue_type(streamer, type, file_path, content_size);
}
- /* initial setting */
- streaming_set_buffer_size(streamer, BUFFER_TYPE_MUXED, buffering_bytes, buffering_time);
+ /* queue_size_time will set to queue2 only in case of live buffering. */
+ queue_size_time = streamer->buffering_req.prebuffer_time;
+
+ 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_percent(streamer, BUFFER_TYPE_MUXED, DEFAULT_BUFFER_HIGH_PERCENT, 0);
- if (type < MUXED_BUFFER_TYPE_MAX)
- streaming_set_queue2_queue_type(streamer, type, file_path, content_size);
MMPLAYER_FLEAVE();
return;
}
-void
-__mm_player_streaming_sync_property(mm_player_streaming_t *streamer, GstElement *decodebin)
+void __mm_player_streaming_sync_property(mm_player_streaming_t *streamer, GstElement *decodebin)
{
streaming_buffer_t *buffer_handle = NULL;
streamer->need_sync = FALSE;
}
-void
-__mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer,
- GstElement *buffer,
- gint buffering_time)
+void __mm_player_streaming_set_multiqueue(mm_player_streaming_t *streamer, GstElement *buffer)
{
streaming_buffer_t *buffer_handle = NULL;
gdouble high_percent = 0.0;
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);
+ if (streamer->buffering_req.prebuffer_time <= MIN_BUFFERING_TIME)
+ streamer->buffering_req.prebuffer_time = DEFAULT_PREBUFFERING_TIME;
- LOGD("pre_buffering: %d ms, during playing: %d ms", 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);
+ high_percent = (gdouble)(streamer->buffering_req.prebuffer_time * 100) / MAX_BUFFER_SIZE_TIME;
LOGD("high_percent %2.3f %%", high_percent);
/* initial setting */
- streaming_set_buffer_size(streamer, BUFFER_TYPE_DEMUXED, GET_MAX_BUFFER_BYTES(streamer), GET_MAX_BUFFER_TIME(streamer));
+ 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);
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(mm_player_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;
(*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(mm_player_streaming_t *streamer,
+ gint byte_out_rate, gint fixed_buffering_time, streaming_buffer_info_t *buffer_info)
{
streaming_buffer_t *buffer_handle = NULL;
(*buffer_info).percent_time = per_time;
}
-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(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)
{
streaming_buffer_t *buffer_handle = NULL;
}
-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(mm_player_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;
+ gint expected_play_time = DEFAULT_REBUFFERING_TIME;
- streaming_buffer_info_t buffer_info;
+ streaming_buffer_info_t buffer_info;
streaming_content_info_t content_info;
streaming_bitrate_info_t bitrate_info;
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;
+ }
+ }
+
+ LOGD("buffering mode: %d, time: %d", buffering_mode, expected_play_time);
buffer_info.buffering_bytes = buffer_handle->buffering_bytes;
buffer_info.buffering_time = buffer_handle->buffering_time;
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",
- buffering_mode, bitrate_info.byte_in_rate, bitrate_info.byte_out_rate,
- bitrate_info.buffer_criteria, bitrate_info.time_rate);
+ 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;
-
- 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.
+ /* even if new byte size is smaller than the previous one, time need to be updated. */
+ if (IS_MUXED_BUFFERING_MODE(streamer))
buffer_handle->buffering_time = buffer_info.buffering_time;
}
streamer->need_sync = TRUE;
}
-static void
-streaming_adjust_min_threshold(mm_player_streaming_t *streamer, gint64 position)
+static void streaming_adjust_min_threshold(mm_player_streaming_t *streamer, gint64 position)
{
#define DEFAULT_TIME_PAD 1000 /* ms */
gint playing_time = 0;
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(mm_player_streaming_t *streamer, GstMessage *buffering_msg, gint64 position)
{
gint buffer_percent = 0;
}
}
-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(mm_player_streaming_t *streamer, GstMessage *buffering_msg,
+ guint64 content_size, gint64 position, gint64 duration)
{
MMPLAYER_FENTER();
projects / platform / core / multimedia / libmm-player.git / commitdiff