src/mm_player_pd.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, naveen cherukuri <naveen.ch@samsung.com>,
   7  * YeJin Cho <cho.yejin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22 #include <mm_debug.h>
  23 #include <mm_error.h>
  24 #include "mm_player_pd.h"
  25 #include "mm_player_utils.h"
  26 #include "mm_player_priv.h"
  27
  28 /*---------------------------------------------------------------------------------------
  29 |    LOCAL FUNCTION PROTOTYPES:                                                                                                                 |
  30 ---------------------------------------------------------------------------------------*/
  31
  32 /* It's callback to process whenever there is some changes in PD downloader. */
  33 static gboolean __pd_downloader_callback(GstBus *bus, GstMessage *msg, gpointer data);
  34
  35 /* This function posts messages to application. */
  36 /* Currently, MM_MESSAGE_PD_DOWNLOADER_START and MM_MESSAGE_PD_DOWNLOADER_END are used. */
  37 static gboolean __pd_downloader_post_message(mm_player_t * player, enum MMMessageType msgtype, MMMessageParamType* param);
  38
  39 /*=======================================================================================
  40 |  FUNCTION DEFINITIONS                                                                                                                                                       |
  41 =======================================================================================*/
  42 static gboolean
  43 __pd_downloader_callback(GstBus *bus, GstMessage *msg, gpointer data)
  44 {
  45         mm_player_t * player = NULL;
  46         mm_player_pd_t *pd = NULL;
  47         gboolean bret = TRUE;
  48
  49         MMPLAYER_FENTER();
  50
  51         /* chech player handle */
  52         return_val_if_fail ( data, MM_ERROR_INVALID_ARGUMENT );
  53
  54         player = MM_PLAYER_CAST((MMHandleType)data);
  55
  56         /* get PD downloader handle */
  57         pd = MM_PLAYER_GET_PD((MMHandleType)data);
  58
  59         return_val_if_fail ( pd, MM_ERROR_INVALID_ARGUMENT );
  60
  61 //      g_print("%s\n", GST_MESSAGE_TYPE_NAME(msg));
  62
  63         switch ( GST_MESSAGE_TYPE( msg ) )
  64         {
  65                 case GST_MESSAGE_EOS:
  66                         {
  67                                 debug_log("PD Downloader EOS received....\n");
  68
  69                                 g_object_set (G_OBJECT (pd->playback_pipeline_src), "eos", TRUE, NULL);
  70
  71                                 /* notify application that download is completed */
  72                                 __pd_downloader_post_message(player, MM_MESSAGE_PD_DOWNLOADER_END, NULL);
  73
  74                                 #ifdef PD_SELF_DOWNLOAD
  75                                 _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
  76                                 #endif
  77                         }
  78                         break;
  79
  80                 case GST_MESSAGE_ERROR:
  81                         {
  82                                 GError *error = NULL;
  83                                 gchar* debug = NULL;
  84                                 GstMessage *new_msg = NULL;
  85
  86                                 /* get error code */
  87                                 gst_message_parse_error( msg, &error, &debug );
  88                                 debug_error ("GST_MESSAGE_ERROR = %s\n", debug);
  89
  90                                 new_msg = gst_message_new_error (GST_OBJECT_CAST (pd->playback_pipeline_src), error, debug);
  91
  92                                 /* notify application that pd has any error */
  93                                 gst_element_post_message (pd->playback_pipeline_src, new_msg);
  94
  95                                 _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
  96                                 MMPLAYER_FREEIF(debug);
  97                                 g_error_free( error);
  98                         }
  99                         break;
 100
 101                 case GST_MESSAGE_WARNING:
 102                         {
 103                                 char* debug = NULL;
 104                                 GError* error = NULL;
 105
 106                                 gst_message_parse_warning(msg, &error, &debug);
 107                                 debug_warning("warning : %s\n", error->message);
 108                                 debug_warning("debug : %s\n", debug);
 109
 110                                 MMPLAYER_FREEIF(debug);
 111                                 g_error_free( error);
 112                         }
 113                         break;
 114
 115                 case GST_MESSAGE_STATE_CHANGED:
 116                 {
 117                         GstState old_state, new_state;
 118                         gchar *src_name;
 119
 120                         /* get old and new state */
 121                         gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
 122
 123                         if (old_state == new_state)
 124                                 break;
 125
 126                         /* we only care about pipeline state changes */
 127                         if (GST_MESSAGE_SRC (msg) != GST_OBJECT (pd->downloader_pipeline))
 128                                 break;
 129
 130                         src_name = gst_object_get_name (msg->src);
 131                         debug_log ("%s changed state from %s to %s", src_name,
 132                                 gst_element_state_get_name (old_state),
 133                                 gst_element_state_get_name (new_state));
 134                         g_free (src_name);
 135
 136                         switch(new_state)
 137                         {
 138                                 case GST_STATE_VOID_PENDING:
 139                                 case GST_STATE_NULL:
 140                                 case GST_STATE_READY:
 141                                 case GST_STATE_PAUSED:
 142                                         break;
 143
 144                                 case GST_STATE_PLAYING:
 145                                         /* notify application that download is stated */
 146                                         __pd_downloader_post_message(player, MM_MESSAGE_PD_DOWNLOADER_START, NULL);
 147                                         break;
 148
 149                                 default:
 150                                         break;
 151                         }
 152                 }
 153                 break;
 154
 155                 case GST_MESSAGE_DURATION:
 156                 {
 157                         GstFormat fmt= GST_FORMAT_BYTES;
 158
 159                         gint64 size = 0LL;
 160
 161                         /* get total size  of download file, (bytes) */
 162                         if ( ! gst_element_query_duration( pd->downloader_pipeline, &fmt, &size ) )
 163                         {
 164                                 GError *err = NULL;
 165                                 GstMessage *new_msg = NULL;
 166
 167                                 err = g_error_new (GST_STREAM_ERROR, GST_STREAM_ERROR_FAILED, "can't get total size");
 168                                 new_msg = gst_message_new_error (GST_OBJECT_CAST (pd->playback_pipeline_src), err, NULL);
 169                                 gst_element_post_message (pd->playback_pipeline_src, new_msg);
 170
 171                                 g_error_free (err);
 172
 173                                 // TODO: check if playback pipeline is closed well or not
 174                                 g_object_set (G_OBJECT (pd->playback_pipeline_src), "eos", TRUE, NULL);
 175
 176                                 _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
 177
 178                                 debug_error("failed to query total size for download\n");
 179                                 break;
 180                         }
 181
 182                         pd->total_size = size;
 183
 184                         debug_log("PD total size : %lld bytes\n", size);
 185                 }
 186                 break;
 187
 188                 default:
 189                         debug_warning("unhandled message\n");
 190                         break;
 191         }
 192
 193         MMPLAYER_FLEAVE();
 194
 195         return bret;
 196 }
 197
 198
 199 gboolean __pd_downloader_post_message(mm_player_t * player, enum MMMessageType msgtype, MMMessageParamType* param)
 200 {
 201         MMPLAYER_FENTER();
 202
 203         return_val_if_fail( player, FALSE );
 204
 205         if ( !player->pd_msg_cb )
 206         {
 207                 debug_warning("no msg callback. can't post\n");
 208                 return FALSE;
 209         }
 210
 211         player->pd_msg_cb(msgtype, param, player->pd_msg_cb_param);
 212
 213         MMPLAYER_FLEAVE();
 214
 215         return TRUE;
 216 }
 217
 218
 219 gboolean _mmplayer_get_pd_downloader_status(MMHandleType handle, guint64 *current_pos, guint64 *total_size)
 220 {
 221         MMPLAYER_FENTER();
 222
 223         mm_player_pd_t * pd = NULL;
 224         guint64 bytes = 0;
 225
 226         return_val_if_fail(handle, MM_ERROR_INVALID_ARGUMENT);
 227
 228         pd = MM_PLAYER_GET_PD(handle);
 229
 230         return_val_if_fail(pd, MM_ERROR_INVALID_ARGUMENT);
 231         return_val_if_fail(pd->downloader_pipeline, MM_ERROR_PLAYER_INVALID_STATE);
 232
 233         if ( !pd->total_size )
 234         {
 235                 debug_warning("not ready to get total size\n");
 236                 return FALSE;
 237         }
 238
 239         g_object_get(pd->downloader_sink, "current-bytes", &bytes, NULL);
 240
 241         debug_log("PD status : %lld / %lld\n", bytes, pd->total_size);
 242
 243         *current_pos = bytes;
 244         *total_size = pd->total_size;
 245
 246         MMPLAYER_FLEAVE();
 247
 248         return TRUE;
 249 }
 250
 251
 252 mm_player_pd_t * _mmplayer_create_pd_downloader()
 253 {
 254         MMPLAYER_FENTER();
 255
 256         mm_player_pd_t * pd = NULL;
 257
 258         /* create PD handle */
 259         pd = (mm_player_pd_t *) malloc (sizeof (mm_player_pd_t));
 260         if ( !pd )
 261         {
 262                 debug_error ("Failed to create pd downloader handle...\n");
 263                 return FALSE;
 264         }
 265         memset( pd, 0, sizeof (mm_player_pd_t));
 266
 267         MMPLAYER_FLEAVE();
 268
 269         return pd;
 270 }
 271
 272
 273 gboolean _mmplayer_destroy_pd_downloader (MMHandleType handle)
 274 {
 275         MMPLAYER_FENTER();
 276
 277         mm_player_pd_t * pd = NULL;
 278
 279         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 280
 281         pd = MM_PLAYER_GET_PD(handle);
 282
 283         if (pd && pd->downloader_pipeline)
 284                 _mmplayer_unrealize_pd_downloader (handle);
 285
 286         /* release PD handle */
 287         MMPLAYER_FREEIF(pd);
 288
 289         MMPLAYER_FLEAVE();
 290
 291         return TRUE;
 292 }
 293
 294
 295 gboolean _mmplayer_realize_pd_downloader (MMHandleType handle, gchar *src_uri, gchar *dst_uri, GstElement *pushsrc)
 296 {
 297         MMPLAYER_FENTER();
 298
 299         mm_player_pd_t * pd = NULL;
 300
 301         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 302         return_val_if_fail ( src_uri, MM_ERROR_INVALID_ARGUMENT );
 303         return_val_if_fail ( dst_uri, MM_ERROR_INVALID_ARGUMENT );
 304         return_val_if_fail ( pushsrc, MM_ERROR_INVALID_ARGUMENT );
 305
 306         pd = MM_PLAYER_GET_PD(handle);
 307
 308         /* initialize */
 309         pd->path_read_from = g_strdup (src_uri);
 310         pd->location_to_save = g_strdup (dst_uri);
 311         pd->playback_pipeline_src = pushsrc;
 312         pd->total_size = 0LL;
 313
 314         MMPLAYER_FLEAVE();
 315
 316         return TRUE;
 317 }
 318
 319
 320 gboolean _mmplayer_start_pd_downloader (MMHandleType handle)
 321 {
 322         GstBus* bus = NULL;
 323         gboolean bret = FALSE;
 324         GstStateChangeReturn sret = GST_STATE_CHANGE_SUCCESS;
 325         GstState cur_state;
 326         GstState pending_state;
 327
 328         MMPLAYER_FENTER();
 329
 330         mm_player_pd_t * pd = NULL;
 331
 332         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 333
 334         pd = MM_PLAYER_GET_PD(handle);
 335
 336         /* pipeline */
 337         pd->downloader_pipeline = gst_pipeline_new ("PD Downloader");
 338         if (NULL == pd->downloader_pipeline)
 339         {
 340                 debug_error ("Can't create PD download pipeline...");
 341                 return FALSE;
 342         }
 343
 344         /* source */
 345         pd->downloader_src = gst_element_factory_make ("souphttpsrc", "PD HTTP download source");
 346         if (NULL == pd->downloader_src)
 347         {
 348                 debug_error ("Can't create PD download src...");
 349                 return FALSE;
 350         }
 351
 352         /* queue */
 353         pd->downloader_queue = gst_element_factory_make ("queue", "PD download queue");
 354         if (NULL == pd->downloader_queue)
 355         {
 356                 debug_error ("Can't create PD download queue...");
 357                 return FALSE;
 358         }
 359
 360         /* filesink */
 361         pd->downloader_sink = gst_element_factory_make ("filesink", "PD download sink");
 362         if (NULL == pd->downloader_sink)
 363         {
 364                 debug_error ("Can't create PD download sink...");
 365                 return FALSE;
 366         }
 367
 368         g_object_set(pd->downloader_sink, "sync", FALSE, NULL);
 369
 370         /* Add to bin and link */
 371         gst_bin_add_many (GST_BIN (pd->downloader_pipeline),
 372                                         pd->downloader_src, pd->downloader_queue, pd->downloader_sink,
 373                                         NULL);
 374
 375         bret = gst_element_link_many (pd->downloader_src, pd->downloader_queue, pd->downloader_sink, NULL);
 376         if (FALSE == bret)
 377         {
 378                 debug_error ("Can't link elements src and sink...");
 379                 return FALSE;
 380         }
 381
 382         /* Get Bus and set callback to watch */
 383         bus = gst_pipeline_get_bus (GST_PIPELINE (pd->downloader_pipeline));
 384         gst_bus_add_watch (bus, __pd_downloader_callback, (gpointer)handle);
 385         gst_object_unref (bus);
 386
 387         /* Set URI on HTTP source */
 388         g_object_set (G_OBJECT (pd->downloader_src), "location", pd->path_read_from, NULL);
 389
 390         /* set file download location on filesink*/
 391         g_object_set (G_OBJECT (pd->downloader_sink), "location", pd->location_to_save, NULL);
 392
 393         secure_debug_log ("src location = %s, save location = %s\n", pd->path_read_from, pd->location_to_save);
 394
 395         /* Start to download */
 396         sret = gst_element_set_state (pd->downloader_pipeline, GST_STATE_PLAYING);
 397         if (GST_STATE_CHANGE_FAILURE == sret)
 398         {
 399                 debug_error ("PD download pipeline failed to go to PLAYING state...");
 400                 return FALSE;
 401         }
 402
 403         debug_log ("set_state :: sret = %d\n", sret);
 404
 405         sret = gst_element_get_state (pd->downloader_pipeline, &cur_state, &pending_state, GST_CLOCK_TIME_NONE);
 406         if (GST_STATE_CHANGE_FAILURE == sret)
 407         {
 408                 debug_error ("PD download pipeline failed to do get_state...");
 409                 return FALSE;
 410         }
 411
 412         debug_log ("get-state :: sret = %d\n", sret);
 413
 414         MMPLAYER_FLEAVE();
 415
 416         return TRUE;
 417 }
 418
 419
 420 gboolean _mmplayer_unrealize_pd_downloader (MMHandleType handle)
 421 {
 422         MMPLAYER_FENTER();
 423
 424         mm_player_pd_t * pd = NULL;
 425
 426         return_val_if_fail ( handle, FALSE );
 427
 428         pd = MM_PLAYER_GET_PD(handle);
 429
 430         return_val_if_fail ( pd && pd->downloader_pipeline, FALSE );
 431
 432         gst_element_set_state (pd->downloader_pipeline, GST_STATE_NULL);
 433         gst_element_get_state (pd->downloader_pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 434
 435         gst_object_unref (G_OBJECT (pd->downloader_pipeline));
 436         pd->downloader_pipeline = NULL;
 437
 438         /* free */
 439         MMPLAYER_FREEIF(pd->path_read_from);
 440         MMPLAYER_FREEIF(pd->location_to_save);
 441
 442         MMPLAYER_FLEAVE();
 443
 444         return TRUE;
 445 }
 446
 447
 448 gint _mm_player_set_pd_downloader_message_cb(MMHandleType handle, MMMessageCallback callback, gpointer user_param)
 449 {
 450         MMPLAYER_FENTER();
 451
 452         mm_player_t * player = NULL;
 453
 454         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 455
 456         player = MM_PLAYER_CAST((MMHandleType)handle);
 457
 458         /* PD callback can be set as soon as player handle is created.
 459           * So, player handle must have it.
 460           */
 461         player->pd_msg_cb = callback;
 462         player->pd_msg_cb_param = user_param;
 463
 464         debug_log("msg_cb : 0x%x     msg_cb_param : 0x%x\n", (guint)callback, (guint)user_param);
 465
 466         MMPLAYER_FLEAVE();
 467
 468         return MM_ERROR_NONE;
 469 }