modify progressive download api

diff --git a/src/include/mm_player_pd.h b/src/include/mm_player_pd.h
index 81268e1..163f65c 100755 (executable)
--- a/src/include/mm_player_pd.h
+++ b/src/include/mm_player_pd.h
@@ -35,15 +35,15 @@
 
 typedef struct
 {
-       gchar *uri_to_download;         // path for download and playback
-       gchar *uri_to_save;                     // path for saving to local 
+       gchar *path_read_from;          // path for download and playback
+       gchar *location_to_save;                // path for saving to local
        gint64 total_size;                              // size of file to download (bytes)
 
-       GstElement *pushsrc;                    // src element of playback pipeline
-       GstElement *download_pipe;
-       GstElement *download_src;
-       GstElement *download_queue;
-       GstElement *download_sink;
+       GstElement *playback_pipeline_src;  // src element of playback pipeline
+       GstElement *downloader_pipeline;
+       GstElement *downloader_src;
+       GstElement *downloader_queue;
+       GstElement *downloader_sink;
 }mm_player_pd_t;
 
 /**
@@ -51,22 +51,22 @@ typedef struct
  *
  * @return     This function returns allocated handle.
  * @remarks
- * @see                _mmplayer_pd_destroy()
+ * @see                _mmplayer_destroy_pd_downloader()
  *
  */
-mm_player_pd_t * _mmplayer_pd_create ();
+mm_player_pd_t * _mmplayer_create_pd_downloader ();
 /**
- * This function release handle of progressive download.
+ * This function destroy progressive download.
  *
  * @param[in]  handle  Handle of player.
  * @return     This function returns true on success, or false on failure.
  * @remarks
- * @see                _mmplayer_pd_create()
+ * @see                _mmplayer_create_pd_downloader()
  *
  */
-gboolean _mmplayer_pd_destroy (MMHandleType handle);
+gboolean _mmplayer_destroy_pd_downloader  (MMHandleType handle);
 /**
- * This function initialize progressive download.
+ * This function realize progressive download.
  *
  * @param[in]  handle  Handle of player.
  * @param[in]  src_uri path to download.
@@ -74,40 +74,30 @@ gboolean _mmplayer_pd_destroy (MMHandleType handle);
  * @param[in]  pushsrc source element of playback pipeline
  * @return     This function returns true on success, or false on failure.
  * @remarks
- * @see                _mmplayer_pd_deinitialize()
+ * @see
  *
  */
-gboolean _mmplayer_pd_initialize (MMHandleType handle, gchar *src_uri, gchar *dst_uri, GstElement *pushsrc);
+gboolean _mmplayer_realize_pd_downloader (MMHandleType handle, gchar *src_uri, gchar *dst_uri, GstElement *pushsrc);
 /**
- * This function deinitialize progressive download.
+ * This function unrealize progressive download.
  *
  * @param[in]  handle  Handle of player.
  * @return     This function returns true on success, or false on failure.
  * @remarks
- * @see                _mmplayer_pd_initialize()
+ * @see                _mmplayer_realize_pd_downloader()
  *
  */
-gboolean _mmplayer_pd_deinitialize (MMHandleType handle);
+gboolean _mmplayer_unrealize_pd_downloader (MMHandleType handle);
 /**
  * This function start progressive download.
  *
  * @param[in]  handle  Handle of player.
  * @return     This function returns true on success, or false on failure.
  * @remarks
- * @see                _mmplayer_pd_stop()
- *
- */
-gboolean _mmplayer_pd_start (MMHandleType handle);
-/**
- * This function stop progressive download.
- *
- * @param[in]  handle  Handle of player.
- * @return     This function returns true on success, or false on failure.
- * @remarks
- * @see                _mmplayer_pd_start()
+ * @see
  *
  */
-gboolean _mmplayer_pd_stop (MMHandleType handle);
+gboolean _mmplayer_start_pd_downloader (MMHandleType handle);
 /**
  * This function get pd current status.
  *
@@ -119,7 +109,7 @@ gboolean _mmplayer_pd_stop (MMHandleType handle);
  * @see
  *
  */
-gboolean _mmplayer_pd_get_status(MMHandleType handle, guint64 *current_pos, guint64 *total_size);
+gboolean _mmplayer_get_pd_downloader_status(MMHandleType handle, guint64 *current_pos, guint64 *total_size);
 /**
  * This function set message callback of PD downloader.
  *
@@ -131,7 +121,7 @@ gboolean _mmplayer_pd_get_status(MMHandleType handle, guint64 *current_pos, guin
  * @see
  *
  */
