src/mm_player_es.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>, heechul jeon <heechul.jeon@samsung.co>,
   7  * YoungHwan An <younghwan_.an@samsung.com>, Eunhae Choi <eunhae1.choi@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
  23 /*===========================================================================================
  24 |                                                                                                                                                                                       |
  25 |  INCLUDE FILES                                                                                                                                                        |
  26 |                                                                                                                                                                                       |
  27 ========================================================================================== */
  28 #include <dlog.h>
  29 #include "mm_player_es.h"
  30 #include "mm_player_utils.h"
  31 #include "mm_player_internal.h"
  32
  33 #include <gst/app/gstappsrc.h>
  34
  35 /*---------------------------------------------------------------------------
  36 |    LOCAL VARIABLE DEFINITIONS for internal                                |
  37 ---------------------------------------------------------------------------*/
  38 #define DEFAULT_FRAMERATE_NUM 30
  39 #define DEFAULT_FRAMERATE_DEN 1
  40 #define DEFAULT_VIDEO_FRAME_DURATION 33 /* ms */
  41 #define PLAYER_DATA_PUSH_WAIT_COUNT 10
  42 #define PLAYER_STATE_CHECK_INTERVAL (100*1000)
  43
  44 /*---------------------------------------------------------------------------
  45 |    LOCAL FUNCTION PROTOTYPES:                                             |
  46 ---------------------------------------------------------------------------*/
  47 static int __parse_media_format(MMPlayerVideoStreamInfo * video, MMPlayerAudioStreamInfo * audio, media_format_h format);
  48 static int __convert_media_format_video_mime_to_str(MMPlayerVideoStreamInfo * video, media_format_mimetype_e mime);
  49 static int __convert_media_format_audio_mime_to_str(MMPlayerAudioStreamInfo * audio, media_format_mimetype_e mime);
  50
  51 /*===========================================================================================
  52 |                                                                                                                                                                                       |
  53 |  FUNCTION DEFINITIONS                                                                                                                                         |
  54 |                                                                                                                                                                                       |
  55 ========================================================================================== */
  56
  57 static int
  58 __convert_media_format_video_mime_to_str(MMPlayerVideoStreamInfo * video,
  59         media_format_mimetype_e mime)
  60 {
  61         MMPLAYER_RETURN_VAL_IF_FAIL(video, MM_ERROR_INVALID_ARGUMENT);
  62
  63         switch (mime) {
  64         case MEDIA_FORMAT_MPEG4_SP:
  65                 video->mime = g_strdup("video/mpeg");
  66                 video->version = 4;
  67                 break;
  68         case MEDIA_FORMAT_H264_SP:
  69         case MEDIA_FORMAT_H264_MP:
  70         case MEDIA_FORMAT_H264_HP:
  71                 video->mime = g_strdup("video/x-h264");
  72                 break;
  73         default:
  74                 video->mime = g_strdup("unknown");
  75                 break;
  76         }
  77
  78         return MM_ERROR_NONE;
  79 }
  80
  81 static int
  82 __convert_media_format_audio_mime_to_str(MMPlayerAudioStreamInfo * audio,
  83         media_format_mimetype_e mime)
  84 {
  85         MMPLAYER_RETURN_VAL_IF_FAIL(audio, MM_ERROR_INVALID_ARGUMENT);
  86
  87         switch (mime) {
  88         case MEDIA_FORMAT_AAC:
  89                 audio->mime = g_strdup("audio/mpeg");
  90                 audio->version = 2;
  91                 break;
  92         default:
  93                 audio->mime = g_strdup("unknown");
  94                 break;
  95         }
  96
  97         return MM_ERROR_NONE;
  98 }
  99
 100 static int
 101 __parse_media_format(MMPlayerVideoStreamInfo * video,
 102         MMPlayerAudioStreamInfo * audio, media_format_h format)
 103 {
 104         if (audio) {
 105                 media_format_mimetype_e mime;
 106                 int channel;
 107                 int samplerate;
 108                 int avg_bps;
 109
 110                 if (media_format_get_audio_info(format, &mime, &channel, &samplerate, NULL,
 111                         &avg_bps) != MEDIA_FORMAT_ERROR_NONE) {
 112                         LOGE("media_format_get_audio_info failed");
 113                         return MM_ERROR_PLAYER_INTERNAL;
 114                 }
 115
 116                 __convert_media_format_audio_mime_to_str(audio, mime);
 117                 audio->sample_rate = samplerate;
 118                 audio->channels = channel;
 119                 //video->user_info = ;
 120         }
 121
 122         if (video) {
 123                 media_format_mimetype_e mime;
 124                 int width = 0;
 125                 int height = 0;
 126                 int avg_bps = 0;
 127                 int frame_rate = 0;
 128
 129                 if (media_format_get_video_info(format, &mime, &width, &height, &avg_bps,
 130                         NULL) != MEDIA_FORMAT_ERROR_NONE) {
 131                         LOGE("media_format_get_video_info failed");
 132                         return MM_ERROR_PLAYER_INTERNAL;
 133                 }
 134
 135                 if (media_format_get_video_frame_rate(format, &frame_rate))
 136                         LOGW("failed to get video frame rate, will be set 30.");
 137
 138                 LOGD("frame_rate %d", frame_rate);
 139
 140                 __convert_media_format_video_mime_to_str(video, mime);
 141
 142                 video->width = width;
 143                 video->height = height;
 144                 video->framerate_num = (frame_rate > 0) ? (frame_rate) : (DEFAULT_FRAMERATE_NUM);
 145                 video->framerate_den = DEFAULT_FRAMERATE_DEN;
 146         }
 147
 148         return MM_ERROR_NONE;
 149 }
 150
 151 static gboolean
 152 __mmplayer_update_video_info(MMHandleType hplayer, media_format_h fmt)
 153 {
 154         mm_player_t *player = (mm_player_t *) hplayer;
 155         gboolean ret = FALSE;
 156         GstStructure *str = NULL;
 157         media_format_mimetype_e mimetype = 0;
 158         gint cur_width = 0, width = 0;
 159         gint cur_height = 0, height = 0;
 160
 161         MMPLAYER_FENTER();
 162
 163         MMPLAYER_RETURN_VAL_IF_FAIL(player && player->v_stream_caps, FALSE);
 164         MMPLAYER_RETURN_VAL_IF_FAIL(fmt, FALSE);
 165
 166         if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PAUSED &&
 167                 MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PLAYING) {
 168                 LOGW("skip update video info, state: %s", MMPLAYER_STATE_GET_NAME(MMPLAYER_CURRENT_STATE(player)));
 169                 return FALSE;
 170         }
 171
 172         str = gst_caps_get_structure(player->v_stream_caps, 0);
 173         if (!str) {
 174                 LOGE("failed to get caps info");
 175                 return FALSE;
 176         }
 177
 178         if (!gst_structure_get_int(str, "width", &cur_width))
 179                 LOGD("missing 'width' field in video caps");
 180
 181         if (!gst_structure_get_int(str, "height", &cur_height))
 182                 LOGD("missing 'height' field in video caps");
 183
 184         media_format_get_video_info(fmt, &mimetype, &width, &height, NULL, NULL);
 185         if ((cur_width != width) || (cur_height != height)) {
 186                 LOGW("resolution is changed %dx%d -> %dx%d",
 187                         cur_width, cur_height, width, height);
 188                 _mmplayer_set_video_info(hplayer, fmt);
 189                 ret = TRUE;
 190         }
 191
 192         MMPLAYER_FLEAVE();
 193         return ret;
 194 }
 195
 196
 197 int
 198 _mmplayer_set_media_stream_buffer_status_cb(MMHandleType hplayer,
 199                                                                                         MMPlayerStreamType type,
 200                                                                                         mm_player_media_stream_buffer_status_callback callback,
 201                                                                                         void *user_param)
 202 {
 203         mm_player_t *player = (mm_player_t *) hplayer;
 204
 205         MMPLAYER_FENTER();
 206
 207         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 208
 209         MMPLAYER_MEDIA_STREAM_CALLBACK_LOCK(player);
 210
 211         if (player->media_stream_buffer_status_cb[type]) {
 212                 if (!callback)
 213                         LOGD("[type:%s] will be clear", MMPLAYER_STREAM_TYPE_GET_NAME(type));
 214                 else
 215                         LOGD("[type:%s] will be overwritten", MMPLAYER_STREAM_TYPE_GET_NAME(type));
 216         }
 217
 218         player->media_stream_buffer_status_cb[type] = callback;
 219         player->buffer_cb_user_param[type] = user_param;
 220
 221         LOGD("player handle %p, type %s, callback %p",
 222                         player, MMPLAYER_STREAM_TYPE_GET_NAME(type), player->media_stream_buffer_status_cb[type]);
 223         MMPLAYER_MEDIA_STREAM_CALLBACK_UNLOCK(player);
 224
 225         MMPLAYER_FLEAVE();
 226
 227         return MM_ERROR_NONE;
 228 }
 229
 230 int
 231 _mmplayer_set_media_stream_seek_data_cb(MMHandleType hplayer,
 232                                                                                 MMPlayerStreamType type,
 233                                                                                 mm_player_media_stream_seek_data_callback callback,
 234                                                                                 void *user_param)
 235 {
 236         mm_player_t *player = (mm_player_t *) hplayer;
 237
 238         MMPLAYER_FENTER();
 239
 240         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 241
 242         MMPLAYER_MEDIA_STREAM_CALLBACK_LOCK(player);
 243
 244         if (player->media_stream_seek_data_cb[type]) {
 245                 if (!callback)
 246                         LOGD("[type:%s] will be clear", MMPLAYER_STREAM_TYPE_GET_NAME(type));
 247                 else
 248                         LOGD("[type:%s] will be overwritten", MMPLAYER_STREAM_TYPE_GET_NAME(type));
 249         }
 250
 251         player->media_stream_seek_data_cb[type] = callback;
 252         player->seek_cb_user_param[type] = user_param;
 253
 254         LOGD("player handle %p, type %s, callback %p",
 255                         player, MMPLAYER_STREAM_TYPE_GET_NAME(type), player->media_stream_seek_data_cb[type]);
 256         MMPLAYER_MEDIA_STREAM_CALLBACK_UNLOCK(player);
 257
 258         MMPLAYER_FLEAVE();
 259
 260         return MM_ERROR_NONE;
 261 }
 262
 263 static GstElement*
 264 __mmplayer_get_source_element(mm_player_t *player, MMPlayerStreamType type)
 265 {
 266         enum MainElementID elemId = MMPLAYER_M_NUM;
 267
 268         if (player && player->pipeline && player->pipeline->mainbin) {
 269                 /* get elem according to the stream type */
 270                 if (type == MM_PLAYER_STREAM_TYPE_AUDIO) {
 271                         if (player->pipeline->mainbin[MMPLAYER_M_2ND_SRC].gst)
 272                                 elemId = MMPLAYER_M_2ND_SRC;
 273                         else if (g_strrstr(GST_ELEMENT_NAME(player->pipeline->mainbin[MMPLAYER_M_SRC].gst), "audio_appsrc"))
 274                                 elemId = MMPLAYER_M_SRC;
 275                 } else if (type == MM_PLAYER_STREAM_TYPE_VIDEO) {
 276                         elemId = MMPLAYER_M_SRC;
 277                 } else if (type == MM_PLAYER_STREAM_TYPE_TEXT) {
 278                         elemId = MMPLAYER_M_SUBSRC;
 279                 }
 280
 281                 if (elemId != MMPLAYER_M_NUM)
 282                         return player->pipeline->mainbin[elemId].gst;
 283         }
 284
 285         return NULL;
 286 }
 287
 288 int
 289 _mmplayer_set_media_stream_max_size(MMHandleType hplayer, MMPlayerStreamType type, guint64 max_size)
 290 {
 291         mm_player_t *player = (mm_player_t *) hplayer;
 292         GstElement *element = NULL;
 293
 294         MMPLAYER_FENTER();
 295         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 296
 297         if ((type < MM_PLAYER_STREAM_TYPE_AUDIO) ||
 298                 (type > MM_PLAYER_STREAM_TYPE_TEXT) ||
 299                 (max_size == 0)) {
 300                 LOGE("Invalid param type:%d, max_size:%"G_GUINT64_FORMAT, type, max_size);
 301                 return MM_ERROR_INVALID_ARGUMENT;
 302         }
 303
 304         LOGD("type:%s, max_size %"G_GUINT64_FORMAT, MMPLAYER_STREAM_TYPE_GET_NAME(type), max_size);
 305
 306         if ((element = __mmplayer_get_source_element(player, type))) {
 307                 LOGD("update max_size of %s", GST_ELEMENT_NAME(element));
 308                 g_object_set(G_OBJECT(element), "max-bytes", max_size, NULL);
 309         }
 310
 311         player->media_stream_buffer_max_size[type] = max_size;
 312
 313         MMPLAYER_FLEAVE();
 314         return MM_ERROR_NONE;
 315 }
 316
 317 int
 318 _mmplayer_get_media_stream_max_size(MMHandleType hplayer, MMPlayerStreamType type, guint64 *max_size)
 319 {
 320         mm_player_t *player = (mm_player_t *) hplayer;
 321
 322         MMPLAYER_FENTER();
 323
 324         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 325         MMPLAYER_RETURN_VAL_IF_FAIL(max_size, MM_ERROR_INVALID_ARGUMENT);
 326
 327         *max_size = player->media_stream_buffer_max_size[type];
 328
 329         MMPLAYER_FLEAVE();
 330
 331         return MM_ERROR_NONE;
 332 }
 333
 334 int
 335 _mmplayer_set_media_stream_min_percent(MMHandleType hplayer, MMPlayerStreamType type, guint min_percent)
 336 {
 337         mm_player_t *player = (mm_player_t *) hplayer;
 338         GstElement *element = NULL;
 339
 340         MMPLAYER_FENTER();
 341
 342         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 343
 344         if ((type < MM_PLAYER_STREAM_TYPE_AUDIO) || (type > MM_PLAYER_STREAM_TYPE_TEXT)) {
 345                 LOGE("Invalid param type:%d", type);
 346                 return MM_ERROR_INVALID_ARGUMENT;
 347         }
 348
 349         LOGD("type:%s, min_per %u", MMPLAYER_STREAM_TYPE_GET_NAME(type), min_percent);
 350
 351         if ((element = __mmplayer_get_source_element(player, type))) {
 352                 LOGD("update min_per of %s", GST_ELEMENT_NAME(element));
 353                 g_object_set(G_OBJECT(element), "min-percent", min_percent, NULL);
 354         }
 355
 356         player->media_stream_buffer_min_percent[type] = min_percent;
 357
 358         MMPLAYER_FLEAVE();
 359         return MM_ERROR_NONE;
 360 }
 361
 362 int
 363 _mmplayer_get_media_stream_min_percent(MMHandleType hplayer, MMPlayerStreamType type, guint *min_percent)
 364 {
 365         mm_player_t *player = (mm_player_t *) hplayer;
 366
 367         MMPLAYER_FENTER();
 368
 369         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 370         MMPLAYER_RETURN_VAL_IF_FAIL(min_percent, MM_ERROR_INVALID_ARGUMENT);
 371
 372         *min_percent = player->media_stream_buffer_min_percent[type];
 373
 374         MMPLAYER_FLEAVE();
 375
 376         return MM_ERROR_NONE;
 377 }
 378
 379 static int
 380 __mmplayer_check_buffer_level(mm_player_t *player, GstElement* element, MMPlayerStreamType type)
 381 {
 382         guint64 current_level_bytes = 0;
 383         guint64 max_bytes = 0;
 384         guint current_level_per = 0;
 385
 386         MMPLAYER_FENTER();
 387         MMPLAYER_RETURN_VAL_IF_FAIL(player && element, MM_ERROR_PLAYER_NOT_INITIALIZED);
 388
 389         if (player->media_stream_buffer_max_size[type] > 0)
 390                 max_bytes = player->media_stream_buffer_max_size[type];
 391         else
 392                 g_object_get(G_OBJECT(element), "max-bytes", &max_bytes, NULL);
 393
 394         if (max_bytes == 0) {
 395                 LOGW("buffer max size is zero");
 396                 return MM_ERROR_NONE;
 397         }
 398
 399         g_object_get(G_OBJECT(element), "current-level-bytes", &current_level_bytes, NULL);
 400
 401         if (max_bytes <= current_level_bytes) {
 402                 LOGE("no available buffer space, type: %s, max %"G_GUINT64_FORMAT", curr %"G_GUINT64_FORMAT,
 403                                         MMPLAYER_STREAM_TYPE_GET_NAME(type), max_bytes, current_level_bytes);
 404                 return MM_ERROR_PLAYER_BUFFER_SPACE;
 405         }
 406
 407         if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PLAYING) {
 408                 MMPLAYER_MEDIA_STREAM_CALLBACK_LOCK(player);
 409                 if (!player->media_stream_buffer_status_cb[type]) {
 410                         MMPLAYER_MEDIA_STREAM_CALLBACK_UNLOCK(player);
 411                         return MM_ERROR_NONE;
 412                 }
 413
 414                 current_level_per = (guint)(gst_util_guint64_to_gdouble(current_level_bytes)/gst_util_guint64_to_gdouble(max_bytes)*100);
 415
 416                 LOGD("type: %s, min_per %u, curr_per %u max %"G_GUINT64_FORMAT" cur %"G_GUINT64_FORMAT,
 417                                         MMPLAYER_STREAM_TYPE_GET_NAME(type), player->media_stream_buffer_min_percent[type],
 418                                         current_level_per,
 419                                         player->media_stream_buffer_max_size[type],
 420                                         current_level_bytes);
 421
 422                 if (current_level_per < player->media_stream_buffer_min_percent[type])
 423                         player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, current_level_bytes, player->buffer_cb_user_param[type]);
 424
 425                 MMPLAYER_MEDIA_STREAM_CALLBACK_UNLOCK(player);
 426         }
 427
 428         MMPLAYER_FLEAVE();
 429         return MM_ERROR_NONE;
 430 }
 431
 432 int
 433 _mmplayer_submit_packet(MMHandleType hplayer, media_packet_h packet)
 434 {
 435         int ret = MM_ERROR_NONE;
 436         GstBuffer *_buffer = NULL;
 437         mm_player_t *player = (mm_player_t *) hplayer;
 438         guint8 *buf = NULL;
 439         uint64_t size = 0;
 440         GstElement* element = NULL;
 441         MMPlayerStreamType streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
 442         media_format_h fmt = NULL;
 443         bool flag = FALSE;
 444         bool is_eos = FALSE;
 445
 446         MMPLAYER_RETURN_VAL_IF_FAIL(packet, MM_ERROR_INVALID_ARGUMENT);
 447         MMPLAYER_RETURN_VAL_IF_FAIL(player &&
 448         player->pipeline &&
 449         player->pipeline->mainbin &&
 450         player->pipeline->mainbin[MMPLAYER_M_SRC].gst,
 451         MM_ERROR_PLAYER_NOT_INITIALIZED);
 452
 453         /* get stream type if audio or video */
 454         media_packet_is_audio(packet, &flag);
 455         if (flag) {
 456                 streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
 457         } else {
 458                 media_packet_is_video(packet, &flag);
 459                 if (flag)
 460                         streamtype = MM_PLAYER_STREAM_TYPE_VIDEO;
 461                 else
 462                         streamtype = MM_PLAYER_STREAM_TYPE_TEXT;
 463         }
 464
 465         element = __mmplayer_get_source_element(player, streamtype);
 466         if (!element) {
 467                 LOGE("there is no source element of type %d", streamtype);
 468                 ret = MM_ERROR_PLAYER_INTERNAL;
 469                 goto ERROR;
 470         }
 471
 472         /* check buffer level */
 473         ret = __mmplayer_check_buffer_level(player, element, streamtype);
 474         if (ret != MM_ERROR_NONE)
 475                 return ret;
 476
 477         /* get data */
 478         if (media_packet_get_buffer_data_ptr(packet, (void **) &buf) != MEDIA_PACKET_ERROR_NONE) {
 479                 LOGE("failed to get buffer data ptr");
 480                 ret = MM_ERROR_PLAYER_INTERNAL;
 481                 goto ERROR;
 482         }
 483
 484         if (media_packet_get_buffer_size(packet, &size) != MEDIA_PACKET_ERROR_NONE) {
 485                 LOGE("failed to get buffer size");
 486                 ret = MM_ERROR_PLAYER_INTERNAL;
 487                 goto ERROR;
 488         }
 489
 490         if (buf != NULL && size > 0) {
 491                 GstMapInfo buff_info = GST_MAP_INFO_INIT;
 492                 uint64_t pts = 0;
 493                 uint64_t duration = 0;
 494                 int wait_cnt = 0;
 495
 496                 /* get size */
 497                 _buffer = gst_buffer_new_and_alloc(size);
 498
 499                 if (!_buffer) {
 500                         LOGE("failed to allocate memory for push buffer\n");
 501                         ret = MM_ERROR_PLAYER_NO_FREE_SPACE;
 502                         goto ERROR;
 503                 }
 504
 505                 if (gst_buffer_map(_buffer, &buff_info, GST_MAP_READWRITE)) {
 506                         memcpy(buff_info.data, buf, size);
 507                         buff_info.size = size;
 508
 509                         gst_buffer_unmap(_buffer, &buff_info);
 510                 }
 511
 512                 /* wait till the pipeline is ready to get data, if not some data is missed */
 513                 while ((GST_STATE(element) < GST_STATE_PAUSED) && (wait_cnt < PLAYER_DATA_PUSH_WAIT_COUNT)) {
 514                         LOGW("wait to update source state : %d, %d", player->state, GST_STATE(element));
 515                         usleep(PLAYER_STATE_CHECK_INTERVAL);
 516                         wait_cnt++;
 517                 }
 518
 519                 if (wait_cnt == PLAYER_DATA_PUSH_WAIT_COUNT) {
 520                         LOGE("source is not ready %d", GST_STATE(element));
 521                         ret = MM_ERROR_PLAYER_INTERNAL;
 522                         goto ERROR;
 523                 }
 524
 525                 if (streamtype == MM_PLAYER_STREAM_TYPE_VIDEO) {
 526                         /* get format to check video format */
 527                         media_packet_get_format(packet, &fmt);
 528                         if (fmt) {
 529                                 if (__mmplayer_update_video_info(hplayer, fmt)) {
 530                                         LOGD("update video caps");
 531                                         g_object_set(G_OBJECT(player->pipeline->mainbin[MMPLAYER_M_SRC].gst),
 532                                                 "caps", player->v_stream_caps, NULL);
 533                                 }
 534                                 media_format_unref(fmt);
 535                         }
 536
 537                         /* get duration */
 538                         if (media_packet_get_duration(packet, &duration) != MEDIA_PACKET_ERROR_NONE) {
 539                                 LOGW("failed to get duration info");
 540                                 /* keep push without error handling */
 541                         }
 542
 543                         if (duration == 0)
 544                                 duration = DEFAULT_VIDEO_FRAME_DURATION * GST_MSECOND;
 545
 546                         GST_BUFFER_DURATION(_buffer) = (GstClockTime)duration;
 547                 }
 548
 549                 /* get pts */
 550                 if (media_packet_get_pts(packet, &pts) != MEDIA_PACKET_ERROR_NONE) {
 551                         LOGE("failed to get pts info");
 552                         ret = MM_ERROR_PLAYER_INTERNAL;
 553                         goto ERROR;
 554                 }
 555                 GST_BUFFER_PTS(_buffer) = (GstClockTime)pts;
 556
 557                 if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PLAYING) {
 558                         /* the pushed pts should be lager than current position if it is not in playing state. */
 559                         LOGD("type:%s, curr pos: %"G_GINT64_FORMAT", pushed pts:%"G_GINT64_FORMAT", size:%"G_GUINT64_FORMAT,
 560                                                 MMPLAYER_STREAM_TYPE_GET_NAME(streamtype), player->last_position, (GstClockTime)pts, (guint64)size);
 561                 }
 562
 563                 gst_app_src_push_buffer(GST_APP_SRC(element), _buffer);
 564         } else {
 565                 LOGW("There is no data to push : buf %p, size %"G_GUINT64_FORMAT, buf, (guint64)size);
 566         }
 567
 568         /* check eos */
 569         if (media_packet_is_end_of_stream(packet, &is_eos) != MEDIA_PACKET_ERROR_NONE) {
 570                 LOGE("failed to get eos info");
 571                 return MM_ERROR_PLAYER_INTERNAL;
 572         }
 573
 574         if (is_eos) {
 575                 LOGW("we got eos of stream type(%s)", MMPLAYER_STREAM_TYPE_GET_NAME(streamtype));
 576                 g_signal_emit_by_name(element, "end-of-stream", &ret);
 577         }
 578
 579         return ret;
 580
 581 ERROR:
 582         gst_buffer_unref(_buffer);
 583         return ret;
 584 }
 585
 586 static int
 587 __mmplayer_video_caps_new(MMHandleType hplayer, MMPlayerVideoStreamInfo * video,
 588         const char *fieldname, ...)
 589 {
 590         int cap_size;
 591         GstCaps *caps = NULL;
 592         GstStructure *structure = NULL;
 593         va_list var_args;
 594         mm_player_t *player = MM_PLAYER_CAST(hplayer);
 595
 596         MMPLAYER_FENTER();
 597         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 598         MMPLAYER_RETURN_VAL_IF_FAIL(video, MM_ERROR_PLAYER_NOT_INITIALIZED);
 599
 600         LOGD("width=%d height=%d framerate num=%d, den=%d",
 601         video->width, video->height, video->framerate_num, video->framerate_den);
 602
 603         caps = gst_caps_new_simple(video->mime,
 604                 "width", G_TYPE_INT, video->width,
 605                 "height", G_TYPE_INT, video->height,
 606                 "framerate", GST_TYPE_FRACTION, video->framerate_num, video->framerate_den, NULL);
 607
 608         for (cap_size = 0; cap_size < gst_caps_get_size(caps); cap_size++) {
 609                 va_start(var_args, fieldname);
 610                 structure = gst_caps_get_structure(caps, cap_size);
 611                 gst_structure_set_valist(structure, fieldname, var_args);
 612                 va_end(var_args);
 613         }
 614
 615         if (video->extradata_size) {
 616                 GstBuffer *buf = NULL;
 617                 GstMapInfo buff_info = GST_MAP_INFO_INIT;
 618
 619                 buf = gst_buffer_new_and_alloc(video->extradata_size);
 620
 621                 if (gst_buffer_map(buf, &buff_info, GST_MAP_READ)) {
 622                         memcpy(buff_info.data, video->codec_extradata, video->extradata_size);
 623                         buff_info.size = video->extradata_size;
 624                         gst_buffer_unmap(buf, &buff_info);
 625                 }
 626
 627                 gst_caps_set_simple(caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
 628                 gst_buffer_unref(buf);
 629         }
 630
 631         if (player->v_stream_caps) {
 632                 LOGW("caps will be updated ");
 633
 634                 gst_caps_unref(player->v_stream_caps);
 635                 player->v_stream_caps = NULL;
 636         }
 637
 638         player->v_stream_caps = gst_caps_copy(caps);
 639         MMPLAYER_LOG_GST_CAPS_TYPE(player->v_stream_caps);
 640         gst_caps_unref(caps);
 641
 642         MMPLAYER_FLEAVE();
 643
 644         return MM_ERROR_NONE;
 645 }
 646
 647 static void
 648 __mmplayer_set_uri_type(mm_player_t *player)
 649 {
 650         MMPLAYER_FENTER();
 651
 652         player->profile.uri_type = MM_PLAYER_URI_TYPE_MS_BUFF;
 653         player->es_player_push_mode = TRUE;
 654
 655         MMPLAYER_FLEAVE();
 656         return;
 657 }
 658
 659 int
 660 _mmplayer_set_video_info(MMHandleType hplayer, media_format_h format)
 661 {
 662         mm_player_t *player = MM_PLAYER_CAST(hplayer);
 663         MMPlayerVideoStreamInfo video = { 0, };
 664         int ret = MM_ERROR_NONE;
 665         gboolean drc = FALSE;
 666
 667         MMPLAYER_FENTER();
 668
 669         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 670
 671         __mmplayer_set_uri_type(player);
 672
 673         ret = __parse_media_format(&video, NULL, format);
 674         if (ret != MM_ERROR_NONE)
 675                 return ret;
 676
 677         mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_DRC_MODE, &drc);
 678
 679         if (strstr(video.mime, "video/mpeg")) {
 680                 __mmplayer_video_caps_new(hplayer, &video,
 681                 "mpegversion", G_TYPE_INT, video.version,
 682                 "systemstream", G_TYPE_BOOLEAN, FALSE,
 683                 "adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
 684         } else if (strstr(video.mime, "video/x-h264")) {
 685                 /*
 686                 if (info.colordepth) {
 687                         __mmplayer_video_caps_new(hplayer, &info,
 688                                 "colordepth", G_TYPE_INT, info.colordepth, NULL);
 689                 } else
 690                 */
 691                 {
 692                         __mmplayer_video_caps_new(hplayer, &video,
 693                         "stream-format", G_TYPE_STRING, "byte-stream",
 694                         "alignment", G_TYPE_STRING, "au",
 695                         "adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
 696                 }
 697         }
 698 #if 0
 699         else if (strstr(info->mime, "video/x-wmv")) {
 700                 __mmplayer_video_caps_new(hplayer, &info,
 701                 "wmvversion", G_TYPE_INT, info.version, NULL);
 702         } else if (strstr(info.mime, "video/x-pn-realvideo")) {
 703                 __mmplayer_video_caps_new(hplayer, &info,
 704                 "rmversion", G_TYPE_INT, info.version, NULL);
 705         } else if (strstr(info.mime, "video/x-msmpeg")) {
 706                 __mmplayer_video_caps_new(hplayer, &info,
 707                 "msmpegversion", G_TYPE_INT, info.version, NULL);
 708         } else if (strstr(info.mime, "video/x-h265")) {
 709                 if (info.colordepth)
 710                         __mmplayer_video_caps_new(hplayer, &info,
 711                         "colordepth", G_TYPE_INT, info.colordepth, NULL);
 712                 else
 713                         __mmplayer_video_caps_new(hplayer, &info, NULL);
 714         } else
 715                 __mmplayer_video_caps_new(hplayer, &info, NULL);
 716 #endif
 717         g_free((char *) video.mime);
 718
 719         MMPLAYER_FLEAVE();
 720
 721         return MM_ERROR_NONE;
 722 }
 723
 724 int
 725 _mmplayer_set_audio_info(MMHandleType hplayer, media_format_h format)
 726 {
 727         mm_player_t *player = MM_PLAYER_CAST(hplayer);
 728         GstCaps *caps = NULL;
 729         MMPlayerAudioStreamInfo audio = { 0, };
 730         int ret = MM_ERROR_NONE;
 731
 732         MMPLAYER_FENTER();
 733
 734         MMPLAYER_RETURN_VAL_IF_FAIL(hplayer, MM_ERROR_PLAYER_NOT_INITIALIZED);
 735
 736         __mmplayer_set_uri_type(player);
 737
 738         ret = __parse_media_format(NULL, &audio, format);
 739         if (ret != MM_ERROR_NONE)
 740                 return ret;
 741
 742         audio.user_info = 0;           //test
 743
 744         LOGD("set audio player[%p] version=%d rate=%d channel=%d",
 745                 player, audio.version, audio.sample_rate, audio.channels);
 746
 747         if (strstr(audio.mime, "audio/mpeg")) {
 748                 if (audio.version == 1) {       // mp3
 749                         caps = gst_caps_new_simple("audio/mpeg",
 750                         "channels", G_TYPE_INT, audio.channels,
 751                         "rate", G_TYPE_INT, audio.sample_rate,
 752                         "mpegversion", G_TYPE_INT, audio.version,
 753                         "layer", G_TYPE_INT, audio.user_info, NULL);
 754                 } else {                    // aac
 755                         gchar *stream_format = NULL;
 756
 757                         if (audio.user_info == 0)
 758                                 stream_format = g_strdup("raw");
 759                         else if (audio.user_info == 1)
 760                                 stream_format = g_strdup("adts");
 761                         else if (audio.user_info == 2)
 762                                 stream_format = g_strdup("adif");
 763
 764                         caps = gst_caps_new_simple("audio/mpeg",
 765                                         "channels", G_TYPE_INT, audio.channels,
 766                                         "rate", G_TYPE_INT, audio.sample_rate,
 767                                         "mpegversion", G_TYPE_INT, audio.version,
 768                                         "stream-format", G_TYPE_STRING, stream_format, NULL);
 769
 770                         g_free(stream_format);
 771                         stream_format = NULL;
 772                 }
 773         }
 774 #if 0
 775         else if (strstr(audio.mime, "audio/x-raw-int")) {
 776                 caps = gst_caps_new_simple("audio/x-raw-int",
 777                 "width", G_TYPE_INT, audio.width,
 778                 "depth", G_TYPE_INT, audio.depth,
 779                 "endianness", G_TYPE_INT, audio.endianness,
 780                 "signed", G_TYPE_BOOLEAN, audio.signedness,
 781                 "channels", G_TYPE_INT, audio.channels,
 782                 "rate", G_TYPE_INT, audio.sample_rate, NULL);
 783         } else {
 784                 caps = gst_caps_new_simple(audio.mime,
 785                 "channels", G_TYPE_INT, audio.channels,
 786                 "rate", G_TYPE_INT, audio.sample_rate, NULL);
 787         }
 788 #endif
 789
 790         if (audio.extradata_size && audio.codec_extradata) {
 791                 GstBuffer *buf = NULL;
 792                 GstMapInfo buff_info = GST_MAP_INFO_INIT;
 793
 794                 buf = gst_buffer_new_and_alloc(audio.extradata_size);
 795
 796                 if (gst_buffer_map(buf, &buff_info, GST_MAP_READ)) {
 797                         memcpy(buff_info.data, audio.codec_extradata, audio.extradata_size);
 798                         gst_buffer_unmap(buf, &buff_info);
 799                 }
 800
 801                 gst_caps_set_simple(caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
 802                 gst_buffer_unref(buf);
 803                 g_free((char *) audio.codec_extradata);
 804         }
 805
 806         g_free((char *) audio.mime);
 807
 808         player->a_stream_caps = gst_caps_copy(caps);
 809         gst_caps_unref(caps);
 810
 811         MMPLAYER_FLEAVE();
 812
 813         return MM_ERROR_NONE;
 814 }
 815
 816 int
 817 _mmplayer_set_subtitle_info(MMHandleType hplayer,
 818         MMPlayerSubtitleStreamInfo * subtitle)
 819 {
 820 #if 0                           //todo
 821         mm_player_t *player = MM_PLAYER_CAST(hplayer);
 822         GstCaps *caps = NULL;
 823
 824         MMPLAYER_FENTER();
 825
 826         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 827         MMPLAYER_RETURN_VAL_IF_FAIL(info, MM_ERROR_PLAYER_NOT_INITIALIZED);
 828
 829         LOGD("set subtitle player[%p] info [%p]", player, info);
 830
 831
 832         caps = gst_caps_new_simple(info->mime, NULL, NULL);  // TO CHECK
 833         if (NULL == caps)
 834                 return FALSE;
 835
 836         if (strstr(info->mime, "application/x-xsub")) {
 837                 gst_caps_set_simple(caps, "codec_tag", G_TYPE_UINT, info->codec_tag, NULL);
 838         } else if (strstr(info->mime, "application/x-smpte-text")) {
 839                 if (info->context) {
 840                         gst_caps_set_simple(caps, "ttml_priv_data", G_TYPE_POINTER,
 841                         info->context, NULL);
 842                 }
 843         }
 844
 845         player->s_stream_caps = gst_caps_copy(caps);
 846
 847         gst_caps_unref(caps);
 848 #endif
 849
 850         MMPLAYER_FLEAVE();
 851
 852         return MM_ERROR_NONE;
 853 }
 854
 855 int
 856 _mmplayer_set_media_stream_dynamic_resolution(MMHandleType hplayer, bool drc)
 857 {
 858         mm_player_t *player = MM_PLAYER_CAST(hplayer);
 859         int ret = MM_ERROR_NONE;
 860
 861         MMPLAYER_FENTER();
 862
 863         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 864
 865         mm_attrs_set_int_by_name(player->attrs, MM_PLAYER_DRC_MODE, (int)drc);
 866         if (player->v_stream_caps) {
 867                 gst_caps_set_simple(player->v_stream_caps,
 868                         "adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
 869                 MMPLAYER_LOG_GST_CAPS_TYPE(player->v_stream_caps);
 870         }
 871
 872         MMPLAYER_FLEAVE();
 873
 874         return ret;
 875 }
 876