enable dump function with gstreamer 1.x and modify log message of streaming.

Change-Id: I3486cdde4fafb1f306cbab699b53ece6f197da67
Signed-off-by: Hyunil Park <hyunil46.park@samsung.com>

diff --git a/src/mm_player_priv.c b/src/mm_player_priv.c
index 40cb8655113ff0d8ddbafafa401b090592ebf7fe..6bf25a8db3c822f62047cd2a70f2a5954d30b0fa 100644 (file)
--- a/src/mm_player_priv.c
+++ b/src/mm_player_priv.c
@@ -218,7 +218,7 @@ static gboolean _mmplayer_update_content_attrs(mm_player_t* player, enum content
 
 
 static gboolean __mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element);
-//static gboolean __mmplayer_dump_buffer_probe_cb(GstPad *pad, GstBuffer *buffer, gpointer u_data);
+static GstPadProbeReturn __mmplayer_dump_buffer_probe_cb(GstPad *pad,  GstPadProbeInfo *info, gpointer u_data);
 static void __mmplayer_release_dump_list (GList *dump_list);
 
 static int             __gst_realize(mm_player_t* player);
@@ -17084,7 +17084,7 @@ __mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element)
                                memset (dump_file_name, 0x00, PLAYER_INI_MAX_STRLEN*2);
                                sprintf (dump_file_name, "%s/%s_sink_pad.dump", player->ini.dump_element_path, player->ini.dump_element_keyword[idx]);
                                dump_s->dump_element_file = fopen(dump_file_name,"w+");
-//                             dump_s->probe_handle_id = gst_pad_add_buffer_probe (dump_s->dump_pad, G_CALLBACK(__mmplayer_dump_buffer_probe_cb), dump_s->dump_element_file);
+                               dump_s->probe_handle_id = gst_pad_add_probe (dump_s->dump_pad, GST_PAD_PROBE_TYPE_BUFFER, __mmplayer_dump_buffer_probe_cb, dump_s->dump_element_file, NULL);
                                /* add list for removed buffer probe and close FILE */
                                player->dump_list = g_list_append (player->dump_list, dump_s);
                                debug_log ("%s sink pad added buffer probe for dump", factory_name);
@@ -17103,23 +17103,24 @@ __mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element)
        return FALSE;
 }
 
-
-#if 0
-static gboolean
-__mmplayer_dump_buffer_probe_cb(GstPad *pad, GstBuffer *buffer, gpointer u_data)
+static GstPadProbeReturn
+__mmplayer_dump_buffer_probe_cb(GstPad *pad,  GstPadProbeInfo *info, gpointer u_data)
 {
        FILE *dump_data = (FILE *) u_data;
 //     int written = 0;
+       GstBuffer *buffer = gst_pad_probe_info_get_buffer(info);
+       GstMapInfo probe_info = GST_MAP_INFO_INIT;
 
        return_val_if_fail ( dump_data, FALSE );
 
+       gst_buffer_map(buffer, &probe_info, GST_MAP_READ);
+
 //     debug_log ("buffer timestamp = %" GST_TIME_FORMAT, GST_TIME_ARGS( GST_BUFFER_TIMESTAMP(buffer)));
 
-       fwrite ( GST_BUFFER_DATA(buffer), 1, GST_BUFFER_SIZE(buffer), dump_data);
+       fwrite ( probe_info.data, 1, probe_info.size , dump_data);
 
-       return TRUE;
+       return GST_PAD_PROBE_OK;
 }
-#endif
 
 static void
 __mmplayer_release_dump_list (GList *dump_list)

diff --git a/src/mm_player_streaming.c b/src/mm_player_streaming.c
index 9525d7fe6c7cc757dcb8fbd72b4f1789e9af2c63..44f4b03bf60ed3984d130eedabf707fd6784c27a 100755 (executable)
--- a/src/mm_player_streaming.c
+++ b/src/mm_player_streaming.c
@@ -314,7 +314,7 @@ streaming_set_buffer_percent(       mm_player_streaming_t* streamer,
 
        streaming_check_buffer_percent(low_percent, high_percent, &confirmed_low, &confirmed_high);
 
-       // if use-buffering is disabled, this settings do not have any meaning.
+       /* if use-buffering is disabled, this settings do not have any meaning. */
        debug_log("target buffer elem : %s (%2.3f ~ %2.3f)",
                GST_ELEMENT_NAME(buffer_handle->buffer), confirmed_low, confirmed_high);
 
@@ -447,14 +447,14 @@ streaming_set_buffer_size(mm_player_streaming_t* streamer, BufferType type, guin
                        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-time", ((guint)ceil(buffering_time) * GST_SECOND),
-                                                       "max-size-buffers", 0, NULL);                                   // disable
+                                                       "max-size-buffers", 0, NULL);                                     /* disable */
 
                        buffer_handle->buffering_time = buffering_time;
                        buffer_handle->buffering_bytes = GET_MAX_BUFFER_BYTES(streamer);
 
                        debug_log("max-size-time : %f", buffering_time);
                }