-gint _mm_player_set_pd_message_callback(MMHandleType player, MMMessageCallback callback, gpointer user_param);
+gint _mm_player_set_pd_downloader_message_cb(MMHandleType player, MMMessageCallback callback, gpointer user_param);
 
 #ifdef __cplusplus
        }

diff --git a/src/include/mm_player_priv.h b/src/include/mm_player_priv.h
index 11463da..44bab14 100755 (executable)
--- a/src/include/mm_player_priv.h
+++ b/src/include/mm_player_priv.h
@@ -445,7 +445,7 @@ typedef struct {
 
        /* progressive download */
        mm_player_pd_t *pd_downloader;
-       gchar *pd_file_location;
+       gchar *pd_file_save_path;
        MMPlayerPDMode pd_mode;
 
        /* streaming player */

diff --git a/src/mm_player.c b/src/mm_player.c
index 1abea4c..948e73b 100755 (executable)
--- a/src/mm_player.c
+++ b/src/mm_player.c
@@ -207,7 +207,7 @@ int mm_player_set_pd_message_callback(MMHandleType player, MMMessageCallback cal
 
        return_val_if_fail(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 
-       result = _mm_player_set_pd_message_callback(player, callback, user_param);
+       result = _mm_player_set_pd_downloader_message_cb(player, callback, user_param);
 
        return result;
 }
@@ -774,7 +774,7 @@ int mm_player_get_pd_status(MMHandleType player, guint64 *current_pos, guint64 *
        return_val_if_fail(current_pos, MM_ERROR_COMMON_INVALID_ARGUMENT);
        return_val_if_fail(total_size, MM_ERROR_COMMON_INVALID_ARGUMENT);
 
-       result = _mmplayer_pd_get_status(player, current_pos, total_size);
+       result = _mmplayer_get_pd_downloader_status(player, current_pos, total_size);
 
        return result;
 }

diff --git a/src/mm_player_pd.c b/src/mm_player_pd.c
index 250ce0b..11d8826 100755 (executable)
--- a/src/mm_player_pd.c
+++ b/src/mm_player_pd.c
@@ -30,20 +30,20 @@
 ---------------------------------------------------------------------------------------*/
 
 /* It's callback to process whenever there is some changes in PD downloader. */
-static gboolean __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data);
+static gboolean __pd_downloader_callback(GstBus *bus, GstMessage *msg, gpointer data);
 
 /* This function posts messages to application. */
 /* Currently, MM_MESSAGE_PD_DOWNLOADER_START and MM_MESSAGE_PD_DOWNLOADER_END are used. */
-static gboolean __mmplayer_pd_post_message(mm_player_t * player, enum MMMessageType msgtype, MMMessageParamType* param);
+static gboolean __pd_downloader_post_message(mm_player_t * player, enum MMMessageType msgtype, MMMessageParamType* param);
 
 /*=======================================================================================
 |  FUNCTION DEFINITIONS                                                                                                                                                              |
 =======================================================================================*/
 static gboolean
-__pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
+__pd_downloader_callback(GstBus *bus, GstMessage *msg, gpointer data)
 {
        mm_player_t * player = NULL;
-       mm_player_pd_t *pd_downloader = NULL;
+       mm_player_pd_t *pd = NULL;
        gboolean bret = TRUE;
        
        debug_fenter();
@@ -54,9 +54,9 @@ __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
        player = MM_PLAYER_CAST((MMHandleType)data);
 
        /* get PD downloader handle */
-       pd_downloader = MM_PLAYER_GET_PD((MMHandleType)data);
+       pd = MM_PLAYER_GET_PD((MMHandleType)data);
 
-       return_val_if_fail ( pd_downloader, MM_ERROR_INVALID_ARGUMENT );
+       return_val_if_fail ( pd, MM_ERROR_INVALID_ARGUMENT );
 
 //     g_print("%s\n", GST_MESSAGE_TYPE_NAME(msg));
 
@@ -64,15 +64,15 @@ __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
        {
                case GST_MESSAGE_EOS:
                        {
-                               debug_log("PD EOS received....\n");
+                               debug_log("PD Downloader EOS received....\n");
 
-                               g_object_set (G_OBJECT (pd_downloader->pushsrc), "eos", TRUE, NULL);
+                               g_object_set (G_OBJECT (pd->playback_pipeline_src), "eos", TRUE, NULL);
 
                                /* notify application that download is completed */
-                               __mmplayer_pd_post_message(player, MM_MESSAGE_PD_DOWNLOADER_END, NULL);
+                               __pd_downloader_post_message(player, MM_MESSAGE_PD_DOWNLOADER_END, NULL);
 
                                #ifdef PD_SELF_DOWNLOAD
-                               _mmplayer_pd_stop ((MMHandleType)data);
+                               _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
                                #endif
                        }
                        break;
@@ -88,12 +88,12 @@ __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
                                gst_message_parse_error( msg, &error, &debug );
                                debug_error ("GST_MESSAGE_ERROR = %s\n", debug);
                                
-                               new_msg = gst_message_new_error (GST_OBJECT_CAST (pd_downloader->pushsrc), error, debug);
+                               new_msg = gst_message_new_error (GST_OBJECT_CAST (pd->playback_pipeline_src), error, debug);
 
                                /* notify application that pd has any error */
-                               ret = gst_element_post_message (pd_downloader->pushsrc, new_msg);
+                               ret = gst_element_post_message (pd->playback_pipeline_src, new_msg);
 
-                               _mmplayer_pd_stop ((MMHandleType)data);
+                               _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
                        }
                        break;
 
@@ -123,7 +123,7 @@ __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
                                break;
 
                        /* we only care about pipeline state changes */
-                       if (GST_MESSAGE_SRC (msg) != GST_OBJECT (pd_downloader->download_pipe))
+                       if (GST_MESSAGE_SRC (msg) != GST_OBJECT (pd->downloader_pipeline))
                                break;
 
                        src_name = gst_object_get_name (msg->src);
@@ -142,7 +142,7 @@ __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
 
                                case GST_STATE_PLAYING:
                                        /* notify application that download is stated */
-                                       __mmplayer_pd_post_message(player, MM_MESSAGE_PD_DOWNLOADER_START, NULL);
+                                       __pd_downloader_post_message(player, MM_MESSAGE_PD_DOWNLOADER_START, NULL);
                                        break;
 
                                default:
@@ -158,27 +158,27 @@ __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
                        gint64 size = 0LL;
 
                        /* get total size  of download file, (bytes) */
-                       if ( ! gst_element_query_duration( pd_downloader->download_pipe, &fmt, &size ) )
+                       if ( ! gst_element_query_duration( pd->downloader_pipeline, &fmt, &size ) )
                        {
                                GError *err = NULL;
                                GstMessage *new_msg = NULL;
 
                                err = g_error_new (GST_STREAM_ERROR, GST_STREAM_ERROR_FAILED, "can't get total size");
-                               new_msg = gst_message_new_error (GST_OBJECT_CAST (pd_downloader->pushsrc), err, NULL);
-                               gst_element_post_message (pd_downloader->pushsrc, new_msg);
+                               new_msg = gst_message_new_error (GST_OBJECT_CAST (pd->playback_pipeline_src), err, NULL);
+                               gst_element_post_message (pd->playback_pipeline_src, new_msg);
 
                                g_error_free (err);
 
                                // TODO: check if playback pipeline is closed well or not
-                               g_object_set (G_OBJECT (pd_downloader->pushsrc), "eos", TRUE, NULL);
+                               g_object_set (G_OBJECT (pd->playback_pipeline_src), "eos", TRUE, NULL);
 
-                               _mmplayer_pd_stop ((MMHandleType)data);
+                               _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
 
                                debug_error("failed to query total size for download\n");
                                break;
                        }
 
-                       pd_downloader->total_size = size;
+                       pd->total_size = size;
 
                        debug_log("PD total size : %lld bytes\n", size);
                }
@@ -194,8 +194,8 @@ __pd_download_callback(GstBus *bus, GstMessage *msg, gpointer data)
        return bret;
 }
 
