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         debug_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                                 gboolean ret = FALSE;
  83                                 GError *error = NULL;
  84                                 gchar* debug = NULL;
  85                                 GstMessage *new_msg = NULL;
  86
  87                                 /* get error code */
  88                                 gst_message_parse_error( msg, &error, &debug );
  89                                 debug_error ("GST_MESSAGE_ERROR = %s\n", debug);
  90
  91                                 new_msg = gst_message_new_error (GST_OBJECT_CAST (pd->playback_pipeline_src), error, debug);
  92
  93                                 /* notify application that pd has any error */
  94                                 ret = gst_element_post_message (pd->playback_pipeline_src, new_msg);
  95
  96                                 _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
  97                         }
  98                         break;
  99
 100                 case GST_MESSAGE_WARNING:
 101                         {
 102                                 char* debug = NULL;
 103                                 GError* error = NULL;
 104
 105                                 gst_message_parse_warning(msg, &error, &debug);
 106                                 debug_warning("warning : %s\n", error->message);
 107                                 debug_warning("debug : %s\n", debug);
 108
 109                                 MMPLAYER_FREEIF(debug);
 110                                 g_error_free( error);
 111                         }
 112                         break;
 113
 114                 case GST_MESSAGE_STATE_CHANGED:
 115                 {
 116                         GstState old_state, new_state;
 117                         gchar *src_name;
 118
 119                         /* get old and new state */
 120                         gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
 121
 122                         if (old_state == new_state)
 123                                 break;
 124
 125                         /* we only care about pipeline state changes */
 126                         if (GST_MESSAGE_SRC (msg) != GST_OBJECT (pd->downloader_pipeline))
 127                                 break;
 128
 129                         src_name = gst_object_get_name (msg->src);
 130                         debug_log ("%s changed state from %s to %s", src_name,
 131                                 gst_element_state_get_name (old_state),
 132                                 gst_element_state_get_name (new_state));
 133                         g_free (src_name);
 134
 135                         switch(new_state)
 136                         {
 137                                 case GST_STATE_VOID_PENDING:
 138                                 case GST_STATE_NULL:
 139                                 case GST_STATE_READY:
 140                                 case GST_STATE_PAUSED:
 141                                         break;
 142
 143                                 case GST_STATE_PLAYING:
 144                                         /* notify application that download is stated */
 145                                         __pd_downloader_post_message(player, MM_MESSAGE_PD_DOWNLOADER_START, NULL);
 146                                         break;
 147
 148                                 default:
 149                                         break;
 150                         }
 151                 }
 152                 break;
 153
 154                 case GST_MESSAGE_DURATION:
 155                 {
 156                         GstFormat fmt= GST_FORMAT_BYTES;
 157
 158                         gint64 size = 0LL;
 159
 160                         /* get total size  of download file, (bytes) */
 161                         if ( ! gst_element_query_duration( pd->downloader_pipeline, &fmt, &size ) )
 162                         {
 163                                 GError *err = NULL;
 164                                 GstMessage *new_msg = NULL;
 165
 166                                 err = g_error_new (GST_STREAM_ERROR, GST_STREAM_ERROR_FAILED, "can't get total size");
 167                                 new_msg = gst_message_new_error (GST_OBJECT_CAST (pd->playback_pipeline_src), err, NULL);
 168                                 gst_element_post_message (pd->playback_pipeline_src, new_msg);
 169
 170                                 g_error_free (err);
 171
 172                                 // TODO: check if playback pipeline is closed well or not
 173                                 g_object_set (G_OBJECT (pd->playback_pipeline_src), "eos", TRUE, NULL);
 174
 175                                 _mmplayer_unrealize_pd_downloader ((MMHandleType)data);
 176
 177                                 debug_error("failed to query total size for download\n");
 178                                 break;
 179                         }
 180
 181                         pd->total_size = size;
 182
 183                         debug_log("PD total size : %lld bytes\n", size);
 184                 }
 185                 break;
 186
 187                 default:
 188                         debug_warning("unhandled message\n");
 189                         break;
 190         }
 191
 192         debug_fleave();
 193
 194         return bret;
 195 }
 196
 197
 198 gboolean __pd_downloader_post_message(mm_player_t * player, enum MMMessageType msgtype, MMMessageParamType* param)
 199 {
 200         debug_fenter();
 201
 202         return_val_if_fail( player, FALSE );
 203
 204         if ( !player->pd_msg_cb )
 205         {
 206                 debug_warning("no msg callback. can't post\n");
 207                 return FALSE;
 208         }
 209
 210         player->pd_msg_cb(msgtype, param, player->pd_msg_cb_param);
 211
 212         debug_fleave();
 213
 214         return TRUE;
 215 }
 216
 217
 218 gboolean _mmplayer_get_pd_downloader_status(MMHandleType handle, guint64 *current_pos, guint64 *total_size)
 219 {
 220         debug_fenter();
 221
 222         mm_player_pd_t * pd = NULL;
 223         guint64 bytes = 0;
 224
 225         return_val_if_fail(handle, MM_ERROR_INVALID_ARGUMENT);
 226
 227         pd = MM_PLAYER_GET_PD(handle);
 228
 229         return_val_if_fail(pd, MM_ERROR_INVALID_ARGUMENT);
 230         return_val_if_fail(pd->downloader_pipeline, MM_ERROR_INVALID_ARGUMENT);
 231
 232         if ( !pd->total_size )
 233         {
 234                 debug_warning("not ready to get total size\n");
 235                 return FALSE;
 236         }
 237
 238         g_object_get(pd->downloader_sink, "current-bytes", &bytes, NULL);
 239
 240         debug_log("PD status : %lld / %lld\n", bytes, pd->total_size);
 241
 242         *current_pos = bytes;
 243         *total_size = pd->total_size;
 244
 245         debug_fleave();
 246
 247         return TRUE;
 248 }
 249
 250
 251 mm_player_pd_t * _mmplayer_create_pd_downloader()
 252 {
 253         debug_fenter();
 254
 255         mm_player_pd_t * pd = NULL;
 256
 257         /* create PD handle */
 258         pd = (mm_player_pd_t *) malloc (sizeof (mm_player_pd_t));
 259         if ( !pd )
 260         {
 261                 debug_error ("Failed to create pd downloader handle...\n");
 262                 return FALSE;
 263         }
 264
 265         debug_fleave();
 266
 267         return pd;
 268 }
 269
 270
 271 gboolean _mmplayer_destroy_pd_downloader (MMHandleType handle)
 272 {
 273         debug_fenter();
 274
 275         mm_player_pd_t * pd = NULL;
 276
 277         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 278
 279         pd = MM_PLAYER_GET_PD(handle);
 280
 281         if (pd && pd->downloader_pipeline)
 282                 _mmplayer_unrealize_pd_downloader (handle);
 283
 284         /* release PD handle */
 285         MMPLAYER_FREEIF(pd);
 286
 287         debug_fleave();
 288
 289         return TRUE;
 290 }
 291
 292
 293 gboolean _mmplayer_realize_pd_downloader (MMHandleType handle, gchar *src_uri, gchar *dst_uri, GstElement *pushsrc)
 294 {
 295         debug_fenter();
 296
 297         mm_player_pd_t * pd = NULL;
 298
 299         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 300         return_val_if_fail ( src_uri, MM_ERROR_INVALID_ARGUMENT );
 301         return_val_if_fail ( dst_uri, MM_ERROR_INVALID_ARGUMENT );
 302         return_val_if_fail ( pushsrc, MM_ERROR_INVALID_ARGUMENT );
 303
 304         pd = MM_PLAYER_GET_PD(handle);
 305
 306         /* initialize */
 307         pd->path_read_from = g_strdup (src_uri);
 308         pd->location_to_save = g_strdup (dst_uri);
 309         pd->playback_pipeline_src = pushsrc;
 310         pd->total_size = 0LL;
 311
 312         debug_fleave();
 313
 314         return TRUE;
 315 }
 316
 317
 318 gboolean _mmplayer_start_pd_downloader (MMHandleType handle)
 319 {
 320         GstBus* bus = NULL;
 321         gboolean bret = FALSE;
 322         GstStateChangeReturn sret = GST_STATE_CHANGE_SUCCESS;
 323         GstState cur_state;
 324         GstState pending_state;
 325
 326         debug_fenter();
 327
 328         mm_player_pd_t * pd = NULL;
 329
 330         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 331
 332         pd = MM_PLAYER_GET_PD(handle);
 333
 334         /* pipeline */
 335         pd->downloader_pipeline = gst_pipeline_new ("PD Downloader");
 336         if (NULL == pd->downloader_pipeline)
 337         {
 338                 debug_error ("Can't create PD download pipeline...");
 339                 return FALSE;
 340         }
 341
 342         /* source */
 343         pd->downloader_src = gst_element_factory_make ("souphttpsrc", "PD HTTP download source");
 344         if (NULL == pd->downloader_src)
 345         {
 346                 debug_error ("Can't create PD download src...");
 347                 return FALSE;
 348         }
 349
 350         /* queue */
 351         pd->downloader_queue = gst_element_factory_make ("queue", "PD download queue");
 352         if (NULL == pd->downloader_queue)
 353         {
 354                 debug_error ("Can't create PD download queue...");
 355                 return FALSE;
 356         }
 357
 358         /* filesink */
 359         pd->downloader_sink = gst_element_factory_make ("filesink", "PD download sink");
 360         if (NULL == pd->downloader_sink)
 361         {
 362                 debug_error ("Can't create PD download sink...");
 363                 return FALSE;
 364         }
 365
 366         g_object_set(pd->downloader_sink, "sync", FALSE, NULL);
 367
 368         /* Add to bin and link */
 369         gst_bin_add_many (GST_BIN (pd->downloader_pipeline),
 370                                         pd->downloader_src, pd->downloader_queue, pd->downloader_sink,
 371                                         NULL);
 372
 373         bret = gst_element_link_many (pd->downloader_src, pd->downloader_queue, pd->downloader_sink, NULL);
 374         if (FALSE == bret)
 375         {
 376                 debug_error ("Can't link elements src and sink...");
 377                 return FALSE;
 378         }
 379
 380         /* Get Bus and set callback to watch */
 381         bus = gst_pipeline_get_bus (GST_PIPELINE (pd->downloader_pipeline));
 382         gst_bus_add_watch (bus, __pd_downloader_callback, (gpointer)handle);
 383         gst_object_unref (bus);
 384
 385         /* Set URI on HTTP source */
 386         g_object_set (G_OBJECT (pd->downloader_src), "location", pd->path_read_from, NULL);
 387
 388         /* set file download location on filesink*/
 389         g_object_set (G_OBJECT (pd->downloader_sink), "location", pd->location_to_save, NULL);
 390
 391         debug_log ("src location = %s, save location = %s\n", pd->path_read_from, pd->location_to_save);
 392
 393         /* Start to download */
 394         sret = gst_element_set_state (pd->downloader_pipeline, GST_STATE_PLAYING);
 395         if (GST_STATE_CHANGE_FAILURE == sret)
 396         {
 397                 debug_error ("PD download pipeline failed to go to PLAYING state...");
 398                 return FALSE;
 399         }
 400
 401         debug_log ("set_state :: sret = %d\n", sret);
 402
 403         sret = gst_element_get_state (pd->downloader_pipeline, &cur_state, &pending_state, GST_CLOCK_TIME_NONE);
 404         if (GST_STATE_CHANGE_FAILURE == sret)
 405         {
 406                 debug_error ("PD download pipeline failed to do get_state...");
 407                 return FALSE;
 408         }
 409
 410         debug_log ("get-state :: sret = %d\n", sret);
 411
 412         debug_fleave();
 413
 414         return TRUE;
 415 }
 416
 417
 418 gboolean _mmplayer_unrealize_pd_downloader (MMHandleType handle)
 419 {
 420         debug_fenter();
 421
 422         mm_player_pd_t * pd = NULL;
 423
 424         return_val_if_fail ( handle, FALSE );
 425
 426         pd = MM_PLAYER_GET_PD(handle);
 427
 428         return_val_if_fail ( pd && pd->downloader_pipeline, FALSE );
 429
 430         gst_element_set_state (pd->downloader_pipeline, GST_STATE_NULL);
 431         gst_element_get_state (pd->downloader_pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 432
 433         gst_object_unref (G_OBJECT (pd->downloader_pipeline));
 434         pd->downloader_pipeline = NULL;
 435
 436         /* free */
 437         MMPLAYER_FREEIF(pd->path_read_from);
 438         MMPLAYER_FREEIF(pd->location_to_save);
 439
 440         debug_fleave();
 441
 442         return TRUE;
 443 }
 444
 445
 446 gint _mm_player_set_pd_downloader_message_cb(MMHandleType handle, MMMessageCallback callback, gpointer user_param)
 447 {
 448         debug_fenter();
 449
 450         mm_player_t * player = NULL;
 451
 452         return_val_if_fail ( handle, MM_ERROR_INVALID_ARGUMENT );
 453
 454         player = MM_PLAYER_CAST((MMHandleType)handle);
 455
 456         /* PD callback can be set as soon as player handle is created.
 457           * So, player handle must have it.
 458           */
 459         player->pd_msg_cb = callback;
 460         player->pd_msg_cb_param = user_param;
 461
 462         debug_log("msg_cb : 0x%x     msg_cb_param : 0x%x\n", (guint)callback, (guint)user_param);
 463
 464         debug_fleave();
 465
 466         return MM_ERROR_NONE;
 467 }