-               else    // queue2
+               else    /* queue2 */
                {
                        if (buffer_handle->is_live)
                        {
@@ -476,7 +476,7 @@ streaming_set_buffer_size(mm_player_streaming_t* streamer, BufferType type, guin
                        buffer_handle->buffering_bytes = buffering_bytes;
                        buffer_handle->buffering_time = buffering_time;
 
-                       debug_log("[New][Q2] max-size-bytes : %d", buffering_bytes);
+                       debug_log("max-size-bytes : %d", buffering_bytes);
                }
        }
 
@@ -576,8 +576,6 @@ void __mm_player_streaming_set_multiqueue(  mm_player_streaming_t* streamer,
 
        if (buffer)
        {
-               debug_log("USE-BUFFERING : %s", (use_buffering)?"OOO":"XXX");
-
                buffer_handle->buffer = buffer;
 
                if (use_buffering)
@@ -592,7 +590,7 @@ void __mm_player_streaming_set_multiqueue(  mm_player_streaming_t* streamer,
                g_object_set ( G_OBJECT (buffer_handle->buffer), "use-buffering", use_buffering, NULL );
        }
 
-       debug_log ("time req: %2.2f, default: %2.2f\n", pre_buffering_time, buffering_time);
+       debug_log ("pre_buffering: %2.2f, during playing: %2.2f\n", pre_buffering_time, buffering_time);
 
        if (pre_buffering_time <= 0.0)
        {
@@ -601,7 +599,7 @@ void __mm_player_streaming_set_multiqueue(  mm_player_streaming_t* streamer,
        }
 
        high_percent = (pre_buffering_time * 100) / GET_MAX_BUFFER_TIME(streamer);
-       debug_log ("high_percent :  per %2.3f %%\n", high_percent);
+       debug_log ("high_percent %2.3f %%\n", high_percent);
 
        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);
@@ -719,7 +717,7 @@ streaming_handle_fixed_buffering_mode(      mm_player_streaming_t* streamer,
        buffer_handle = &(streamer->buffer_handle[streamer->streaming_buffer_type]);
        buffering_time = fixed_buffering_time;
 
-       debug_log ("[IN] MM_PLAYER_BUFFERING_MODE_FIXED (%2.2f sec), out:%d\n", buffering_time, byte_out_rate);
+       debug_log ("buffering time: %2.2f sec, out rate: %d\n", buffering_time, byte_out_rate);
 
        if ((buffering_time > 0) && (byte_out_rate > 0))
        {
@@ -737,7 +735,7 @@ streaming_handle_fixed_buffering_mode(      mm_player_streaming_t* streamer,
        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);
 
-       debug_log ("[NEW] bytes %d, time %f, per_byte %f, per_time %f\n",
+       debug_log ("bytes %d, time %f, per_byte %f, per_time %f\n",
                                                                                buffering_bytes, buffering_time, per_byte, per_time);
 
        (*buffer_info).buffering_bytes = buffering_bytes;
@@ -766,22 +764,22 @@ streaming_handle_adaptive_buffering_mode( mm_player_streaming_t* streamer,
        return_if_fail(streamer);
        return_if_fail(buffer_info);
 
-       debug_log ("[IN] MM_PLAYER_BUFFERING_MODE_SLINK (pos %lld, dur %lld, size %lld), in/out:%d/%d, buffer_criteria:%d, time_rate:%f, need:%d sec\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);
+       debug_log ("pos %lld, dur %lld, size %lld, in/out:%d/%d, buffer_criteria:%d, time_rate:%f, need:%d sec\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);
 
        if (((expected_play_time == TO_THE_END) && (content_info.position <= 0)) ||
                (content_info.duration <= 0) ||
                (content_info.content_size <= 0))
        {
-               debug_warning ("Impossible to update buffer setting!! keep previous setting!\n");
+               debug_warning ("keep previous setting.\n");
                return;
        }
 
        if ((bitrate_info.byte_out_rate <= 0) || (bitrate_info.buffer_criteria == 0))
        {
-               debug_warning ("Don't need to change buffer setting(or impossible)!! keep previous setting!\n");
+               debug_warning ("keep previous setting.\n");
                return;
        }
 
@@ -799,10 +797,11 @@ streaming_handle_adaptive_buffering_mode( mm_player_streaming_t* streamer,
        }
        else
        {
-               // buffering_bytes will be set as streamer->default_val.buffering_time
-               debug_warning ("*Warning : receiving rate(%d) > avg content bitrate(%d)!\n", bitrate_info.byte_in_rate, bitrate_info.byte_out_rate);
-               debug_warning ("*Warning : There is no reason to buffering.!\n");
-               debug_warning ("*Warning : in-rate or content bitrate has reported wrong value.!\n");
+               /* 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. */
+               debug_warning ("don't need to do buffering.\n");
        }
 
        if (buffering_bytes > 0)
@@ -821,15 +820,15 @@ streaming_handle_adaptive_buffering_mode( mm_player_streaming_t* streamer,
 
        if (buffer_buffering_time < default_buffering_time)
        {
-               debug_log ("[NEW- adj] buffering time : %2.2f --> %2.2f\n", buffer_buffering_time, default_buffering_time);
-               debug_log ("[NEW- adj] buffering bytes : %d or %d or %d\n",
+               debug_log ("adjusted time: %2.2f -> %2.2f\n", buffer_buffering_time, default_buffering_time);
+               debug_log ("adjusted bytes : %d or %d or %d\n",
                        buffering_bytes,
                        (gint)(bitrate_info.byte_out_rate * buffer_buffering_time),
                        (gint)(bitrate_info.buffer_criteria * buffer_buffering_time));
 
                if (content_info.position > 0)
                {
-                       // start monitoring the abmormal state
+                       /* start monitoring the abmormal state */
                        streamer->default_val.buffering_monitor = TRUE;
                }
 
@@ -841,8 +840,8 @@ streaming_handle_adaptive_buffering_mode(   mm_player_streaming_t* streamer,
        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);
 
-       debug_log ("[NEW- last][buffering_monitor == %s] bytes %d, time %f, per_byte %f, per_time %f\n",
-                                                                               (streamer->default_val.buffering_monitor)?"OO":"XX",
+       debug_log ("monitor %d, bytes %d, time %f, per_byte %f, per_time %f\n",
+                                                                               streamer->default_val.buffering_monitor,
                                                                                buffering_bytes, buffer_buffering_time, per_byte, per_time);
 
        (*buffer_info).buffering_bytes = buffering_bytes;
@@ -950,12 +949,12 @@ streaming_update_buffer_setting   (       mm_player_streaming_t* streamer,
                        buffer_handle->buffering_time = buffer_info.buffering_time;
        }
 
-       debug_log ("new buffer size [%d -> %d bytes] / [%2.2f -> %2.2f sec] / %s \n",
+       debug_log ("adj buffer(%d) %d->%d bytes/%2.2f->%2.2f sec\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,
-                                       (IS_MUXED_BUFFERING_MODE(streamer))?"MUXED":((IS_DEMUXED_BUFFERING_MODE(streamer))?"DEMUXED":"----"));
+                                       GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_info.buffering_time);
 
-       // queue2 : bytes, multiqueue : 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)))
        {
@@ -972,7 +971,7 @@ streaming_update_buffer_setting     (       mm_player_streaming_t* streamer,
 
        streaming_set_buffer_percent(streamer, streamer->streaming_buffer_type, low_percent, buffer_info.percent_byte, buffer_info.percent_time);
 
-       debug_log("[FINAL] buffer setting : size %d, time %f, per %f\n",
+       debug_log("buffer setting: size %d, time %f, per %f\n",
                                                        GET_CURRENT_BUFFERING_BYTE(buffer_handle),
                                                        GET_CURRENT_BUFFERING_TIME(buffer_handle),
                                                        buffer_handle->buffer_high_percent);
@@ -983,7 +982,7 @@ streaming_update_buffer_setting     (       mm_player_streaming_t* streamer,
 static void
 streaming_adjust_min_threshold(mm_player_streaming_t* streamer, gint64 position)
 {
-#define DEFAULT_TIME_PAD 1     // sec
+#define DEFAULT_TIME_PAD 1     /* sec */
        gint playing_time = 0;
 
        MMPLAYER_FENTER();
@@ -992,9 +991,9 @@ streaming_adjust_min_threshold(mm_player_streaming_t* streamer, gint64 position)
 
        playing_time = (gint)((position - streamer->default_val.prev_pos) / GST_SECOND);
 
-       debug_log ("[NEW] buffering monitor = %s\n", (streamer->default_val.buffering_monitor)?"ON":"OFF");
-       debug_log ("[NEW] playing_time ( %d sec) = %lld - %lld \n", playing_time, position, streamer->default_val.prev_pos);
-       debug_log ("[NEW] default time : %2.3f, prev buffering t : %2.3f\n",
+       debug_log ("buffering monitor = %s\n", (streamer->default_val.buffering_monitor)?"ON":"OFF");
+       debug_log ("playing_time ( %d sec) = %lld - %lld \n", playing_time, position, streamer->default_val.prev_pos);
+       debug_log ("default time : %2.3f, prev buffering t : %2.3f\n",
                                        streamer->default_val.buffering_time, streamer->buffer_handle[streamer->streaming_buffer_type].buffering_time);
 
        if ((streamer->default_val.buffering_monitor) && (playing_time <= (gint)streamer->default_val.buffering_time))
@@ -1012,7 +1011,7 @@ streaming_adjust_min_threshold(mm_player_streaming_t* streamer, gint64 position)
                streamer->default_val.buffering_time = DEFAULT_BUFFERING_TIME;
        }
 
-       debug_log ("[NEW] new default min value %2.3f \n", streamer->default_val.buffering_time);
+       debug_log ("new default min value %2.3f \n", streamer->default_val.buffering_time);
 
        streamer->default_val.buffering_monitor = FALSE;
        streamer->default_val.prev_pos = position;
@@ -1032,7 +1031,6 @@ streaming_update_buffering_status(mm_player_streaming_t* streamer, GstMessage *b
        /* update when buffering has started. */
        if ( !streamer->is_buffering )
        {
-               debug_log ("buffering has started.\n");
                streamer->is_buffering = TRUE;
                streamer->is_buffering_done = FALSE;
                streamer->buffering_percent = -1;
@@ -1049,7 +1047,8 @@ streaming_update_buffering_status(mm_player_streaming_t* streamer, GstMessage *b
 
        if (streamer->buffering_percent < buffer_percent)
        {
-               debug_log ("[%s] buffering %d%%....\n", GST_OBJECT_NAME(GST_MESSAGE_SRC(buffering_msg)), buffer_percent);
+               debug_log ("[%s] buffering %d%%....\n",
+                       GST_OBJECT_NAME(GST_MESSAGE_SRC(buffering_msg)), buffer_percent);
                streamer->buffering_percent = buffer_percent;
        }
        else
@@ -1059,7 +1058,6 @@ streaming_update_buffering_status(mm_player_streaming_t* streamer, GstMessage *b
 
        if ((streamer->buffering_percent == MAX_BUFFER_PERCENT) || (streamer->is_buffering_done == TRUE))
        {
-               debug_log ("buffering had done. finished!!\n");
                streamer->is_buffering = FALSE;
                streamer->buffering_req.is_pre_buffering = FALSE;
                if (streamer->buffering_percent == MAX_BUFFER_PERCENT)
@@ -1069,13 +1067,13 @@ streaming_update_buffering_status(mm_player_streaming_t* streamer, GstMessage *b
        }
        else
        {
-               // need to update periodically in case of slink mode
+               /* need to update periodically in case of slink mode */
                if ((increased_per == TRUE) &&
                        (buffer_percent%10 == 0) &&
                        (streamer->buffering_req.mode == MM_PLAYER_BUFFERING_MODE_SLINK) &&
                        (streamer->buffering_req.is_pre_buffering == FALSE))
                {
-                       debug_log ("Update buffer setting to reflect data receiving rate (slink mode)\n");
+                       /* Update buffer setting to reflect data receiving rate for slink mode */
                        streamer->need_update = TRUE;
                }
        }