-gboolean
-__mmplayer_pd_post_message(mm_player_t * player, enum MMMessageType msgtype, MMMessageParamType* param)
+
+gboolean __pd_downloader_post_message(mm_player_t * player, enum MMMessageType msgtype, MMMessageParamType* param)
 {
        debug_fenter();
 
@@ -214,122 +214,108 @@ __mmplayer_pd_post_message(mm_player_t * player, enum MMMessageType msgtype, MMM
        return TRUE;
 }
 
-gboolean _mmplayer_pd_get_status(MMHandleType handle, guint64 *current_pos, guint64 *total_size)
+
+gboolean _mmplayer_get_pd_downloader_status(MMHandleType handle, guint64 *current_pos, guint64 *total_size)
 {
        debug_fenter();
 
-       mm_player_pd_t * pd_downloader = NULL;
+       mm_player_pd_t * pd = NULL;
        guint64 bytes = 0;
 
        return_val_if_fail(handle, MM_ERROR_INVALID_ARGUMENT);
 
-       pd_downloader = MM_PLAYER_GET_PD(handle);
+       pd = MM_PLAYER_GET_PD(handle);
 
-       return_val_if_fail(pd_downloader, MM_ERROR_INVALID_ARGUMENT);
-       return_val_if_fail(pd_downloader->download_pipe, MM_ERROR_INVALID_ARGUMENT);
+       return_val_if_fail(pd, MM_ERROR_INVALID_ARGUMENT);
+       return_val_if_fail(pd->downloader_pipeline, MM_ERROR_INVALID_ARGUMENT);
 
-       if ( !pd_downloader->total_size )
+       if ( !pd->total_size )
        {
                debug_warning("not ready to get total size\n");
                return FALSE;
        }
 
-       g_object_get(pd_downloader->download_sink, "current-bytes", &bytes, NULL);
+       g_object_get(pd->downloader_sink, "current-bytes", &bytes, NULL);
 
-       debug_log("PD status : %lld / %lld\n", bytes, pd_downloader->total_size);
+       debug_log("PD status : %lld / %lld\n", bytes, pd->total_size);
 
        *current_pos = bytes;
-       *total_size = pd_downloader->total_size;
+       *total_size = pd->total_size;
 
        debug_fleave();
 
        return TRUE;
 }
 
-mm_player_pd_t * _mmplayer_pd_create ()
+
+mm_player_pd_t * _mmplayer_create_pd_downloader()
 {
        debug_fenter();
 
-       mm_player_pd_t * pd_downloader = NULL;
+       mm_player_pd_t * pd = NULL;
 
        /* create PD handle */
-       pd_downloader = (mm_player_pd_t *) malloc (sizeof (mm_player_pd_t));
-       if ( !pd_downloader )
+       pd = (mm_player_pd_t *) malloc (sizeof (mm_player_pd_t));
+       if ( !pd )
        {
-               debug_error ("Failed to create pd_downloader handle...\n");
+               debug_error ("Failed to create pd downloader handle...\n");
                return FALSE;
        }
 
        debug_fleave();
 
-       return pd_downloader;
+       return pd;
 }
 
-gboolean _mmplayer_pd_destroy (MMHandleType handle)
+
+gboolean _mmplayer_destroy_pd_downloader (MMHandleType handle)
 {
        debug_fenter();
 
-       mm_player_pd_t * pd_downloader = NULL;
+       mm_player_pd_t * pd = NULL;
 
        return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 
-       pd_downloader = MM_PLAYER_GET_PD(handle);
+       pd = MM_PLAYER_GET_PD(handle);
 
-       if (pd_downloader->download_pipe)
-               _mmplayer_pd_stop (handle);
+       if (pd->downloader_pipeline)
+               _mmplayer_unrealize_pd_downloader (handle);
 
        /* release PD handle */
-       MMPLAYER_FREEIF(pd_downloader);
+       MMPLAYER_FREEIF(pd);
 
        debug_fleave();
 
        return TRUE;
 }
 
-gboolean _mmplayer_pd_initialize (MMHandleType handle, gchar *src_uri, gchar *dst_uri, GstElement *pushsrc)
+
+gboolean _mmplayer_realize_pd_downloader (MMHandleType handle, gchar *src_uri, gchar *dst_uri, GstElement *pushsrc)
 {
        debug_fenter();
 
-       mm_player_pd_t * pd_downloader = NULL;
+       mm_player_pd_t * pd = NULL;
 
        return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
        return_val_if_fail ( src_uri, MM_ERROR_INVALID_ARGUMENT );
        return_val_if_fail ( dst_uri, MM_ERROR_INVALID_ARGUMENT );
        return_val_if_fail ( pushsrc, MM_ERROR_INVALID_ARGUMENT );
 
-       pd_downloader = MM_PLAYER_GET_PD(handle);
+       pd = MM_PLAYER_GET_PD(handle);
 
        /* initialize */
-       pd_downloader->uri_to_download = g_strdup (src_uri);
-       pd_downloader->uri_to_save = g_strdup (dst_uri);
-       pd_downloader->pushsrc = pushsrc;
-       pd_downloader->total_size = 0LL;
+       pd->path_read_from = g_strdup (src_uri);
+       pd->location_to_save = g_strdup (dst_uri);
+       pd->playback_pipeline_src = pushsrc;
+       pd->total_size = 0LL;
 
        debug_fleave();
        
        return TRUE;
 }
 
-gboolean _mmplayer_pd_deinitialize (MMHandleType handle)
-{
-       debug_fenter();
-
-       mm_player_pd_t * pd_downloader = NULL;
-
-       return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
-
-       pd_downloader = MM_PLAYER_GET_PD(handle);
 
-       /* free */
-       MMPLAYER_FREEIF(pd_downloader->uri_to_download);
-       MMPLAYER_FREEIF(pd_downloader->uri_to_save);
-
-       debug_fleave(); 
-
-       return TRUE;
-}
-
-gboolean _mmplayer_pd_start (MMHandleType handle)
+gboolean _mmplayer_start_pd_downloader (MMHandleType handle)
 {
        GstBus* bus = NULL;
        gboolean bret = FALSE;
@@ -339,52 +325,52 @@ gboolean _mmplayer_pd_start (MMHandleType handle)
 
        debug_fenter();
 
-       mm_player_pd_t * pd_downloader = NULL;
+       mm_player_pd_t * pd = NULL;
 
        return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 
-       pd_downloader = MM_PLAYER_GET_PD(handle);
+       pd = MM_PLAYER_GET_PD(handle);
 
        /* pipeline */
-       pd_downloader->download_pipe = gst_pipeline_new ("PD Downloader");
-       if (NULL == pd_downloader->download_pipe)
+       pd->downloader_pipeline = gst_pipeline_new ("PD Downloader");
+       if (NULL == pd->downloader_pipeline)
        {
                debug_error ("Can't create PD download pipeline...");
                return FALSE;
        }
 
        /* source */
-       pd_downloader->download_src = gst_element_factory_make ("souphttpsrc", "PD HTTP download source");
-       if (NULL == pd_downloader->download_src)
+       pd->downloader_src = gst_element_factory_make ("souphttpsrc", "PD HTTP download source");
+       if (NULL == pd->downloader_src)
        {
                debug_error ("Can't create PD download src...");
                return FALSE;
        }
 
        /* queue */
-       pd_downloader->download_queue = gst_element_factory_make ("queue", "PD download queue");
-       if (NULL == pd_downloader->download_queue)
+       pd->downloader_queue = gst_element_factory_make ("queue", "PD download queue");
+       if (NULL == pd->downloader_queue)
        {
                debug_error ("Can't create PD download queue...");
                return FALSE;
        }
 
        /* filesink */
-       pd_downloader->download_sink = gst_element_factory_make ("filesink", "PD download sink");
-       if (NULL == pd_downloader->download_sink)
+       pd->downloader_sink = gst_element_factory_make ("filesink", "PD download sink");
+       if (NULL == pd->downloader_sink)
        {
                debug_error ("Can't create PD download sink...");
                return FALSE;
        }
 
-       g_object_set(pd_downloader->download_sink, "sync", FALSE, NULL);
+       g_object_set(pd->downloader_sink, "sync", FALSE, NULL);
        
        /* Add to bin and link */
-       gst_bin_add_many (GST_BIN (pd_downloader->download_pipe), 
-                                       pd_downloader->download_src, pd_downloader->download_queue, pd_downloader->download_sink,
+       gst_bin_add_many (GST_BIN (pd->downloader_pipeline),
+                                       pd->downloader_src, pd->downloader_queue, pd->downloader_sink,
                                        NULL);
        
-       bret = gst_element_link_many (pd_downloader->download_src, pd_downloader->download_queue, pd_downloader->download_sink, NULL);
+       bret = gst_element_link_many (pd->downloader_src, pd->downloader_queue, pd->downloader_sink, NULL);
        if (FALSE == bret)
        {
                debug_error ("Can't link elements src and sink...");
@@ -392,20 +378,20 @@ gboolean _mmplayer_pd_start (MMHandleType handle)
        }
        
        /* Get Bus and set callback to watch */
-       bus = gst_pipeline_get_bus (GST_PIPELINE (pd_downloader->download_pipe));
-       gst_bus_add_watch (bus, __pd_download_callback, (gpointer)handle);
+       bus = gst_pipeline_get_bus (GST_PIPELINE (pd->downloader_pipeline));
+       gst_bus_add_watch (bus, __pd_downloader_callback, (gpointer)handle);
        gst_object_unref (bus);
        
        /* Set URI on HTTP source */
-       g_object_set (G_OBJECT (pd_downloader->download_src), "location", pd_downloader->uri_to_download, NULL);
+       g_object_set (G_OBJECT (pd->downloader_src), "location", pd->path_read_from, NULL);
 
        /* set file download location on filesink*/
-       g_object_set (G_OBJECT (pd_downloader->download_sink), "location", pd_downloader->uri_to_save, NULL);
+       g_object_set (G_OBJECT (pd->downloader_sink), "location", pd->location_to_save, NULL);
 
-       debug_log ("src location = %s, save location = %s\n", pd_downloader->uri_to_download, pd_downloader->uri_to_save);
+       debug_log ("src location = %s, save location = %s\n", pd->path_read_from, pd->location_to_save);
 
        /* Start to download */
-       sret = gst_element_set_state (pd_downloader->download_pipe, GST_STATE_PLAYING);
+       sret = gst_element_set_state (pd->downloader_pipeline, GST_STATE_PLAYING);
        if (GST_STATE_CHANGE_FAILURE == sret)
        {
                debug_error ("PD download pipeline failed to go to PLAYING state...");
@@ -414,7 +400,7 @@ gboolean _mmplayer_pd_start (MMHandleType handle)
 
        debug_log ("set_state :: sret = %d\n", sret);
 
-       sret = gst_element_get_state (pd_downloader->download_pipe, &cur_state, &pending_state, GST_CLOCK_TIME_NONE);
+       sret = gst_element_get_state (pd->downloader_pipeline, &cur_state, &pending_state, GST_CLOCK_TIME_NONE);
        if (GST_STATE_CHANGE_FAILURE == sret)
        {
                debug_error ("PD download pipeline failed to do get_state...");
@@ -428,29 +414,36 @@ gboolean _mmplayer_pd_start (MMHandleType handle)
        return TRUE;
 }
 
-gboolean _mmplayer_pd_stop (MMHandleType handle)
+
+gboolean _mmplayer_unrealize_pd_downloader (MMHandleType handle)
 {
        debug_fenter();
 
-       mm_player_pd_t * pd_downloader = NULL;
+       mm_player_pd_t * pd = NULL;
 
-       return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
+       return_val_if_fail ( handle, FALSE );
 
-       pd_downloader = MM_PLAYER_GET_PD(handle);
+       pd = MM_PLAYER_GET_PD(handle);
 
-       return_val_if_fail ( pd_downloader->download_pipe, MM_ERROR_INVALID_ARGUMENT );
+       return_val_if_fail ( pd->downloader_pipeline, FALSE );
 
-       gst_element_set_state (pd_downloader->download_pipe, GST_STATE_NULL);
-       gst_element_get_state (pd_downloader->download_pipe, NULL, NULL, GST_CLOCK_TIME_NONE);
+       gst_element_set_state (pd->downloader_pipeline, GST_STATE_NULL);
+       gst_element_get_state (pd->downloader_pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 
-       pd_downloader->download_pipe = NULL;
+       gst_object_unref (G_OBJECT (pd->downloader_pipeline));
+       pd->downloader_pipeline = NULL;
+
+       /* free */
+       MMPLAYER_FREEIF(pd->path_read_from);
+       MMPLAYER_FREEIF(pd->location_to_save);
 
        debug_fleave();
 
        return TRUE;
 }
 
-gint _mm_player_set_pd_message_callback(MMHandleType handle, MMMessageCallback callback, gpointer user_param)
+
+gint _mm_player_set_pd_downloader_message_cb(MMHandleType handle, MMMessageCallback callback, gpointer user_param)
 {
        debug_fenter();
 

diff --git a/src/mm_player_priv.c b/src/mm_player_priv.c
index cdfa965..d3cbcf5 100755 (executable)
--- a/src/mm_player_priv.c
+++ b/src/mm_player_priv.c
@@ -219,6 +219,12 @@ static gboolean __is_http_progressive_down(mm_player_t* player);
 static gboolean __mmplayer_warm_up_video_codec( mm_player_t* player,  GstElementFactory *factory);
 static GstBusSyncReply __mmplayer_bus_sync_callback (GstBus * bus, GstMessage * message, gpointer data);
 
+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);
+
+
 /*===========================================================================================
 |                                                                                                                                                                                      |
 |  FUNCTION DEFINITIONS                                                                                                                                                |
@@ -301,6 +307,9 @@ __mmplayer_check_state(mm_player_t* player, enum PlayerCommandState command)
 
                case MMPLAYER_COMMAND_START:
                {
+                       if (MMPLAYER_IS_HTTP_PD(player))
+                               goto INVALID_STATE;
+
                        MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PLAYING;
 
                        if ( pending_state == MM_PLAYER_STATE_NONE )
@@ -1466,7 +1475,7 @@ __mmplayer_gst_callback(GstBus *bus, GstMessage *msg, gpointer data) // @
 
                        if (MMPLAYER_IS_HTTP_PD(player))
                        {       
-                               _mmplayer_pd_stop ((MMHandleType)player);
+                               _mmplayer_unrealize_pd_downloader ((MMHandleType)player);
                        }
                        
                        MMPLAYER_FREEIF( debug );
@@ -4166,13 +4175,13 @@ __mmplayer_gst_create_pipeline(mm_player_t* player) // @
                                        
                                        mm_attrs_get_string_by_name ( attrs, "pd_location", &path );
                                        
-                                       MMPLAYER_FREEIF(player->pd_file_location);
+                                       MMPLAYER_FREEIF(player->pd_file_save_path);
 
                                        debug_log("PD Location : %s\n", path);
 
                                        if ( path )
                                        {
-                                               player->pd_file_location = g_strdup(path);
+                                               player->pd_file_save_path = g_strdup(path);
                                        }
                                        else
                                        {
@@ -4188,7 +4197,7 @@ __mmplayer_gst_create_pipeline(mm_player_t* player) // @
                                        break;
                                }
 
-                               g_object_set(G_OBJECT(element), "location", player->pd_file_location, NULL);
+                               g_object_set(G_OBJECT(element), "location", player->pd_file_save_path, NULL);
                        }
                        
                        player->streaming_type = STREAMING_SERVICE_NONE;
@@ -5822,7 +5831,7 @@ _mmplayer_create_player(MMHandleType handle) // @
        if (MMPLAYER_IS_HTTP_PD(player))
        {
                player->pd_downloader = NULL;
-               player->pd_file_location = NULL;
+               player->pd_file_save_path = NULL;
        }
 
        /* give default value of sound effect setting */
@@ -5984,16 +5993,15 @@ ERROR:
 }
 
 int 
-__mmplayer_release_extended_streaming(mm_player_t* player)
+__mmplayer_destroy_streaming_ext(mm_player_t* player)
 {
        return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
 
-       if (player->pd_downloader && MMPLAYER_IS_HTTP_PD(player))
-       {
-               _mmplayer_pd_stop ((MMHandleType)player);
-               _mmplayer_pd_deinitialize ((MMHandleType)player);
-               _mmplayer_pd_destroy((MMHandleType)player);
-       }
+       if (player->pd_downloader)
+               _mmplayer_unrealize_pd_downloader((MMHandleType)player);
+
+       if (MMPLAYER_IS_HTTP_PD(player))
+               _mmplayer_destroy_pd_downloader((MMHandleType)player);
 
        if (MMPLAYER_IS_STREAMING(player))
        {
@@ -6019,7 +6027,7 @@ _mmplayer_destroy(MMHandleType handle) // @
        /* destroy can called at anytime */
        MMPLAYER_CHECK_STATE_RETURN_IF_FAIL ( player, MMPLAYER_COMMAND_DESTROY );
 
-       __mmplayer_release_extended_streaming(player);
+       __mmplayer_destroy_streaming_ext(player);
 
        /* release repeat thread */
        if ( player->repeat_thread_cond &&
@@ -6080,31 +6088,26 @@ _mmplayer_destroy(MMHandleType handle) // @
        return MM_ERROR_NONE;
 }
 
-
 int 
-__mmplayer_init_extended_streaming(mm_player_t* player)
+__mmplayer_realize_streaming_ext(mm_player_t* player)
 {
        int ret = MM_ERROR_NONE;
-       
+
+       debug_fenter();
        return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
 
        if (MMPLAYER_IS_HTTP_PD(player))
        {
                gboolean bret = FALSE;
-               gchar *src_uri = NULL;
-
-               player->pd_downloader = _mmplayer_pd_create ();
 
+               player->pd_downloader = _mmplayer_create_pd_downloader();
                if ( !player->pd_downloader )
                {
                        debug_error ("Unable to create PD Downloader...");
                        ret = MM_ERROR_PLAYER_NO_FREE_SPACE;
                }
-               
-               if (player->pd_mode == MM_PLAYER_PD_MODE_URI)
-                       src_uri = player->profile.uri;
-               
-               bret = _mmplayer_pd_initialize ((MMHandleType)player, src_uri, player->pd_file_location, player->pipeline->mainbin[MMPLAYER_M_SRC].gst);
+
+               bret = _mmplayer_realize_pd_downloader((MMHandleType)player, player->profile.uri, player->pd_file_save_path, player->pipeline->mainbin[MMPLAYER_M_SRC].gst);
                
                if (FALSE == bret)
                {
@@ -6113,6 +6116,7 @@ __mmplayer_init_extended_streaming(mm_player_t* player)
                }
        }
 
+       debug_fleave();
        return ret;
 }
 
@@ -6207,7 +6211,7 @@ _mmplayer_realize(MMHandleType hplayer) // @
        }
        else
        {
-               __mmplayer_init_extended_streaming(player);
+               __mmplayer_realize_streaming_ext(player);
        }
 
        debug_fleave();
@@ -6216,18 +6220,20 @@ _mmplayer_realize(MMHandleType hplayer) // @
 }
 
 int
-__mmplayer_deinit_extended_streaming(mm_player_t *player)
+__mmplayer_unrealize_streaming_ext(mm_player_t *player)
 {
+       debug_fenter();
        return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
        
        /* destroy can called at anytime */
        if (player->pd_downloader && MMPLAYER_IS_HTTP_PD(player))
        {
-               _mmplayer_pd_stop ((MMHandleType)player);
+               _mmplayer_unrealize_pd_downloader ((MMHandleType)player);
+               player->pd_downloader = NULL;
        }
 
+       debug_fleave();
        return MM_ERROR_NONE;
-
 }
 
 int
@@ -6243,7 +6249,7 @@ _mmplayer_unrealize(MMHandleType hplayer) // @
        /* check current state */
        MMPLAYER_CHECK_STATE_RETURN_IF_FAIL( player, MMPLAYER_COMMAND_UNREALIZE );
 
-       __mmplayer_deinit_extended_streaming(player);
+       __mmplayer_unrealize_streaming_ext(player);
 
        /* unrealize pipeline */
        ret = __gst_unrealize( player );
@@ -6568,26 +6574,40 @@ _mmplayer_set_buffer_seek_data_cb(MMHandleType hplayer, mm_player_buffer_seek_da
        return MM_ERROR_NONE;
 }
 
-int __mmplayer_start_extended_streaming(mm_player_t *player)
-{      
+int __mmplayer_start_streaming_ext(mm_player_t *player)
+{
+       gint ret = MM_ERROR_NONE;
+
+       debug_fenter();
        return_val_if_fail ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
 
-       if (MMPLAYER_IS_HTTP_PD(player) && player->pd_downloader)
+       if (MMPLAYER_IS_HTTP_PD(player))
        {
-               if (player->pd_mode == MM_PLAYER_PD_MODE_URI)
+               if ( !player->pd_downloader )
                {
-                       gboolean bret = FALSE;
-                       
-                       bret = _mmplayer_pd_start ((MMHandleType)player);
-                       if (FALSE == bret)
+                       ret = __mmplayer_realize_streaming_ext(player);
+
+                       if ( ret != MM_ERROR_NONE)
+                       {
+                               debug_error ("failed to realize streaming ext\n");
+                               return ret;
+                       }
+               }
+
+               if (player->pd_downloader && player->pd_mode == MM_PLAYER_PD_MODE_URI)
+               {
+                       ret = _mmplayer_start_pd_downloader ((MMHandleType)player);
+                       if ( !ret )
                        {
                                debug_error ("ERROR while starting PD...\n");
                                return MM_ERROR_PLAYER_NOT_INITIALIZED;
                        }
+                       ret = MM_ERROR_NONE;
                }
        }
 
-       return MM_ERROR_NONE;
+       debug_fleave();
+       return ret;
 }
 
 int
@@ -6623,8 +6643,11 @@ _mmplayer_start(MMHandleType hplayer) // @
                }
        }
 
-       if (__mmplayer_start_extended_streaming(player) != MM_ERROR_NONE)
-               return MM_ERROR_PLAYER_INTERNAL;
+       ret = __mmplayer_start_streaming_ext(player);
+       if ( ret != MM_ERROR_NONE )
+       {
+               debug_error("failed to start streaming ext \n");
+       }
        
        /* start pipeline */
        ret = __gst_start( player );
@@ -6750,6 +6773,8 @@ _mmplayer_stop(MMHandleType hplayer) // @
        /* NOTE : application should not wait for EOS after calling STOP */
        __mmplayer_cancel_delayed_eos( player );
 
+       __mmplayer_unrealize_streaming_ext(player);
+
        /* stop pipeline */
        ret = __gst_stop( player );
 
@@ -6788,6 +6813,9 @@ _mmplayer_pause(MMHandleType hplayer) // @
                         */
                        mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
                        debug_log("prepare mode : %s", (async ? "async" : "sync"));
+
+                       if (__mmplayer_start_streaming_ext(player) != MM_ERROR_NONE)
+                               return MM_ERROR_PLAYER_INTERNAL;
                }
                break;