[0.6.136] change naming the next playback

- use gapless playback as GStreamer upstream

Change-Id: I09e725e394ca5c196ed8e047fc511883bdcaf82d

diff --git a/src/include/mm_player_priv.h b/src/include/mm_player_priv.h
index c767fb1..827e0e1 100644 (file)
--- a/src/include/mm_player_priv.h
+++ b/src/include/mm_player_priv.h
@@ -560,11 +560,11 @@ typedef struct {
        GMutex cmd_lock;
        GMutex playback_lock;
 
-       /* next play thread */
-       GThread* next_play_thread;
-       gboolean next_play_thread_exit;
-       GCond next_play_thread_cond;
-       GMutex next_play_thread_mutex;
+       /* gapless play thread */
+       GThread* gapless_play_thread;
+       gboolean gapless_play_thread_exit;
+       GCond gapless_play_thread_cond;
+       GMutex gapless_play_thread_mutex;
        mm_player_gapless_t gapless;
 
        /* capture thread */

diff --git a/src/include/mm_player_utils.h b/src/include/mm_player_utils.h
index 4659fa0..efcb3f4 100644 (file)
--- a/src/include/mm_player_utils.h
+++ b/src/include/mm_player_utils.h
@@ -72,11 +72,11 @@ do {        \
 #define MMPLAYER_CAPTURE_THREAD_WAIT(x_player)               g_cond_wait(&((mm_player_t *)x_player)->capture_thread_cond, &((mm_player_t *)x_player)->capture_thread_mutex)
 #define MMPLAYER_CAPTURE_THREAD_SIGNAL(x_player)             g_cond_signal(&((mm_player_t *)x_player)->capture_thread_cond);
 
-/* next play thread */
-#define MMPLAYER_NEXT_PLAY_THREAD_LOCK(x_player)             g_mutex_lock(&((mm_player_t *)x_player)->next_play_thread_mutex)
-#define MMPLAYER_NEXT_PLAY_THREAD_UNLOCK(x_player)           g_mutex_unlock(&((mm_player_t *)x_player)->next_play_thread_mutex)
-#define MMPLAYER_NEXT_PLAY_THREAD_WAIT(x_player)             g_cond_wait(&((mm_player_t *)x_player)->next_play_thread_cond, &((mm_player_t *)x_player)->next_play_thread_mutex)
-#define MMPLAYER_NEXT_PLAY_THREAD_SIGNAL(x_player)           g_cond_signal(&((mm_player_t *)x_player)->next_play_thread_cond);
+/* gapless play thread */
+#define MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(x_player)             g_mutex_lock(&((mm_player_t *)x_player)->gapless_play_thread_mutex)
+#define MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(x_player)           g_mutex_unlock(&((mm_player_t *)x_player)->gapless_play_thread_mutex)
+#define MMPLAYER_GAPLESS_PLAY_THREAD_WAIT(x_player)             g_cond_wait(&((mm_player_t *)x_player)->gapless_play_thread_cond, &((mm_player_t *)x_player)->gapless_play_thread_mutex)
+#define MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(x_player)           g_cond_signal(&((mm_player_t *)x_player)->gapless_play_thread_cond);
 
 /* gst bus msg thread */
 #define MMPLAYER_BUS_MSG_THREAD_LOCK(x_player)                   g_mutex_lock(&((mm_player_t *)x_player)->bus_msg_thread_mutex)
@@ -89,7 +89,6 @@ do {  \
 #define MMPLAYER_FSINK_LOCK(x_player)                        g_mutex_lock(&((mm_player_t *)x_player)->fsink_lock)
 #define MMPLAYER_FSINK_UNLOCK(x_player)                      g_mutex_unlock(&((mm_player_t *)x_player)->fsink_lock)
 
-
 /* handling update tag */
 #define MMPLAYER_UPDATE_TAG_LOCK(x_player)                   g_mutex_lock(&((mm_player_t *)x_player)->update_tag_lock)
 #define MMPLAYER_UPDATE_TAG_UNLOCK(x_player)                 g_mutex_unlock(&((mm_player_t *)x_player)->update_tag_lock)

diff --git a/src/mm_player_priv.c b/src/mm_player_priv.c
index c64cb39..a904607 100644 (file)
--- a/src/mm_player_priv.c
+++ b/src/mm_player_priv.c
@@ -169,7 +169,7 @@ static int          __mmplayer_check_not_supported_codec(mm_player_t* player, const gcha
 static void            __mmplayer_add_sink(mm_player_t* player, GstElement* sink);
 static void            __mmplayer_del_sink(mm_player_t* player, GstElement* sink);
 static void            __mmplayer_release_signal_connection(mm_player_t* player, MMPlayerSignalType type);
-static gpointer __mmplayer_next_play_thread(gpointer data);
+static gpointer __mmplayer_gapless_play_thread(gpointer data);
 static gboolean __mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element);
 static GstPadProbeReturn __mmplayer_dump_buffer_probe_cb(GstPad *pad,  GstPadProbeInfo *info, gpointer u_data);
 static void __mmplayer_release_dump_list(GList *dump_list);
@@ -184,7 +184,7 @@ static int __mmplayer_realize_streaming_ext(mm_player_t* player);
 static int __mmplayer_unrealize_streaming_ext(mm_player_t *player);
 static int __mmplayer_start_streaming_ext(mm_player_t *player);
 static int __mmplayer_destroy_streaming_ext(mm_player_t* player);
-static gboolean __mmplayer_verify_next_play_path(mm_player_t *player);
+static gboolean __mmplayer_verify_gapless_play_path(mm_player_t *player);
 static void __mmplayer_activate_next_source(mm_player_t *player, GstState target);
 static void __mmplayer_check_pipeline(mm_player_t* player);
 static gboolean __mmplayer_deactivate_selector(mm_player_t *player, MMPlayerTrackType type);
@@ -812,21 +812,21 @@ ALREADY_GOING:
        return MM_ERROR_PLAYER_NO_OP;
 }
 
-static gpointer __mmplayer_next_play_thread(gpointer data)
+static gpointer __mmplayer_gapless_play_thread(gpointer data)
 {
        mm_player_t* player = (mm_player_t*) data;
        MMPlayerGstElement *mainbin = NULL;
 
        MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
 
-       MMPLAYER_NEXT_PLAY_THREAD_LOCK(player);
-       while (!player->next_play_thread_exit) {
-               LOGD("next play thread started. waiting for signal.\n");
-               MMPLAYER_NEXT_PLAY_THREAD_WAIT(player);
+       MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
+       while (!player->gapless_play_thread_exit) {
+               LOGD("gapless play thread started. waiting for signal.\n");
+               MMPLAYER_GAPLESS_PLAY_THREAD_WAIT(player);
 
                LOGD("reconfigure pipeline for gapless play.\n");
 
-               if (player->next_play_thread_exit) {
+               if (player->gapless_play_thread_exit) {
                        if (player->gapless.reconfigure) {
                                player->gapless.reconfigure = false;
                                MMPLAYER_PLAYBACK_UNLOCK(player);
@@ -845,7 +845,7 @@ static gpointer __mmplayer_next_play_thread(gpointer data)
 
                __mmplayer_activate_next_source(player, GST_STATE_PLAYING);
        }
-       MMPLAYER_NEXT_PLAY_THREAD_UNLOCK(player);
+       MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(player);
 
        return NULL;
 }
@@ -5377,20 +5377,20 @@ _mmplayer_create_player(MMHandleType handle)
        /* create update tag lock */
        g_mutex_init(&player->update_tag_lock);
 
-       /* create next play mutex */
-       g_mutex_init(&player->next_play_thread_mutex);
+       /* create gapless play mutex */
+       g_mutex_init(&player->gapless_play_thread_mutex);
 
-       /* create next play cond */
-       g_cond_init(&player->next_play_thread_cond);
+       /* create gapless play cond */
+       g_cond_init(&player->gapless_play_thread_cond);
 
-       /* create next play thread */
-       player->next_play_thread =
-               g_thread_try_new("next_play_thread", __mmplayer_next_play_thread, (gpointer)player, NULL);
-       if (!player->next_play_thread) {
-               LOGE("failed to create next play thread");
+       /* create gapless play thread */
+       player->gapless_play_thread =
+               g_thread_try_new("gapless_play_thread", __mmplayer_gapless_play_thread, (gpointer)player, NULL);
+       if (!player->gapless_play_thread) {
+               LOGE("failed to create gapless play thread");
                ret = MM_ERROR_PLAYER_RESOURCE_LIMIT;
-               g_mutex_clear(&player->next_play_thread_mutex);
-               g_cond_clear(&player->next_play_thread_cond);
+               g_mutex_clear(&player->gapless_play_thread_mutex);
+               g_cond_clear(&player->gapless_play_thread_cond);
                goto ERROR;
        }
 
@@ -5496,18 +5496,18 @@ ERROR:
 
        g_queue_free(player->bus_msg_q);
 
-       /* free next play thread */
-       if (player->next_play_thread) {
-               MMPLAYER_NEXT_PLAY_THREAD_LOCK(player);
-               player->next_play_thread_exit = TRUE;
-               MMPLAYER_NEXT_PLAY_THREAD_SIGNAL(player);
-               MMPLAYER_NEXT_PLAY_THREAD_UNLOCK(player);
+       /* free gapless play thread */
+       if (player->gapless_play_thread) {
+               MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
+               player->gapless_play_thread_exit = TRUE;
+               MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(player);
+               MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(player);
 
-               g_thread_join(player->next_play_thread);
-               player->next_play_thread = NULL;
+               g_thread_join(player->gapless_play_thread);
+               player->gapless_play_thread = NULL;
 
-               g_mutex_clear(&player->next_play_thread_mutex);
-               g_cond_clear(&player->next_play_thread_cond);
+               g_mutex_clear(&player->gapless_play_thread_mutex);
+               g_cond_clear(&player->gapless_play_thread_cond);
        }
 
        /* release attributes */
@@ -5698,18 +5698,18 @@ _mmplayer_destroy(MMHandleType handle)
 
        __mmplayer_destroy_streaming_ext(player);
 
-       /* release next play thread */
-       if (player->next_play_thread) {
-               MMPLAYER_NEXT_PLAY_THREAD_LOCK(player);
-               player->next_play_thread_exit = TRUE;
-               MMPLAYER_NEXT_PLAY_THREAD_SIGNAL(player);
-               MMPLAYER_NEXT_PLAY_THREAD_UNLOCK(player);
+       /* release gapless play thread */
+       if (player->gapless_play_thread) {
+               MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
+               player->gapless_play_thread_exit = TRUE;
+               MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(player);
+               MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(player);
 
-               LOGD("waitting for next play thread exit\n");
-               g_thread_join(player->next_play_thread);
-               g_mutex_clear(&player->next_play_thread_mutex);
-               g_cond_clear(&player->next_play_thread_cond);
-               LOGD("next play thread released\n");
+               LOGD("waitting for gapless play thread exit\n");
+               g_thread_join(player->gapless_play_thread);
+               g_mutex_clear(&player->gapless_play_thread_mutex);
+               g_cond_clear(&player->gapless_play_thread_cond);
+               LOGD("gapless play thread released\n");
        }
 
        _mmplayer_release_video_capture(player);
@@ -7263,7 +7263,7 @@ __mmplayer_get_next_uri(mm_player_t *player)
 }
 
 static gboolean
-__mmplayer_verify_next_play_path(mm_player_t *player)
+__mmplayer_verify_gapless_play_path(mm_player_t *player)
 {
 #define REPEAT_COUNT_INFINITELY -1
 #define REPEAT_COUNT_MIN 2
@@ -7278,7 +7278,7 @@ __mmplayer_verify_next_play_path(mm_player_t *player)
 
        MMPLAYER_FENTER();
 
-       LOGD("checking for next play option");
+       LOGD("checking for gapless play option");
 
        if (player->pipeline->textbin) {
                LOGE("subtitle path is enabled. gapless play is not supported.\n");
@@ -7353,12 +7353,12 @@ __mmplayer_verify_next_play_path(mm_player_t *player)
        return TRUE;
 
 ERROR:
-       LOGE("unable to play next path. EOS will be posted soon");
+       LOGE("unable to play gapless path. EOS will be posted soon");
        return FALSE;
 }
 
 static void
-__mmplayer_initialize_next_play(mm_player_t *player)
+__mmplayer_initialize_gapless_play(mm_player_t *player)
 {
        int i;
 
@@ -7456,7 +7456,7 @@ __mmplayer_activate_next_source(mm_player_t *player, GstState target)
        }
 
        /* Initialize Player values */
-       __mmplayer_initialize_next_play(player);
+       __mmplayer_initialize_gapless_play(player);
 
        mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
 
@@ -7675,7 +7675,7 @@ __mmplayer_deactivate_old_path(mm_player_t *player)
        }
 
        MMPLAYER_PLAYBACK_LOCK(player);
-       MMPLAYER_NEXT_PLAY_THREAD_SIGNAL(player);
+       MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(player);
 
        MMPLAYER_FLEAVE();
        return;
@@ -7687,7 +7687,7 @@ ERROR:
 
                /*post error*/
                msg.code = MM_ERROR_PLAYER_INTERNAL;
-               LOGE("next_uri_play> deactivate error");
+               LOGE("gapless_uri_play> deactivate error");
 
                MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg);
                player->msg_posted = TRUE;
@@ -8185,7 +8185,7 @@ __mmplayer_gst_decode_drained(GstElement *bin, gpointer data)
        }
 
        if (!player->gapless.reconfigure && /* If it is already checked, skip verify. */
-               !__mmplayer_verify_next_play_path(player)) {
+               !__mmplayer_verify_gapless_play_path(player)) {
                LOGD("decoding is finished.");
                __mmplayer_reset_gapless_state(player);
                MMPLAYER_CMD_UNLOCK(player);