src/port_gst/mediademuxer_port_gst.c

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @file mediademuxer_port_gst.c
  19  * @brief Handling for GStreamer Port, defined function and there implementation
  20  */
  21
  22 #include <mm_debug.h>
  23 #include <unistd.h>
  24 #include <math.h>
  25 #include <mediademuxer_error.h>
  26 #include <mediademuxer_private.h>
  27 #include <mediademuxer_port.h>
  28 #include <mediademuxer_port_gst.h>
  29 #include <media_packet_internal.h>
  30
  31 static int gst_demuxer_init(MMHandleType *pHandle);
  32 static int gst_demuxer_prepare(MMHandleType pHandle, char *uri);
  33 static int gst_demuxer_get_data_count(MMHandleType pHandle, int *count);
  34 static int gst_demuxer_set_track(MMHandleType pHandle, int track);
  35 static int gst_demuxer_start(MMHandleType pHandle);
  36 static int gst_demuxer_read_sample(MMHandleType pHandle,
  37                         media_packet_h *outbuf, int track_indx);
  38 static int gst_demuxer_get_track_info(MMHandleType pHandle,
  39                         media_format_h *format, int index);
  40 static int gst_demuxer_seek(MMHandleType pHandle, gint64 pos1);
  41 static int gst_demuxer_unset_track(MMHandleType pHandle, int track);
  42 static int gst_demuxer_stop(MMHandleType pHandle);
  43 static int gst_demuxer_unprepare(MMHandleType pHandle);
  44 static int gst_demuxer_destroy(MMHandleType pHandle);
  45 static int gst_set_error_cb(MMHandleType pHandle,
  46                         gst_error_cb callback, void *user_data);
  47 static int gst_set_eos_cb(MMHandleType pHandle,
  48                         gst_eos_cb callback, void *user_data);
  49 static int __gst_eos_callback(int track_num, void *user_data);
  50
  51 static gint __gst_handle_core_error(mdgst_handle_t *gst_handle, int code);
  52 static gint __gst_handle_library_error(mdgst_handle_t *gst_handle, int code);
  53 static gint __gst_handle_resource_error(mdgst_handle_t *gst_handle, int code);
  54 static gint __gst_handle_stream_error(mdgst_handle_t *gst_handle, GError *error, GstMessage *message);
  55 static gint __gst_transform_gsterror(mdgst_handle_t *gst_handle, GstMessage *message, GError *error);
  56
  57 /* Media Demuxer API common */
  58 static media_port_demuxer_ops def_demux_ops = {
  59         .n_size = 0,
  60         .init = gst_demuxer_init,
  61         .prepare = gst_demuxer_prepare,
  62         .get_track_count = gst_demuxer_get_data_count,
  63         .set_track = gst_demuxer_set_track,
  64         .start = gst_demuxer_start,
  65         .get_track_info = gst_demuxer_get_track_info,
  66         .read_sample = gst_demuxer_read_sample,
  67         .seek = gst_demuxer_seek,
  68         .unset_track = gst_demuxer_unset_track,
  69         .stop = gst_demuxer_stop,
  70         .unprepare = gst_demuxer_unprepare,
  71         .destroy = gst_demuxer_destroy,
  72         .set_error_cb = gst_set_error_cb,
  73         .set_eos_cb = gst_set_eos_cb,
  74 };
  75
  76 static gint __gst_handle_core_error(mdgst_handle_t *gst_handle, int code)
  77 {
  78         gint trans_err = MEDIADEMUXER_ERROR_NONE;
  79
  80         MEDIADEMUXER_CHECK_NULL(gst_handle);
  81
  82         switch (code) {
  83         case GST_CORE_ERROR_MISSING_PLUGIN:
  84                 return MEDIADEMUXER_ERROR_NOT_SUPPORTED;
  85         case GST_CORE_ERROR_STATE_CHANGE:
  86         case GST_CORE_ERROR_SEEK:
  87         case GST_CORE_ERROR_NOT_IMPLEMENTED:
  88         case GST_CORE_ERROR_FAILED:
  89         case GST_CORE_ERROR_TOO_LAZY:
  90         case GST_CORE_ERROR_PAD:
  91         case GST_CORE_ERROR_THREAD:
  92         case GST_CORE_ERROR_NEGOTIATION:
  93         case GST_CORE_ERROR_EVENT:
  94         case GST_CORE_ERROR_CAPS:
  95         case GST_CORE_ERROR_TAG:
  96         case GST_CORE_ERROR_CLOCK:
  97         case GST_CORE_ERROR_DISABLED:
  98         default:
  99                 trans_err =  MEDIADEMUXER_ERROR_INVALID_OPERATION;
 100                 break;
 101         }
 102
 103         return trans_err;
 104 }
 105
 106 static gint __gst_handle_library_error(mdgst_handle_t *gst_handle, int code)
 107 {
 108         gint trans_err = MEDIADEMUXER_ERROR_NONE;
 109
 110         MEDIADEMUXER_CHECK_NULL(gst_handle);
 111
 112         switch (code) {
 113         case GST_LIBRARY_ERROR_FAILED:
 114         case GST_LIBRARY_ERROR_TOO_LAZY:
 115         case GST_LIBRARY_ERROR_INIT:
 116         case GST_LIBRARY_ERROR_SHUTDOWN:
 117         case GST_LIBRARY_ERROR_SETTINGS:
 118         case GST_LIBRARY_ERROR_ENCODE:
 119         default:
 120                 trans_err =  MEDIADEMUXER_ERROR_INVALID_OPERATION;
 121                 break;
 122         }
 123
 124         return trans_err;
 125 }
 126
 127
 128 static gint __gst_handle_resource_error(mdgst_handle_t *gst_handle, int code)
 129 {
 130         gint trans_err = MEDIADEMUXER_ERROR_NONE;
 131
 132         MEDIADEMUXER_CHECK_NULL(gst_handle);
 133
 134         switch (code) {
 135         case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
 136                 trans_err = MEDIADEMUXER_ERROR_OUT_OF_MEMORY;
 137                 break;
 138         case GST_RESOURCE_ERROR_WRITE:
 139         case GST_RESOURCE_ERROR_FAILED:
 140         case GST_RESOURCE_ERROR_SEEK:
 141         case GST_RESOURCE_ERROR_TOO_LAZY:
 142         case GST_RESOURCE_ERROR_BUSY:
 143         case GST_RESOURCE_ERROR_OPEN_WRITE:
 144         case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
 145         case GST_RESOURCE_ERROR_CLOSE:
 146         case GST_RESOURCE_ERROR_SYNC:
 147         case GST_RESOURCE_ERROR_SETTINGS:
 148         default:
 149                 trans_err = MEDIADEMUXER_ERROR_RESOURCE_LIMIT;
 150                 break;
 151         }
 152
 153         return trans_err;
 154 }
 155
 156 static gint __gst_handle_stream_error(mdgst_handle_t *gst_handle, GError *error, GstMessage *message)
 157 {
 158         gint trans_err = MEDIADEMUXER_ERROR_NONE;
 159
 160         MEDIADEMUXER_CHECK_NULL(gst_handle);
 161         MEDIADEMUXER_CHECK_NULL(error);
 162         MEDIADEMUXER_CHECK_NULL(message);
 163
 164         switch (error->code) {
 165         case GST_STREAM_ERROR_FAILED:
 166         case GST_STREAM_ERROR_TYPE_NOT_FOUND:
 167         case GST_STREAM_ERROR_DECODE:
 168         case GST_STREAM_ERROR_WRONG_TYPE:
 169         case GST_STREAM_ERROR_DECRYPT:
 170         case GST_STREAM_ERROR_DECRYPT_NOKEY:
 171         case GST_STREAM_ERROR_CODEC_NOT_FOUND:
 172                 trans_err = __gst_transform_gsterror(gst_handle, message, error);
 173                 break;
 174
 175         case GST_STREAM_ERROR_NOT_IMPLEMENTED:
 176         case GST_STREAM_ERROR_TOO_LAZY:
 177         case GST_STREAM_ERROR_ENCODE:
 178         case GST_STREAM_ERROR_DEMUX:
 179         case GST_STREAM_ERROR_MUX:
 180         case GST_STREAM_ERROR_FORMAT:
 181         default:
 182                 trans_err = MEDIADEMUXER_ERROR_INVALID_OPERATION;
 183                 break;
 184         }
 185
 186         return trans_err;
 187 }
 188
 189 static gint __gst_transform_gsterror(mdgst_handle_t *gst_handle, GstMessage *message, GError *error)
 190 {
 191         gchar *src_element_name = NULL;
 192         GstElement *src_element = NULL;
 193         GstElementFactory *factory = NULL;
 194         const gchar *klass = NULL;
 195
 196         MEDIADEMUXER_CHECK_NULL(gst_handle);
 197
 198         src_element = GST_ELEMENT_CAST(message->src);
 199         if (!src_element)
 200                 goto INTERNAL_ERROR;
 201
 202         src_element_name = GST_ELEMENT_NAME(src_element);
 203         if (!src_element_name)
 204                 goto INTERNAL_ERROR;
 205
 206         factory = gst_element_get_factory(src_element);
 207         if (!factory)
 208                 goto INTERNAL_ERROR;
 209
 210         klass = gst_element_factory_get_klass(factory);
 211         if (!klass)
 212                 goto INTERNAL_ERROR;
 213
 214         MD_I("error code=%d, msg=%s, src element=%s, class=%s\n",
 215                         error->code, error->message, src_element_name, klass);
 216
 217         switch (error->code) {
 218         case GST_STREAM_ERROR_DECODE:
 219         case GST_STREAM_ERROR_FAILED:
 220                 return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
 221                 break;
 222
 223         case GST_STREAM_ERROR_CODEC_NOT_FOUND:
 224         case GST_STREAM_ERROR_TYPE_NOT_FOUND:
 225         case GST_STREAM_ERROR_WRONG_TYPE:
 226                 return MEDIADEMUXER_ERROR_NOT_SUPPORTED;
 227                 break;
 228
 229         default:
 230                 return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
 231                 break;
 232         }
 233
 234         return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
 235
 236 INTERNAL_ERROR:
 237         return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
 238 }
 239
 240
 241 int gst_mediademxer_port_register(media_port_demuxer_ops *pOps)
 242 {
 243         MEDIADEMUXER_FENTER();
 244         int ret = MD_ERROR_NONE;
 245         MEDIADEMUXER_CHECK_NULL(pOps);
 246         def_demux_ops.n_size = sizeof(def_demux_ops);
 247
 248         memcpy((char *)pOps + sizeof(pOps->n_size),
 249                (char *)&def_demux_ops + sizeof(def_demux_ops.n_size),
 250                pOps->n_size - sizeof(pOps->n_size));
 251
 252         MEDIADEMUXER_FLEAVE();
 253         return ret;
 254 }
 255
 256 static int gst_demuxer_init(MMHandleType *pHandle)
 257 {
 258         MEDIADEMUXER_FENTER();
 259         int ret = MD_ERROR_NONE;
 260         mdgst_handle_t *new_mediademuxer = NULL;
 261         new_mediademuxer = (mdgst_handle_t *)g_malloc(sizeof(mdgst_handle_t));
 262         MD_I("gst_demuxer_init allocating new_mediademuxer:%p\n", new_mediademuxer);
 263         if (!new_mediademuxer) {
 264                 MD_E("Cannot allocate memory for demuxer\n");
 265                 ret = MD_ERROR;
 266                 goto ERROR;
 267         }
 268         memset(new_mediademuxer, 0, sizeof(mdgst_handle_t));
 269         new_mediademuxer->is_prepared = false;
 270         (new_mediademuxer->info).num_audio_track = 0;
 271         (new_mediademuxer->info).num_video_track = 0;
 272         (new_mediademuxer->info).num_subtitle_track = 0;
 273         (new_mediademuxer->info).num_other_track = 0;
 274         (new_mediademuxer->info).head = NULL;
 275         *pHandle = (MMHandleType)new_mediademuxer;
 276         new_mediademuxer->total_tracks = 0;
 277         MEDIADEMUXER_FLEAVE();
 278         return ret;
 279 ERROR:
 280         MEDIADEMUXER_FLEAVE();
 281         return ret;
 282 }
 283
 284 gboolean __gst_bus_call(GstBus *bus, GstMessage *msg, gpointer data)
 285 {
 286         mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
 287         MEDIADEMUXER_FENTER();
 288         int ret = MD_ERROR_NONE;
 289         switch (GST_MESSAGE_TYPE(msg)) {
 290         case GST_MESSAGE_EOS: {
 291                         MD_I("EOS Reached");
 292                 }
 293                 break;
 294         case GST_MESSAGE_ERROR: {
 295                         GError *error = NULL;
 296                         gst_message_parse_error(msg, &error, NULL);
 297                         if (!error) {
 298                                 MD_I("GST error message parsing failed");
 299                                 break;
 300                         }
 301
 302                         if (error->domain == GST_STREAM_ERROR)
 303                                 ret = __gst_handle_stream_error(gst_handle, error, msg);
 304                         else if (error->domain == GST_RESOURCE_ERROR)
 305                                 ret = __gst_handle_resource_error(gst_handle, error->code);
 306                         else if (error->domain == GST_LIBRARY_ERROR)
 307                                 ret = __gst_handle_library_error(gst_handle, error->code);
 308                         else if (error->domain == GST_CORE_ERROR)
 309                                 ret = __gst_handle_core_error(gst_handle, error->code);
 310                         else
 311                                 MD_W("Unexpected error has occured");
 312
 313                         if (gst_handle->user_cb[_GST_EVENT_TYPE_ERROR]) {
 314                                 ((mediademuxer_error_cb)gst_handle->user_cb[_GST_EVENT_TYPE_ERROR])
 315                                         (ret, gst_handle->user_data[_GST_EVENT_TYPE_ERROR]);
 316                                         MD_W("Error : (ox%08x)", ret);
 317                         }
 318                         MD_E("Error: %s\n", error->message);
 319                         g_error_free(error);
 320                 }
 321                 break;
 322         default:
 323                 break;
 324         }
 325         MEDIADEMUXER_FLEAVE();
 326         return ret;
 327 }
 328
 329 static void __gst_no_more_pad(GstElement *element, gpointer data)
 330 {
 331         MEDIADEMUXER_FENTER();
 332         mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
 333         int loop_track;
 334         track_info *head_track = &(gst_handle->info);
 335         track *head = head_track->head;
 336         MEDIADEMUXER_CHECK_NULL_VOID(gst_handle);
 337         gst_handle->selected_tracks =
 338             (bool *) g_malloc(sizeof(bool) * (gst_handle->total_tracks));
 339         MD_I("Allocating %p to core->selected_tracks \n", gst_handle->selected_tracks);
 340         if (!gst_handle->selected_tracks) {
 341                 MD_E("[%s]Memory allocation failed\n", __FUNCTION__);
 342                 return;
 343         } else {
 344                 for (loop_track = 0; loop_track < gst_handle->total_tracks;
 345                      loop_track++)
 346                         gst_handle->selected_tracks[loop_track] = false;
 347         }
 348         MD_I("Number of video tracks are %d\n", head_track->num_video_track);
 349         MD_I("Number of audio tracks are %d\n", head_track->num_audio_track);
 350         MD_I("Number of subtitle tracks are %d\n",
 351              head_track->num_subtitle_track);
 352         MD_I("Number of other tracks are %d\n", head_track->num_other_track);
 353         while (head) {
 354                 MD_I("track caps[%s]\n", head->caps_string);
 355                 head = head->next;
 356         }
 357         gst_handle->is_prepared = true;
 358         MD_I("core->is_prepared: ");
 359         gst_handle->is_prepared ? MD_I("true\n") : MD_I("false\n");
 360         MEDIADEMUXER_FLEAVE();
 361 }
 362
 363 void __gst_free_stuct(track **head)
 364 {
 365         MEDIADEMUXER_FENTER();
 366         track *temp = NULL;
 367         temp = *head;
 368         while (temp) {
 369
 370                 if (temp->pad) {
 371                         MD_I("unref GST_PAD %p\n", temp->pad);
 372                         gst_object_unref(temp->pad);
 373                 }
 374                 if (temp->caps) {
 375                         MD_I("unref GST_PAD caps %p\n", temp->caps);
 376                         gst_caps_unref(temp->caps);
 377                 }
 378                 if (temp->caps_string) {
 379                         MD_I("deallocate GST_PAD caps_string  %p\n",
 380                              temp->caps_string);
 381                         g_free(temp->caps_string);
 382                 }
 383                 if (temp->format) {
 384                         MD_I("unref media_format  %p\n", temp->format);
 385                         media_format_unref(temp->format);
 386                 }
 387                 if (temp->next) {
 388                         track *next = temp->next;
 389                         MD_I("deallocate memory %p\n", temp);
 390                         free(temp);
 391                         temp = next;
 392                 } else {
 393                         MD_I("deallocate memory %p\n", temp);
 394                         free(temp);
 395                         temp = NULL;
 396                         *head = NULL;
 397                 }
 398         }
 399         MEDIADEMUXER_FLEAVE();
 400 }
 401
 402 int __gst_add_track_info(GstPad *pad, GstCaps *caps, track **head,
 403                                                 GstElement *pipeline)
 404 {
 405         MEDIADEMUXER_FENTER();
 406         GstPad *apppad = NULL;
 407         GstPad *queue_sink_pad = NULL;
 408         GstPad *queue_src_pad = NULL;
 409         GstCaps *outcaps = NULL;
 410         GstPad *parse_sink_pad = NULL;
 411         GstElement *parse_element = NULL;
 412         GstElement *id3tag = NULL;
 413         GstPad *id3_sinkpad = NULL;
 414         GstPad *id3_srcpad = NULL;
 415         track *temp = NULL;
 416
 417         temp = (track *)(g_malloc(sizeof(track)));
 418         if (!temp) {
 419                 MD_E("Not able to allocate memory");
 420                 return MD_ERROR;
 421         } else {
 422                 MD_I("allocate memory %p", temp);
 423         }
 424         memset(temp, 0x00, sizeof(track));
 425
 426         temp->pad = gst_object_ref(pad);
 427         temp->caps = gst_caps_ref(caps);
 428         temp->caps_string = gst_caps_to_string(caps);
 429         temp->next = NULL;
 430         temp->format = NULL;
 431         temp->need_codec_data = TRUE;
 432
 433         MD_I("track caps(%s)", temp->caps_string ? temp->caps_string : "NULL");
 434
 435         /* Link demuxer - queue */
 436         temp->queue = gst_element_factory_make("queue", NULL);
 437         if (!temp->queue) {
 438                 MD_E("factory not able to make queue");
 439                 goto ERROR;
 440         }
 441
 442         if (!gst_bin_add(GST_BIN(pipeline), temp->queue)) {
 443                 gst_object_unref(temp->queue);
 444                 MD_E("fail add queue in pipeline");
 445                 goto ERROR;
 446         }
 447         MD_I("added queue element in pipeline.");
 448
 449         queue_sink_pad = gst_element_get_static_pad(temp->queue, "sink");
 450         if (!queue_sink_pad) {
 451                 MD_E("sink pad of queue not avaible");
 452                 goto ERROR;
 453         }
 454
 455         MEDIADEMUXER_LINK_PAD(pad, queue_sink_pad, ERROR);
 456         MEDIADEMUXER_SYNC_STATE_WITH_PARENT(temp->queue, ERROR);
 457
 458         temp->appsink = gst_element_factory_make("appsink", NULL);
 459         if (!temp->appsink) {
 460                 MD_E("factory not able to make appsink");
 461                 goto ERROR;
 462         }
 463         g_object_set(G_OBJECT(temp->appsink), "wait-on-eos", TRUE, NULL);
 464
 465         if (!gst_bin_add(GST_BIN(pipeline), temp->appsink)) {
 466                 gst_object_unref(temp->appsink);
 467                 MD_E("fail add appsink in pipeline");
 468                 goto ERROR;
 469         }
 470         MD_I("added appsink element in pipeline.");
 471
 472         gst_app_sink_set_max_buffers((GstAppSink *) temp->appsink, (guint) 0);
 473         gst_app_sink_set_drop((GstAppSink *) temp->appsink, true);
 474
 475         queue_src_pad = gst_element_get_static_pad(temp->queue, "src");
 476         if (!queue_src_pad) {
 477                 MD_E("src pad of queue not avaible");
 478                 goto ERROR;
 479         }
 480         apppad = gst_element_get_static_pad(temp->appsink, "sink");
 481         if (!apppad) {
 482                 MD_E("sink pad of appsink not avaible");
 483                 goto ERROR;
 484         }
 485         /* Check for type video and it should be h264 */
 486         if (temp->caps_string && strstr(temp->caps_string, "video")) {
 487                 if (strstr(temp->caps_string, "h264")) {
 488                         parse_element = gst_element_factory_make("h264parse", NULL);
 489                         if (!parse_element) {
 490                                 MD_E("factory not able to make h264parse");
 491                                 goto ERROR;
 492                         }
 493                 } else if (strstr(temp->caps_string, "mpeg")) {
 494                         parse_element = gst_element_factory_make("mpeg4videoparse", NULL);
 495                         if (!parse_element) {
 496                                 MD_E("factory not able to make h264parse");
 497                                 goto ERROR;
 498                         }
 499                         g_object_set(G_OBJECT(parse_element), "config-interval", 1, NULL);
 500                 }
 501
 502                 if (parse_element) {
 503                         MD_I("add video parse element(%s).", GST_ELEMENT_NAME(parse_element));
 504                         if (!gst_bin_add(GST_BIN(pipeline), parse_element)) {
 505                                 gst_object_unref(parse_element);
 506                                 MD_E("fail add video parse(%s) in pipeline", GST_ELEMENT_NAME(parse_element));
 507                                 goto ERROR;
 508                         }
 509                         parse_sink_pad = gst_element_get_static_pad(parse_element, "sink");
 510                         if (!parse_sink_pad) {
 511                                 MD_E("sink pad of video parse(%s) not available", GST_ELEMENT_NAME(parse_element));
 512                                 goto ERROR;
 513                         }
 514                         /* Link demuxer pad with sink pad of parse element */
 515                         MEDIADEMUXER_LINK_PAD(queue_src_pad, parse_sink_pad, ERROR);
 516
 517                         MEDIADEMUXER_SYNC_STATE_WITH_PARENT(parse_element, ERROR);
 518
 519                         if (strstr(temp->caps_string, "h264")) {
 520                                 outcaps = gst_caps_new_simple("video/x-h264", "stream-format", G_TYPE_STRING, "byte-stream", NULL);
 521                                 gst_element_link_filtered(parse_element, temp->appsink, outcaps);
 522                                 gst_caps_unref(outcaps);
 523                                 temp->need_codec_data = FALSE;
 524                         } else if (strstr(temp->caps_string, "mpeg")) {
 525                                 gst_element_link(parse_element, temp->appsink);
 526                         } else {
 527                                 MEDIADEMUXER_LINK_PAD(queue_src_pad, apppad, ERROR);
 528                         }
 529                 } else {
 530                         MEDIADEMUXER_LINK_PAD(queue_src_pad, apppad, ERROR);
 531                 }
 532         } else if (temp->caps_string && (strstr(temp->caps_string, "audio") || strstr(temp->caps_string, "x-id3"))) {
 533                 if (strstr(temp->caps_string, "audio/mpeg")) {
 534                         int mpegversion = 0;
 535                         GstStructure *structure = NULL;
 536                         structure = gst_caps_get_structure(temp->caps, 0);
 537                         gst_structure_get_int (structure, "mpegversion", &mpegversion);
 538                         if (mpegversion == 2 || mpegversion == 4) {
 539                                 parse_element = gst_element_factory_make("aacparse", NULL);
 540                                 if (!parse_element) {
 541                                         MD_E("factory not able to make aacparse");
 542                                         goto ERROR;
 543                                 }
 544                         } else if (mpegversion == 1) {
 545                                 parse_element = gst_element_factory_make("mpegaudioparse", NULL);
 546                                 if (!parse_element) {
 547                                         MD_E("factory not able to make mpegaudioparse");
 548                                         goto ERROR;
 549                                 }
 550                         }
 551                 } else if (strstr(temp->caps_string, "application/x-id3")) {
 552                         id3tag = gst_element_factory_make("id3demux", NULL);
 553                         if (!id3tag) {
 554                                 MD_E("factory not able to make id3demux");
 555                                 goto ERROR;
 556                         }
 557                         if (!gst_bin_add(GST_BIN(pipeline), id3tag)) {
 558                                 gst_object_unref(id3tag);
 559                                 MD_E("fail add id3tag element in pipeline");
 560                                 goto ERROR;
 561                         }
 562                         id3_sinkpad = gst_element_get_static_pad(id3tag, "sink");
 563                         if (!id3_sinkpad) {
 564                                 MD_E("fail to get id3demux sink pad.\n");
 565                                 goto ERROR;
 566                         }
 567                         MEDIADEMUXER_LINK_PAD(queue_src_pad, id3_sinkpad, ERROR);
 568                         MEDIADEMUXER_SYNC_STATE_WITH_PARENT(id3tag, ERROR);
 569                         id3_srcpad = gst_element_get_static_pad(id3tag, "src");
 570                         if (!id3_srcpad) {
 571                                 MD_E("fail to get id3demux src pad.\n");
 572                                 goto ERROR;
 573                         }
 574                         parse_element = gst_element_factory_make("mpegaudioparse", NULL);
 575                         if (!parse_element) {
 576                                 MD_E("factory not able to make mpegaudioparse");
 577                                 goto ERROR;
 578                         }
 579                 } else if (strstr(temp->caps_string, "audio/x-amr-nb-sh")
 580                                 || strstr(temp->caps_string, "audio/x-amr-wb-sh")) {
 581                         parse_element = gst_element_factory_make("amrparse", NULL);
 582                         if (!parse_element) {
 583                                 MD_E("factory not able to make amrparse");
 584                                 goto ERROR;
 585                         }
 586                 } else if (strstr(temp->caps_string, "audio/x-wav")) {
 587                         parse_element = gst_element_factory_make("wavparse", NULL);
 588                         if (!parse_element) {
 589                                 MD_E("factory not able to make wavparse");
 590                                 goto ERROR;
 591                         }
 592                 } else if (strstr(temp->caps_string, "audio/x-flac")) {
 593                         parse_element = gst_element_factory_make("flacparse", NULL);
 594                         if (!parse_element) {
 595                                 MD_E("factory not able to make flacparse");
 596                                 goto ERROR;
 597                         }
 598                 }
 599
 600                 if (parse_element) {
 601                         MD_I("add audio parse element(%s).", GST_ELEMENT_NAME(parse_element));
 602                         if (!gst_bin_add(GST_BIN(pipeline), parse_element)) {
 603                                 gst_object_unref(parse_element);
 604                                 MD_E("fail add audio parse(%s) in pipeline", GST_ELEMENT_NAME(parse_element));
 605                                 goto ERROR;
 606                         }
 607                         parse_sink_pad = gst_element_get_static_pad(parse_element, "sink");
 608                         if (!parse_sink_pad) {
 609                                 MD_E("sink pad of audio parse(%s) not available", GST_ELEMENT_NAME(parse_element));
 610                                 goto ERROR;
 611                         }
 612
 613                         /* Link demuxer pad with sink pad of parse element */
 614                         if (id3tag)
 615                                 MEDIADEMUXER_LINK_PAD(id3_srcpad, parse_sink_pad, ERROR);
 616                         else
 617                                 MEDIADEMUXER_LINK_PAD(queue_src_pad, parse_sink_pad, ERROR);
 618
 619                         MEDIADEMUXER_SYNC_STATE_WITH_PARENT(parse_element, ERROR);
 620
 621                         /* Link src pad with appSink element */
 622                         gst_element_link(parse_element, temp->appsink);
 623                 } else {
 624                         MEDIADEMUXER_LINK_PAD(queue_src_pad, apppad, ERROR);
 625                 }
 626         } else {
 627                 MEDIADEMUXER_LINK_PAD(queue_src_pad, apppad, ERROR);
 628         }
 629
 630         MEDIADEMUXER_SYNC_STATE_WITH_PARENT(temp->appsink, ERROR);
 631         /* gst_pad_link(pad, fpad) */
 632         if (*head == NULL) {
 633                 *head = temp;
 634         } else {
 635                 track *prev = *head;
 636                 while (prev->next)
 637                         prev = prev->next;
 638                 prev->next = temp;
 639         }
 640         if (queue_sink_pad)
 641                 gst_object_unref(queue_sink_pad);
 642         if (queue_src_pad)
 643                 gst_object_unref(queue_src_pad);
 644         if (apppad)
 645                 gst_object_unref(apppad);
 646         if (parse_sink_pad)
 647                 gst_object_unref(parse_sink_pad);
 648         if (id3_sinkpad)
 649                 gst_object_unref(id3_sinkpad);
 650         if (id3_srcpad)
 651                 gst_object_unref(id3_srcpad);
 652         MEDIADEMUXER_FLEAVE();
 653         return MD_ERROR_NONE;
 654
 655 ERROR:
 656         __gst_free_stuct(&temp);
 657         if (queue_sink_pad)
 658                 gst_object_unref(queue_sink_pad);
 659         if (queue_src_pad)
 660                 gst_object_unref(queue_src_pad);
 661         if (apppad)
 662                 gst_object_unref(apppad);
 663         if (parse_sink_pad)
 664                 gst_object_unref(parse_sink_pad);
 665         if (id3_sinkpad)
 666                 gst_object_unref(id3_sinkpad);
 667         if (id3_srcpad)
 668                 gst_object_unref(id3_srcpad);
 669         __gst_free_stuct(head);
 670         MEDIADEMUXER_FLEAVE();
 671         return MD_ERROR;
 672 }
 673
 674 static void __gst_on_pad_added(GstElement *element, GstPad *pad, gpointer data)
 675 {
 676         MEDIADEMUXER_FENTER();
 677         MD_I("Dynamic pad created, linking demuxer/decoder\n");
 678         track *tmp = NULL;
 679         mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
 680         track_info *head_track = &(gst_handle->info);
 681         GstCaps *caps = NULL;
 682         MEDIADEMUXER_CHECK_NULL_VOID(gst_handle);
 683         caps = gst_pad_get_current_caps(pad);
 684         if (!caps) {
 685                 MD_E("caps is NULL");
 686                 return;
 687         }
 688         gst_handle->total_tracks++;
 689         if (__gst_add_track_info(pad, caps, &(head_track->head), gst_handle->pipeline)
 690             != MD_ERROR_NONE) {
 691                 MD_E("unable to added track info");
 692                 head_track->num_audio_track = 0;
 693                 head_track->num_video_track = 0;
 694                 head_track->num_subtitle_track = 0;
 695                 head_track->num_other_track = 0;
 696                 gst_caps_unref(caps);
 697                 __gst_free_stuct(&(head_track->head));
 698                 return;
 699         }
 700         gst_caps_unref(caps);
 701         tmp = head_track->head;
 702         while (tmp->next)
 703                 tmp = tmp->next;
 704         if (!tmp || !tmp->caps_string) {
 705                 MD_I("trak or trak caps_string is NULL\n");
 706                 MEDIADEMUXER_FLEAVE();
 707                 return;
 708         }
 709         if (tmp->caps_string[0] == 'v') {
 710                 MD_I("found Video Pad\n");
 711                 (head_track->num_video_track)++;
 712         } else if (tmp->caps_string[0] == 'a') {
 713                 MD_I("found Audio Pad\n");
 714                 (head_track->num_audio_track)++;
 715         } else if (tmp->caps_string[0] == 's') {
 716                 MD_I("found subtitle(or Text) Pad\n");
 717                 (head_track->num_subtitle_track)++;
 718         } else {
 719                 MD_W("found Pad, caps: %s\n", tmp->caps_string);
 720                 (head_track->num_other_track)++;
 721         }
 722         MEDIADEMUXER_FLEAVE();
 723 }
 724
 725 static int __gst_create_audio_only_pipeline(gpointer data,  GstCaps *caps)
 726 {
 727         MEDIADEMUXER_FENTER();
 728         mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
 729         GstPad *pad = NULL;
 730         track_info *head_track = &(gst_handle->info);
 731
 732         gst_handle->is_valid_container = true;
 733
 734         pad = gst_element_get_static_pad(gst_handle->typefind, "src");
 735         if (!pad) {
 736                 MD_E("fail to get typefind src pad.\n");
 737                 goto ERROR;
 738         }
 739
 740         gst_handle->total_tracks++;
 741         if (__gst_add_track_info(pad, caps, &(head_track->head), gst_handle->pipeline) != MD_ERROR_NONE) {
 742                 MD_E("unable to added track info");
 743                 head_track->num_audio_track = 0;
 744                 head_track->num_video_track = 0;
 745                 head_track->num_subtitle_track = 0;
 746                 head_track->num_other_track = 0;
 747                 __gst_free_stuct(&(head_track->head));
 748                 goto ERROR;
 749         }
 750
 751         (head_track->num_audio_track)++;
 752
 753         /* unref pads */
 754         if (pad)
 755                 gst_object_unref(pad);
 756
 757         /* In the case of audio only, there is no gst_handle->demux. So we pass NULL */
 758         __gst_no_more_pad(NULL, data);
 759
 760         MEDIADEMUXER_FLEAVE();
 761         return MD_ERROR_NONE;
 762
 763 ERROR:
 764         gst_handle->is_valid_container = false;
 765
 766         if (pad)
 767                 gst_object_unref(pad);
 768
 769         MEDIADEMUXER_FLEAVE();
 770         return MD_ERROR;
 771 }
 772
 773 static void __gst_cb_typefind(GstElement *tf, guint probability,
 774                                         GstCaps *caps, gpointer data)
 775 {
 776         MEDIADEMUXER_FENTER();
 777         mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
 778         GstPad *pad = NULL;
 779         GstPad *demuxer_pad = NULL;
 780         GstPad *fake_pad = NULL;
 781         gchar *type = NULL;
 782         MEDIADEMUXER_CHECK_NULL_VOID(gst_handle);
 783         type = gst_caps_to_string(caps);
 784
 785         if (!type) {
 786                 MD_E("Fail to get caps string");
 787                 goto ERROR;
 788         }
 789
 790         MD_I("Media type %s found, probability %d%%\n", type, probability);
 791         if (strstr(type, "quicktime") || strstr(type, "audio/x-m4a") ||
 792                 strstr(type, "x-3gp") || strstr(type, "ogg") ||
 793                 strstr(type, "flv") || strstr(type, "x-msvideo")) {
 794                 gst_handle->is_valid_container = true;
 795                 if (strstr(type, "ogg"))
 796                         gst_handle->demux = gst_element_factory_make("oggdemux", NULL);
 797                 else if (strstr(type, "flv"))
 798                         gst_handle->demux = gst_element_factory_make("flvdemux", NULL);
 799                 else if (strstr(type, "x-msvideo"))
 800                         gst_handle->demux = gst_element_factory_make("avidemux", NULL);
 801                 else
 802                         gst_handle->demux = gst_element_factory_make("qtdemux", NULL);
 803
 804                 if (!gst_handle->demux) {
 805                         gst_handle->is_valid_container = false;
 806                         MD_E("factory not able to create qtdemux\n");
 807                         goto ERROR;
 808                 }
 809                 g_signal_connect(gst_handle->demux, "pad-added",
 810                                                 G_CALLBACK(__gst_on_pad_added), gst_handle);
 811                 g_signal_connect(gst_handle->demux, "no-more-pads",
 812                                                 G_CALLBACK(__gst_no_more_pad), gst_handle);
 813                 gst_element_set_locked_state(gst_handle->demux, TRUE);
 814                 if (!gst_bin_add(GST_BIN(gst_handle->pipeline), gst_handle->demux)) {
 815                         MD_E("fail add demuxer(%s) in pipeline",
 816                                 GST_ELEMENT_NAME(gst_handle->demux));
 817                         gst_object_unref(gst_handle->demux);
 818                         gst_handle->demux = NULL;
 819                         goto ERROR;
 820                 }
 821
 822                 pad = gst_element_get_static_pad(gst_handle->typefind, "src");
 823                 if (!pad) {
 824                         MD_E("fail to get typefind src pad.\n");
 825                         goto ERROR;
 826                 }
 827                 demuxer_pad = gst_element_get_static_pad(gst_handle->demux, "sink");
 828                 if (!demuxer_pad) {
 829                         MD_E("fail to get qtdemuc sink pad.\n");
 830                         goto ERROR;
 831                 }
 832                 fake_pad = gst_element_get_static_pad(gst_handle->fakesink, "sink");
 833                 if (!fake_pad) {
 834                         MD_E("fail to get fakesink sink pad.\n");
 835                         goto ERROR;
 836                 }
 837                 gst_pad_unlink(pad, fake_pad);
 838                 MEDIADEMUXER_LINK_PAD(pad, demuxer_pad, ERROR);
 839
 840                 MEDIADEMUXER_SYNC_STATE_WITH_PARENT(gst_handle->demux, ERROR);
 841                 gst_element_set_locked_state(gst_handle->demux, FALSE);
 842                 if (pad)
 843                         gst_object_unref(pad);
 844                 if (demuxer_pad)
 845                         gst_object_unref(demuxer_pad);
 846                 if (fake_pad)
 847                         gst_object_unref(fake_pad);
 848
 849         } else if ((strstr(type, "adts"))
 850                    || (strstr(type, "audio/mpeg"))
 851                    || (strstr(type, "audio/x-wav"))
 852                    || (strstr(type, "audio/x-flac"))
 853                    || (strstr(type, "application/x-id3"))
 854                    || (strstr(type, "audio/x-amr-nb-sh"))
 855                    || (strstr(type, "audio/x-amr-wb-sh"))) {
 856                 MD_I("Audio only format is found\n");
 857                 pad = gst_element_get_static_pad(gst_handle->typefind, "src");
 858                 if (!pad) {
 859                         MD_E("fail to get typefind src pad.\n");
 860                         goto ERROR;
 861                 }
 862                 fake_pad = gst_element_get_static_pad(gst_handle->fakesink, "sink");
 863                 if (!fake_pad) {
 864                         MD_E("fail to get fakesink sink pad.\n");
 865                         goto ERROR;
 866                 }
 867                 gst_pad_unlink(pad, fake_pad);
 868                 if (pad)
 869                         gst_object_unref(pad);
 870                 if (fake_pad)
 871                         gst_object_unref(fake_pad);
 872
 873                 __gst_create_audio_only_pipeline(data, caps);
 874         } else {
 875                 gst_handle->is_valid_container = false;
 876                 MD_E("Not supported container %s\n", type);
 877         }
 878
 879         g_free(type);
 880         MEDIADEMUXER_FLEAVE();
 881         return;
 882
 883 ERROR:
 884         gst_handle->is_valid_container = false;
 885         if (type)
 886                 g_free(type);
 887         if (gst_handle->demux)
 888                 gst_element_set_locked_state(gst_handle->demux, FALSE);
 889         if (pad)
 890                 gst_object_unref(pad);
 891         if (demuxer_pad)
 892                 gst_object_unref(demuxer_pad);
 893         if (fake_pad)
 894                 gst_object_unref(fake_pad);
 895         MEDIADEMUXER_FLEAVE();
 896         return;
 897 }
 898
 899 static int _gst_create_pipeline(mdgst_handle_t *gst_handle, char *uri)
 900 {
 901         MEDIADEMUXER_FENTER();
 902         int ret = MD_ERROR_NONE;
 903         GstBus *bus = NULL;
 904         char *path = NULL;
 905 #ifdef TIZEN_FEATURE_STREAMING
 906         int remote_streaming = 0;
 907 #endif
 908         GstState element_state = GST_STATE_VOID_PENDING;
 909         GstState element_pending_state = GST_STATE_VOID_PENDING;
 910
 911         /* Initialize GStreamer */
 912         /* Note: Replace the arguments of gst_init to pass the command line args to GStreamer. */
 913         gst_init(NULL, NULL);
 914
 915         /* Create the empty pipeline */
 916         gst_handle->pipeline = gst_pipeline_new("Demuxer Gst pipeline");
 917         if (!gst_handle->pipeline) {
 918                 MD_E("pipeline create fail");
 919                 ret = MD_ERROR;
 920                 goto ERROR;
 921         }
 922
 923         /* Create the elements */
 924         if ((path = strstr(uri, "http://"))) {
 925 #ifdef TIZEN_FEATURE_STREAMING
 926                 gst_handle->filesrc  = gst_element_factory_make("souphttpsrc", NULL);
 927                 remote_streaming = 1;
 928                 MD_I("Source is http stream. \n");
 929 #else
 930                 MD_I("Source is http stream. Didn't support streaming\n");
 931                 goto ERROR;
 932 #endif
 933         } else {
 934                 gst_handle->filesrc = gst_element_factory_make("filesrc", NULL);
 935                 MD_I("Source is file stream \n");
 936         }
 937         if (!gst_handle->filesrc) {
 938                 MD_E("filesrc creation failed");
 939                 ret = MD_ERROR;
 940                 goto ERROR;
 941         }
 942
 943         /* Modify the source's properties */
 944 #ifdef TIZEN_FEATURE_STREAMING
 945         if (remote_streaming == 1)
 946                 g_object_set(G_OBJECT(gst_handle->filesrc), "location", uri, NULL);
 947         else
 948 #endif
 949                 g_object_set(G_OBJECT(gst_handle->filesrc), "location", uri + 7, NULL);
 950         gst_handle->typefind = gst_element_factory_make("typefind", NULL);
 951         if (!gst_handle->typefind) {
 952                 MD_E("typefind creation failed");
 953                 ret = MD_ERROR;
 954                 goto ERROR;
 955         }
 956         g_signal_connect(gst_handle->typefind, "have-type",
 957                                         G_CALLBACK(__gst_cb_typefind), gst_handle);
 958         gst_handle->fakesink = gst_element_factory_make("fakesink", NULL);
 959         if (!gst_handle->fakesink) {
 960                 MD_E("fakesink creation failed");
 961                 ret = MD_ERROR;
 962                 goto ERROR;
 963         }
 964
 965         /* Build the pipeline */
 966         gst_bin_add_many(GST_BIN(gst_handle->pipeline),
 967                                                 gst_handle->filesrc,
 968                                                 gst_handle->typefind,
 969                                                 gst_handle->fakesink,
 970                                                 NULL);
 971         gst_element_link_many(gst_handle->filesrc,
 972                                                         gst_handle->typefind,
 973                                                         gst_handle->fakesink,
 974                                                         NULL);
 975
 976         /* connect signals, bus watcher */
 977         bus = gst_pipeline_get_bus(GST_PIPELINE(gst_handle->pipeline));
 978         gst_handle->bus_watch_id = gst_bus_add_watch(bus, __gst_bus_call, gst_handle);
 979         gst_handle->thread_default = g_main_context_get_thread_default();
 980         gst_object_unref(GST_OBJECT(bus));
 981
 982         /* set pipeline state to PAUSED */
 983         MEDIADEMUXER_SET_STATE(gst_handle->pipeline, GST_STATE_PAUSED, ERROR);
 984
 985         if (gst_element_get_state(gst_handle->pipeline, &element_state, &element_pending_state, 1 * GST_SECOND)
 986                 == GST_STATE_CHANGE_FAILURE) {
 987                 MD_E(" [%s] state : %s   pending : %s \n",
 988                         GST_ELEMENT_NAME(gst_handle->pipeline),
 989                         gst_element_state_get_name(element_state),
 990                         gst_element_state_get_name(element_pending_state));
 991                 ret = MD_ERROR;
 992                 goto ERROR;
 993         }
 994
 995         if (gst_handle->is_prepared != true) {
 996                 MD_E("Error occure");
 997                 ret = MD_ERROR;
 998                 goto ERROR;
 999         }
1000
1001         MEDIADEMUXER_FLEAVE();
1002         return ret;
1003 ERROR:
1004         MEDIADEMUXER_FLEAVE();
1005         return ret;
1006 }
1007
1008 static int gst_demuxer_prepare(MMHandleType pHandle, char *uri)
1009 {
1010         MEDIADEMUXER_FENTER();
1011         int ret = MD_ERROR_NONE;
1012         MEDIADEMUXER_CHECK_NULL(pHandle);
1013         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1014
1015         MD_I("gst_demuxer_prepare Creating pipeline %p", new_mediademuxer);
1016         ret = _gst_create_pipeline(new_mediademuxer, uri);
1017         if (ret != MD_ERROR_NONE) {
1018                 MD_E("_gst_create_pipeline() failed. returned %d\n", ret);
1019                 goto ERROR;
1020         }
1021         MEDIADEMUXER_FLEAVE();
1022         return ret;
1023 ERROR:
1024         MEDIADEMUXER_FLEAVE();
1025         return ret;
1026 }
1027
1028 static int gst_demuxer_get_data_count(MMHandleType pHandle, int *count)
1029 {
1030         MEDIADEMUXER_FENTER();
1031         int ret = MD_ERROR_NONE;
1032         MEDIADEMUXER_CHECK_NULL(pHandle);
1033         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1034
1035         *count = (new_mediademuxer->info).num_video_track +
1036                         (new_mediademuxer->info).num_audio_track +
1037                         (new_mediademuxer->info).num_subtitle_track +
1038                         (new_mediademuxer->info).num_other_track;
1039         MEDIADEMUXER_FLEAVE();
1040         return ret;
1041 }
1042
1043 int _gst_set_appsink(track *temp, int index, int loop)
1044 {
1045         MEDIADEMUXER_FENTER();
1046         int ret = MD_ERROR_NONE;
1047         int count = 0;
1048
1049         while (count != index) {
1050                 temp = temp->next;
1051                 count++;
1052         }
1053         gst_app_sink_set_max_buffers((GstAppSink *)(temp->appsink), (guint) MAX_APP_BUFFER);
1054         gst_app_sink_set_drop((GstAppSink *)(temp->appsink), false);
1055         gst_app_sink_set_wait_on_eos((GstAppSink *)(temp->appsink), true);
1056         MEDIADEMUXER_FLEAVE();
1057         return ret;
1058 }
1059
1060 static int gst_demuxer_set_track(MMHandleType pHandle, int track)
1061 {
1062         MEDIADEMUXER_FENTER();
1063         int ret = MD_ERROR_NONE;
1064         MEDIADEMUXER_CHECK_NULL(pHandle);
1065         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1066
1067         MD_I("total_tracks (%d) :: selected  track (%d)", new_mediademuxer->total_tracks, track);
1068         if (track >= new_mediademuxer->total_tracks || track < 0) {
1069                 MD_E("total_tracks is less then selected track, So not support this track");
1070                 ret = MD_ERROR_INVALID_ARGUMENT;
1071                 goto ERROR;
1072         }
1073         new_mediademuxer->selected_tracks[track] = true;
1074         _gst_set_appsink((((mdgst_handle_t *)pHandle)->info).head, track,
1075                                         new_mediademuxer->total_tracks);
1076         MEDIADEMUXER_FLEAVE();
1077         return MD_ERROR_NONE;
1078 ERROR:
1079         MEDIADEMUXER_FLEAVE();
1080         return ret;
1081 }
1082
1083 static int _gst_unlink_unselected_track(track *temp, int index)
1084 {
1085         MEDIADEMUXER_FENTER();
1086         int ret = MD_ERROR_NONE;
1087         int count = 0;
1088         GstPad *queue_sink_pad = NULL;
1089         while (count != index) {
1090                 temp = temp->next;
1091                 count++;
1092         }
1093         queue_sink_pad = gst_element_get_static_pad(temp->queue, "sink");
1094         if (!queue_sink_pad) {
1095                 MD_E("queue_sink_pad of appsink not avaible\n");
1096                 return MD_ERROR;
1097         }
1098         if (gst_pad_unlink(temp->pad, queue_sink_pad) != TRUE)
1099                 MD_W("demuxer is already unlinked from queue for track %d\n", index);
1100
1101         gst_object_unref(queue_sink_pad);
1102         MEDIADEMUXER_FLEAVE();
1103         return ret;
1104 }
1105
1106 static int gst_demuxer_start(MMHandleType pHandle)
1107 {
1108         MEDIADEMUXER_FENTER();
1109         int ret = MD_ERROR_NONE;
1110         MEDIADEMUXER_CHECK_NULL(pHandle);
1111         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1112
1113         int indx;
1114         for (indx = 0; indx < gst_handle->total_tracks; indx++) {
1115                 MD_I("track indx[%d] is marked as [%d]. (0- not selected, 1= selected)\n",
1116                         indx, gst_handle->selected_tracks[indx]);
1117                 /*
1118                 if (gst_handle->selected_tracks[indx] ==  false)
1119                         _gst_demuxer_unset(pHandle, indx);
1120                 */
1121                 if (gst_handle->selected_tracks[indx] != true) {
1122                         if (_gst_unlink_unselected_track((((mdgst_handle_t *)pHandle)->info).head, indx) != MD_ERROR_NONE) {
1123                                 MD_E("Failed to unlink unselected tracks\n");
1124                                 ret = MD_INTERNAL_ERROR;
1125                                 goto ERROR;
1126                         }
1127                 }
1128
1129         }
1130
1131         track_info *head_track = &(gst_handle->info);
1132         MD_I("Total Audio track=%d, Video track=%d, text track=%d\n",
1133                         head_track->num_audio_track, head_track->num_video_track,
1134                         head_track->num_subtitle_track);
1135
1136         track *temp = head_track->head;
1137         indx = 0;
1138         while (temp) {
1139                 MD_I("Got one element %p\n", temp->appsink);
1140                 if (gst_element_set_state(temp->appsink, GST_STATE_PLAYING) ==
1141                         GST_STATE_CHANGE_FAILURE) {
1142                         MD_E("Failed to set into PLAYING state");
1143                         ret = MD_INTERNAL_ERROR;
1144                         goto ERROR;
1145                 }
1146                 MD_I("set the state to playing\n");
1147                 indx++;
1148                 if (temp->next) {
1149                         track *next = temp->next;
1150                         temp = next;
1151                 } else {
1152                         temp = NULL;
1153                 }
1154         }
1155
1156         MD_I("gst_demuxer_start pipeine %p", gst_handle);
1157         MEDIADEMUXER_FLEAVE();
1158         return ret;
1159 ERROR:
1160         MEDIADEMUXER_FLEAVE();
1161         return ret;
1162 }
1163
1164 int _set_mime_text(media_format_h format, track *head)
1165 {
1166         MEDIADEMUXER_FENTER();
1167         int ret = MD_ERROR_NONE;
1168         GstStructure *struc = NULL;
1169         struc = gst_caps_get_structure(head->caps, 0);
1170         if (!struc) {
1171                 MD_E("cannot get structure from caps.\n");
1172                 goto ERROR;
1173         }
1174         if (gst_structure_has_name(struc, "text/x-raw")) {
1175                 if (media_format_set_text_mime(format, MEDIA_FORMAT_TEXT_MP4))
1176                         goto ERROR;
1177         } else {
1178                 MD_I("Text mime not supported so far\n");
1179                 goto ERROR;
1180         }
1181
1182         MEDIADEMUXER_FLEAVE();
1183         return ret;
1184 ERROR:
1185         MEDIADEMUXER_FLEAVE();
1186         return MD_ERROR;
1187 }
1188
1189 int _set_mime_video(media_format_h format, track *head)
1190 {
1191         MEDIADEMUXER_FENTER();
1192         int ret = MD_ERROR_NONE;
1193         GstStructure *struc = NULL;
1194         int src_width;
1195         int src_height;
1196         int frame_rate_numerator = 0;
1197         int frame_rate_denominator = 0;
1198         int frame_rate = 0;
1199         media_format_mimetype_e mime_type = MEDIA_FORMAT_MAX;
1200         struc = gst_caps_get_structure(head->caps, 0);
1201         if (!struc) {
1202                 MD_E("cannot get structure from caps.\n");
1203                 goto ERROR;
1204         }
1205         if (gst_structure_has_name(struc, "video/x-h264")) {
1206                 mime_type = MEDIA_FORMAT_H264_SP;
1207         } else if (gst_structure_has_name(struc, "video/x-h263")) {
1208                 mime_type = MEDIA_FORMAT_H263;
1209         } else if (gst_structure_has_name(struc, "video/mpeg")) {
1210                 mime_type = MEDIA_FORMAT_MPEG4_SP;
1211         } else {
1212                 MD_W("Video mime (%s) not supported so far\n", gst_structure_get_name(struc));
1213                 goto ERROR;
1214         }
1215         if (media_format_set_video_mime(format, mime_type)) {
1216                 MD_E("Unable to set video mime type (%x)\n", mime_type);
1217                 goto ERROR;
1218         }
1219         gst_structure_get_int(struc, "width", &src_width);
1220         gst_structure_get_int(struc, "height", &src_height);
1221         if (media_format_set_video_width(format, src_width)) {
1222                 MD_E("Unable to set video width\n");
1223                 goto ERROR;
1224         }
1225         if (media_format_set_video_height(format, src_height)) {
1226                 MD_E("Unable to set video height\n");
1227                 goto ERROR;
1228         }
1229         gst_structure_get_fraction(struc, "framerate",  &frame_rate_numerator, &frame_rate_denominator);
1230
1231         /* Round off the framerate */
1232         if (frame_rate_denominator)
1233                 frame_rate = (int)floor(((gdouble)frame_rate_numerator / frame_rate_denominator) + 0.5);
1234
1235         MD_I("set frame rate %d", frame_rate);
1236         if (media_format_set_video_frame_rate(format, frame_rate)) {
1237                 MD_E("Unable to set video frame rate\n");
1238                 goto ERROR;
1239         }
1240         MEDIADEMUXER_FLEAVE();
1241         return ret;
1242 ERROR:
1243         MEDIADEMUXER_FLEAVE();
1244         return MD_ERROR;
1245 }
1246
1247 int _set_mime_audio(media_format_h format, track *head)
1248 {
1249         MEDIADEMUXER_FENTER();
1250         int ret = MD_ERROR_NONE;
1251         GstStructure *struc = NULL;
1252         int rate = 0;
1253         int bit = 0;
1254         int channels = 0;
1255         int id3_flag = 0;
1256         const gchar *stream_format;
1257         media_format_mimetype_e mime_type = MEDIA_FORMAT_MAX;
1258
1259         struc = gst_caps_get_structure(head->caps, 0);
1260         if (!struc) {
1261                 MD_E("cannot get structure from caps.\n");
1262                 goto ERROR;
1263         }
1264
1265         if (gst_structure_has_name(struc, "application/x-id3"))
1266                 id3_flag = 1;
1267         if (gst_structure_has_name(struc, "audio/mpeg") || id3_flag) {
1268                 gint mpegversion;
1269                 int layer;
1270                 gst_structure_get_int(struc, "mpegversion", &mpegversion);
1271                 if (mpegversion == 4 || mpegversion == 2) {
1272                         mime_type = MEDIA_FORMAT_AAC_LC;
1273                         if (media_format_set_audio_mime(format, mime_type))
1274                                 goto ERROR;
1275                         stream_format = gst_structure_get_string(struc, "stream-format");
1276
1277                         if (strncmp(stream_format, "adts", 4) == 0)
1278                                 media_format_set_audio_aac_type(format, 1);
1279                         else
1280                                 media_format_set_audio_aac_type(format, 0);
1281
1282                 } else if (mpegversion == 1 || id3_flag) {
1283                         gst_structure_get_int(struc, "layer", &layer);
1284                         if ((layer == 3) || (id3_flag == 1)) {
1285                                 mime_type = MEDIA_FORMAT_MP3;
1286                         } else {
1287                                 MD_I("No Support for MPEG%d Layer %d media\n", mpegversion, layer);
1288                                 goto ERROR;
1289                         }
1290                 }
1291         } else if (gst_structure_has_name(struc, "audio/x-amr-nb-sh") ||
1292                 gst_structure_has_name(struc, "audio/x-amr-wb-sh")) {
1293                 if (gst_structure_has_name(struc, "audio/x-amr-nb-sh")) {
1294                         mime_type = MEDIA_FORMAT_AMR_NB;
1295                         rate = 8000;
1296                 } else {
1297                         mime_type = MEDIA_FORMAT_AMR_WB;
1298                         rate = 16000;
1299                 }
1300         } else if (gst_structure_has_name(struc, "audio/AMR")) {
1301                 mime_type = MEDIA_FORMAT_AMR_NB;
1302         } else if (gst_structure_has_name(struc, "audio/AMR-WB")) {
1303                 mime_type = MEDIA_FORMAT_AMR_WB;
1304         } else if (gst_structure_has_name(struc, "audio/x-wav")) {
1305                 mime_type = MEDIA_FORMAT_PCM;
1306         } else if (gst_structure_has_name(struc, "audio/x-flac")) {
1307                 mime_type = MEDIA_FORMAT_FLAC;
1308         } else if (gst_structure_has_name(struc, "audio/x-vorbis")) {
1309                 mime_type = MEDIA_FORMAT_VORBIS;
1310         } else {
1311                 MD_W("Audio mime (%s) not supported so far\n", gst_structure_get_name(struc));
1312                 goto ERROR;
1313         }
1314         if (media_format_set_audio_mime(format, mime_type))
1315                 goto ERROR;
1316         gst_structure_get_int(struc, "channels", &channels);
1317         if (channels == 0) {    /* default */
1318                 if (mime_type == MEDIA_FORMAT_AMR_NB || mime_type == MEDIA_FORMAT_AMR_WB)
1319                         channels = 1;
1320                 else
1321                         channels = 2;
1322         }
1323         if (media_format_set_audio_channel(format, channels))
1324                 goto ERROR;
1325         if (rate == 0)
1326                 gst_structure_get_int(struc, "rate", &rate);
1327         if (rate == 0)
1328                 rate = 44100;   /* default */
1329         if (media_format_set_audio_samplerate(format, rate))
1330                 goto ERROR;
1331         gst_structure_get_int(struc, "bit", &bit);
1332         if (bit == 0)
1333                 bit = 16;       /* default */
1334         if (media_format_set_audio_bit(format, bit))
1335                 goto ERROR;
1336         MEDIADEMUXER_FLEAVE();
1337         return ret;
1338 ERROR:
1339         MEDIADEMUXER_FLEAVE();
1340         return MD_ERROR;
1341 }
1342
1343 static int gst_demuxer_get_track_info(MMHandleType pHandle,
1344                                                         media_format_h *format, int index)
1345 {
1346         MEDIADEMUXER_FENTER();
1347         int ret = MD_ERROR_NONE;
1348         MEDIADEMUXER_CHECK_NULL(pHandle);
1349         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1350
1351         track *temp = NULL;
1352         int loop;
1353         int count = 0;
1354         temp = (new_mediademuxer->info).head;
1355         loop = (new_mediademuxer->info).num_video_track +
1356                         (new_mediademuxer->info).num_audio_track +
1357                         (new_mediademuxer->info).num_subtitle_track +
1358                         (new_mediademuxer->info).num_other_track;
1359         if (index >= loop || index < 0) {
1360                 MD_E("total tracks(loop) is less then selected track(index), So not support this track");
1361                 ret = MD_ERROR;
1362                 goto ERROR;
1363         }
1364
1365         while (count != index) {
1366                 temp = temp->next;
1367                 count++;
1368         }
1369         if (temp->format != NULL) {
1370                 ret = media_format_ref(temp->format);
1371                 if (ret != MEDIA_FORMAT_ERROR_NONE) {
1372                         MD_E("Mediaformat reference count increment failed. returned %d\n", ret);
1373                         ret = MD_INTERNAL_ERROR;
1374                         goto ERROR;
1375                 }
1376                 ret = media_format_make_writable(temp->format, format); /* copy the content */
1377                 if (ret != MEDIA_FORMAT_ERROR_NONE) {
1378                         MD_E("Mediaformat create copy failed. returned %d\n", ret);
1379                         media_format_unref(temp->format);
1380                         ret = MD_INTERNAL_ERROR;
1381                         goto ERROR;
1382                 }
1383                 MEDIADEMUXER_FLEAVE();
1384                 return ret;
1385         }
1386         ret = media_format_create(&(temp->format));
1387         if (ret != MEDIA_FORMAT_ERROR_NONE) {
1388                 MD_E("Mediaformat creation failed. returned %d\n", ret);
1389                 ret = MD_INTERNAL_ERROR;
1390                 goto ERROR;
1391         }
1392
1393         MD_I("CAPS for selected track [%d] is [%s]\n", index, temp->caps_string);
1394         MD_I("format ptr[%p]\n", temp->format);
1395         if (temp->caps_string[0] == 'a') {
1396                 MD_I("Setting for Audio \n");
1397                 _set_mime_audio(temp->format, temp);
1398         } else if (temp->caps_string[0] == 'v') {
1399                 MD_I("Setting for Video \n");
1400                 _set_mime_video(temp->format, temp);
1401         } else if (temp->caps_string[0] == 't') {
1402                 MD_I("Setting for Subtitle\n");
1403                 _set_mime_text(temp->format, temp);
1404         } else {
1405                 MD_W("Not supported so far (except audio, video and subtitle)\n");
1406         }
1407
1408         ret = media_format_ref(temp->format);   /* increment the ref to retain the original content */
1409         if (ret != MEDIA_FORMAT_ERROR_NONE) {
1410                 MD_E("Mediaformat reference count increment failed. returned %d\n", ret);
1411                 ret = MD_INTERNAL_ERROR;
1412                 goto ERROR;
1413         }
1414         ret = media_format_make_writable(temp->format, format); /* copy the content */
1415         if (ret != MEDIA_FORMAT_ERROR_NONE) {
1416                 MD_E("Mediaformat create copy failed. returned %d\n", ret);
1417                 media_format_unref(temp->format);
1418                 ret = MD_INTERNAL_ERROR;
1419                 goto ERROR;
1420         }
1421         MEDIADEMUXER_FLEAVE();
1422         return ret;
1423 ERROR:
1424         MEDIADEMUXER_FLEAVE();
1425         return ret;
1426 }
1427
1428 static int _gst_copy_buf_to_media_packet(media_packet_h out_pkt,
1429                                                         GstBuffer *buffer, GstBuffer *codec_data)
1430 {
1431         MEDIADEMUXER_FENTER();
1432         int ret = MD_ERROR_NONE;
1433         MEDIADEMUXER_CHECK_NULL(out_pkt);
1434         void *pkt_data;
1435         uint64_t size;
1436         GstMapInfo map;
1437
1438         if (!gst_buffer_map(buffer, &map, GST_MAP_READ)) {
1439                 MD_E("gst_buffer_map failed\n");
1440                 ret = MD_ERROR_UNKNOWN;
1441                 goto ERROR;
1442         }
1443         /* copy data */
1444         media_packet_get_buffer_size(out_pkt, &size);
1445         MD_I("Media packet Buffer capacity: %llu GST Buffer size = %d\n", size, map.size);
1446         if (size < (uint64_t)map.size) {
1447                 MD_W("Media packet Buffer capacity[%llu] is \
1448                         less than the GST Buffer size[%d]. Resizing...\n", size, map.size);
1449                 ret = media_packet_set_buffer_size(out_pkt, (uint64_t)map.size);
1450                 media_packet_get_buffer_size(out_pkt, &size);
1451                 MD_I("Media packet Buffer NEW  capacity: %llu \n", size);
1452         }
1453         if (media_packet_get_buffer_data_ptr(out_pkt, &pkt_data)) {
1454                 MD_E("unable to get the buffer pointer from media_packet_get_buffer_data_ptr\n");
1455                 ret = MD_ERROR_UNKNOWN;
1456                 goto ERROR;
1457         }
1458         memcpy((char *)pkt_data, map.data, map.size);
1459         if (media_packet_set_pts(out_pkt, GST_BUFFER_PTS(buffer))) {
1460                 MD_E("unable to set the pts\n");
1461                 ret = MD_ERROR_UNKNOWN;
1462                 goto ERROR;
1463         }
1464         if (media_packet_set_dts(out_pkt, GST_BUFFER_DTS(buffer))) {
1465                 MD_E("unable to set the dts\n");
1466                 ret = MD_ERROR_UNKNOWN;
1467                 goto ERROR;
1468         }
1469         if (media_packet_set_duration(out_pkt, GST_BUFFER_DURATION(buffer))) {
1470                 MD_E("unable to set the duration\n");
1471                 ret = MD_ERROR_UNKNOWN;
1472                 goto ERROR;
1473         }
1474         if (media_packet_set_buffer_size(out_pkt, gst_buffer_get_size(buffer))) {
1475                 MD_E("unable to set the buffer size\n");
1476                 ret = MD_ERROR_UNKNOWN;
1477                 goto ERROR;
1478         }
1479         if (!GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT)) {
1480                 if (media_packet_set_flags(out_pkt, MEDIA_PACKET_SYNC_FRAME)) {
1481                         MD_E("unable to set the buffer flag\n");
1482                         ret = MD_ERROR_UNKNOWN;
1483                         goto ERROR;
1484                 }
1485         }
1486         /* set codec data into media packet */
1487         if (codec_data) {
1488                 GstMapInfo codec_data_map;
1489                 if (!gst_buffer_map(codec_data, &codec_data_map, GST_MAP_READ)) {
1490                         MD_E("codec data buffer map failed\n");
1491                         ret = MD_ERROR_UNKNOWN;
1492                         goto ERROR;
1493                 }
1494                 if (media_packet_set_codec_data(out_pkt, (void *)codec_data_map.data,
1495                         (unsigned int)codec_data_map.size)) {
1496                         MD_E("unable to set the codec data\n");
1497                         ret = MD_ERROR_UNKNOWN;
1498                         gst_buffer_unmap(codec_data, &codec_data_map);
1499                         goto ERROR;
1500                 }
1501                 gst_buffer_unmap(codec_data, &codec_data_map);
1502
1503                 media_buffer_flags_e flags;
1504                 media_packet_get_flags(out_pkt, &flags);
1505                 media_packet_set_flags(out_pkt, flags | MEDIA_PACKET_CODEC_CONFIG);
1506         }
1507 ERROR:
1508         gst_buffer_unmap(buffer, &map);
1509         MEDIADEMUXER_FLEAVE();
1510         return ret;
1511 }
1512
1513 static int _gst_demuxer_create_eos_packet(media_format_h fmt, media_packet_h *outbuf)
1514 {
1515         media_packet_h mediabuf = NULL;
1516         int ret = MD_ERROR_NONE;
1517
1518         MEDIADEMUXER_FENTER();
1519         if (media_packet_create_alloc(fmt, NULL, NULL, &mediabuf)) {
1520                 MD_E("media_packet_create_alloc failed\n");
1521                 ret = MD_ERROR;
1522                 goto ERROR;
1523         }
1524
1525         if (media_packet_set_flags(mediabuf, MEDIA_PACKET_END_OF_STREAM)) {
1526                 MD_E("unable to set EOS flag\n");
1527                 ret = MD_ERROR_UNKNOWN;
1528                 goto ERROR;
1529         }
1530
1531         *outbuf = mediabuf;
1532         MEDIADEMUXER_FLEAVE();
1533
1534         return ret;
1535 ERROR:
1536         if (mediabuf)
1537                 media_packet_destroy(mediabuf);
1538         *outbuf = NULL;
1539         MEDIADEMUXER_FLEAVE();
1540         return ret;
1541 }
1542
1543 static int gst_demuxer_read_sample(MMHandleType pHandle,
1544                                                 media_packet_h *outbuf, int track_indx)
1545 {
1546         MEDIADEMUXER_FENTER();
1547         int ret = MD_ERROR_NONE;
1548         MEDIADEMUXER_CHECK_NULL(pHandle);
1549         mdgst_handle_t *demuxer = (mdgst_handle_t *)pHandle;
1550
1551         media_packet_h mediabuf = NULL;
1552         int indx = 0;
1553
1554         track *atrack = demuxer->info.head;
1555         if ((demuxer->selected_tracks)[track_indx] == false) {
1556                 MD_E("Track Not selected\n");
1557                 ret = MD_ERROR;
1558                 goto ERROR;
1559         }
1560         while (atrack) {
1561                 if (indx == track_indx)  /* Got the requird track details */
1562                         break;
1563                 if (atrack->next) {
1564                         track *next = atrack->next;
1565                         atrack = next;
1566                 } else {
1567                         MD_E("Invalid track Index\n");
1568                         ret = MD_ERROR_INVALID_ARGUMENT;
1569                         goto ERROR;
1570                 }
1571                 indx++;
1572         }
1573
1574         if (!atrack) {
1575                 MD_E("atrack is NULL\n");
1576                 goto ERROR;
1577         }
1578
1579         if (indx != track_indx) {
1580                 MD_E("Invalid track Index\n");
1581                 ret = MD_ERROR_INVALID_ARGUMENT;
1582                 goto ERROR;
1583         }
1584         GstElement *sink = atrack->appsink;
1585         GstSample *sample = NULL;
1586
1587         sample = gst_app_sink_pull_sample((GstAppSink *) sink);
1588         if (sample == NULL) {
1589                 if (gst_app_sink_is_eos((GstAppSink *) sink)) {
1590                         MD_W("End of stream (EOS) reached, triggering the eos callback\n");
1591                         ret = MD_ERROR_NONE;
1592                         *outbuf = NULL;
1593                         __gst_eos_callback(track_indx, demuxer);
1594
1595                         //Make EOS packet
1596                         _gst_demuxer_create_eos_packet(atrack->format, outbuf);
1597                         return ret;
1598                 } else {
1599                         MD_E("gst_demuxer_read_sample failed\n");
1600                         *outbuf = NULL;
1601                         ret = MD_ERROR_UNKNOWN;
1602                         return ret;
1603                 }
1604         }
1605
1606         if (media_packet_create_alloc(atrack->format, NULL, NULL, &mediabuf)) {
1607                 MD_E("media_packet_create_alloc failed\n");
1608                 ret = MD_ERROR;
1609                 goto ERROR;
1610         }
1611
1612         GstBuffer *buffer = gst_sample_get_buffer(sample);
1613         if (buffer == NULL) {
1614                 MD_E("gst_sample_get_buffer returned NULL pointer\n");
1615                 ret = MD_ERROR_UNKNOWN;
1616                 goto ERROR;
1617         }
1618
1619         GstBuffer *codec_data_buffer = NULL;
1620         /* Need to Check : Only the first frame need set codec_data, what about Resolution changed instance ...*/
1621         if (atrack->need_codec_data) {
1622                 atrack->need_codec_data = FALSE;
1623                 /* Create the codec data and pass to _gst_copy_buf_to_media_packet() to add into the media packet */
1624                 GstStructure *structure = NULL;
1625                 const GValue *value = NULL;
1626
1627                 structure = gst_caps_get_structure(atrack->caps, 0);
1628                 /* get codec data from caps*/
1629                 value = gst_structure_get_value(structure, "codec_data");
1630                 if (value)
1631                         codec_data_buffer = gst_value_get_buffer(value);
1632         }
1633
1634         /* Fill the media_packet with proper information */
1635         ret = _gst_copy_buf_to_media_packet(mediabuf, buffer, codec_data_buffer);
1636         gst_sample_unref(sample);
1637         *outbuf = mediabuf;
1638
1639         MEDIADEMUXER_FLEAVE();
1640         return ret;
1641 ERROR:
1642         if (mediabuf)
1643                 media_packet_destroy(mediabuf);
1644         *outbuf = NULL;
1645         MEDIADEMUXER_FLEAVE();
1646         return ret;
1647 }
1648
1649 static int gst_demuxer_seek(MMHandleType pHandle, gint64 pos1)
1650 {
1651         MEDIADEMUXER_FENTER();
1652         MEDIADEMUXER_CHECK_NULL(pHandle);
1653         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1654
1655         gint64 pos = 0;
1656         gdouble rate = 1;
1657         track_info *head_track = &(gst_handle->info);
1658         track *temp = head_track->head;
1659         track *temp_track = head_track->head;
1660         int indx = 0;
1661         bool is_seek = FALSE;
1662
1663         /* Setting each appsink to paused state before seek */
1664         while (temp_track) {
1665                 if (gst_handle->selected_tracks[indx] == true) {
1666                         if (gst_element_set_state(temp_track->appsink, GST_STATE_PAUSED) == GST_STATE_CHANGE_FAILURE) {
1667                                 MD_E("Failed to set into PAUSED state");
1668                                 goto ERROR;
1669                         }
1670                         MD_I("set the state to paused\n");
1671                 }
1672                 indx++;
1673                 if (temp_track->next) {
1674                         track *next = temp_track->next;
1675                         temp_track = next;
1676                 } else {
1677                         temp_track = NULL;
1678                 }
1679         }
1680
1681         pos = pos1 * GST_MSECOND;
1682
1683         MD_I("NEW Time: %" GST_TIME_FORMAT, GST_TIME_ARGS(pos));
1684
1685         indx = 0;
1686         while (temp) {
1687                 MD_I("Got one element %p {%s}\n", temp->appsink, GST_ELEMENT_NAME(temp->appsink));
1688                 if (gst_handle->selected_tracks[indx] == true) {
1689                         temp->need_codec_data = TRUE;
1690
1691                         if (!is_seek) {
1692                                 if (!gst_element_seek(temp->appsink, rate, GST_FORMAT_TIME,
1693                                         GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT | GST_SEEK_FLAG_SNAP_BEFORE,
1694                                         GST_SEEK_TYPE_SET, pos, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE)) {
1695                                         MD_E("Seek failed!\n");
1696                                         goto ERROR;
1697                                 }
1698                                 is_seek = TRUE;
1699                         }
1700                         MD_I("Seek success...setting appsink to playing state\n");
1701                         if (gst_element_set_state(temp->appsink, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
1702                                 MD_E("Failed to set into PLAYING state");
1703                                 goto ERROR;
1704                         }
1705                 }
1706                 indx++;
1707                 if (temp->next) {
1708                         track *next = temp->next;
1709                         temp = next;
1710                 } else {
1711                         temp = NULL;
1712                 }
1713         }
1714
1715         MEDIADEMUXER_FLEAVE();
1716         return MD_ERROR_NONE;
1717 ERROR:
1718         MEDIADEMUXER_FLEAVE();
1719         return MD_ERROR;
1720 }
1721
1722 int _gst_unset_appsink(track *temp, int index, int loop)
1723 {
1724         MEDIADEMUXER_FENTER();
1725         int ret = MD_ERROR_NONE;
1726         int count = 0;
1727
1728         while (count != index) {
1729                 temp = temp->next;
1730                 count++;
1731         }
1732         gst_app_sink_set_max_buffers((GstAppSink *)(temp->appsink), (guint)0);
1733         gst_app_sink_set_drop((GstAppSink *)(temp->appsink), true);
1734         gst_app_sink_set_wait_on_eos((GstAppSink *)(temp->appsink), false);
1735         MEDIADEMUXER_FLEAVE();
1736         return ret;
1737 }
1738
1739 static int gst_demuxer_unset_track(MMHandleType pHandle, int track)
1740 {
1741         MEDIADEMUXER_FENTER();
1742         int ret = MD_ERROR_NONE;
1743         MEDIADEMUXER_CHECK_NULL(pHandle);
1744         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1745
1746         if (track >= new_mediademuxer->total_tracks || track < 0) {
1747                 MD_E("total tracks is less then unselected track, So not support this track");
1748                 ret = MD_ERROR_INVALID_ARGUMENT;
1749                 goto ERROR;
1750         }
1751         new_mediademuxer->selected_tracks[track] = false;
1752         _gst_unset_appsink((((mdgst_handle_t *)pHandle)->info).head, track,
1753                                         new_mediademuxer->total_tracks);
1754         MEDIADEMUXER_FLEAVE();
1755         return ret;
1756 ERROR:
1757         MEDIADEMUXER_FLEAVE();
1758         return ret;
1759 }
1760
1761 static int gst_demuxer_stop(MMHandleType pHandle)
1762 {
1763         MEDIADEMUXER_FENTER();
1764         int ret = MD_ERROR_NONE;
1765         MEDIADEMUXER_CHECK_NULL(pHandle);
1766         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1767
1768         MD_I("gst_demuxer_stop pipeine %p", gst_handle);
1769         if (gst_element_set_state(gst_handle->pipeline, GST_STATE_PAUSED) ==
1770             GST_STATE_CHANGE_FAILURE) {
1771                 MD_E("Failed to set into PAUSE state");
1772                 ret = MD_INTERNAL_ERROR;
1773                 goto ERROR;
1774         }
1775         MEDIADEMUXER_FLEAVE();
1776         return ret;
1777 ERROR:
1778         MEDIADEMUXER_FLEAVE();
1779         return ret;
1780 }
1781
1782 void  _gst_clear_struct(mdgst_handle_t *gst_handle)
1783 {
1784         MEDIADEMUXER_FENTER();
1785         MEDIADEMUXER_CHECK_NULL_VOID(gst_handle);
1786         if (gst_handle->selected_tracks) {
1787                 MD_I("Deallocating gst_handle->selected_tracks %p\n",
1788                      gst_handle->selected_tracks);
1789                 g_free(gst_handle->selected_tracks);
1790                 gst_handle->selected_tracks = NULL;
1791         }
1792         if ((gst_handle->info).head)
1793                 __gst_free_stuct(&(gst_handle->info).head);
1794         MEDIADEMUXER_FLEAVE();
1795 }
1796
1797 int _md_gst_destroy_pipeline(GstElement *pipeline)
1798 {
1799         MEDIADEMUXER_FENTER();
1800         int ret = MD_ERROR_NONE;
1801         if (pipeline)
1802                 MEDIADEMUXER_SET_STATE(pipeline, GST_STATE_NULL, ERROR);
1803         if (pipeline)
1804                 gst_object_unref(GST_OBJECT(pipeline));
1805         MEDIADEMUXER_FLEAVE();
1806         return ret;
1807 ERROR:
1808         if (pipeline)
1809                 gst_object_unref(GST_OBJECT(pipeline));
1810         MEDIADEMUXER_FLEAVE();
1811         return MD_ERROR;
1812 }
1813
1814 static int gst_demuxer_unprepare(MMHandleType pHandle)
1815 {
1816         MEDIADEMUXER_FENTER();
1817         int ret = MD_ERROR_NONE;
1818         MEDIADEMUXER_CHECK_NULL(pHandle);
1819         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1820
1821         /*Modification : Fix pipeline state change was block by appsink When EOS received and appsink also has many datas*/
1822         int indx = 0;
1823         track *atrack = gst_handle->info.head;
1824         while (atrack) {
1825                 if ((gst_handle->selected_tracks)[indx] == false) {
1826                         MD_I("Track [%d] Not selected\n", indx);
1827                 } else {
1828                         MD_I("Track [%d] to unset appsink...\n", indx);
1829                         gst_demuxer_unset_track(pHandle, indx);
1830                 }
1831                 if (atrack->next) {
1832                         track *next = atrack->next;
1833                         atrack = next;
1834                 } else {
1835                         break;
1836                 }
1837                 indx++;
1838         }
1839
1840         _gst_clear_struct(gst_handle);
1841         if (gst_handle->bus_watch_id) {
1842                 GSource *source = NULL;
1843                 source = g_main_context_find_source_by_id(gst_handle->thread_default, gst_handle->bus_watch_id);
1844                 if (source) {
1845                         g_source_destroy(source);
1846                         LOGD("Deallocation bus watch id");
1847                 }
1848         }
1849
1850         MD_I("gst_demuxer_stop pipeine %p\n", gst_handle->pipeline);
1851         if (_md_gst_destroy_pipeline(gst_handle->pipeline) != MD_ERROR_NONE) {
1852                 ret = MD_ERROR;
1853                 goto ERROR;
1854         }
1855         MEDIADEMUXER_FLEAVE();
1856         return ret;
1857 ERROR:
1858         MEDIADEMUXER_FLEAVE();
1859         return ret;
1860 }
1861
1862 static int gst_demuxer_destroy(MMHandleType pHandle)
1863 {
1864         MEDIADEMUXER_FENTER();
1865         int ret = MD_ERROR_NONE;
1866         MEDIADEMUXER_CHECK_NULL(pHandle);
1867         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1868
1869         MD_I("gst_demuxer_destroy deallocating new_mediademuxer:%p\n",
1870              new_mediademuxer);
1871         g_free(new_mediademuxer);
1872         MEDIADEMUXER_FLEAVE();
1873         return ret;
1874 }
1875
1876 int gst_set_error_cb(MMHandleType pHandle,
1877                         gst_error_cb callback, void *user_data)
1878 {
1879         MEDIADEMUXER_FENTER();
1880         int ret = MD_ERROR_NONE;
1881         MEDIADEMUXER_CHECK_NULL(pHandle);
1882         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1883
1884         if (gst_handle->user_cb[_GST_EVENT_TYPE_ERROR]) {
1885                 MD_E("Already set mediademuxer_error_cb\n");
1886                 ret = MD_ERROR_INVALID_ARGUMENT;
1887                 goto ERROR;
1888         } else {
1889                 if (!callback) {
1890                         MD_E("fail invaild argument (callback)\n");
1891                         ret = MD_ERROR_INVALID_ARGUMENT;
1892                         goto ERROR;
1893                 }
1894         }
1895
1896         MD_I("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
1897
1898         gst_handle->user_cb[_GST_EVENT_TYPE_ERROR] = (gst_error_cb)callback;
1899         gst_handle->user_data[_GST_EVENT_TYPE_ERROR] = user_data;
1900         MEDIADEMUXER_FLEAVE();
1901         return MD_ERROR_NONE;
1902 ERROR:
1903         MEDIADEMUXER_FLEAVE();
1904         return ret;
1905 }
1906
1907 int gst_set_eos_cb(MMHandleType pHandle, gst_eos_cb callback, void *user_data)
1908 {
1909         MEDIADEMUXER_FENTER();
1910         int ret = MD_ERROR_NONE;
1911         MEDIADEMUXER_CHECK_NULL(pHandle);
1912         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1913
1914         if (gst_handle->user_cb[_GST_EVENT_TYPE_EOS]) {
1915                 MD_E("Already set mediademuxer_eos_cb\n");
1916                 ret = MD_ERROR_INVALID_ARGUMENT;
1917                 goto ERROR;
1918         } else {
1919                 if (!callback) {
1920                         MD_E("fail invaild argument (callback)\n");
1921                         ret = MD_ERROR_INVALID_ARGUMENT;
1922                         goto ERROR;
1923                 }
1924         }
1925
1926         MD_I("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
1927         gst_handle->user_cb[_GST_EVENT_TYPE_EOS] = (gst_eos_cb)callback;
1928         gst_handle->user_data[_GST_EVENT_TYPE_EOS] = user_data;
1929         MEDIADEMUXER_FLEAVE();
1930         return MD_ERROR_NONE;
1931 ERROR:
1932         MEDIADEMUXER_FLEAVE();
1933         return ret;
1934 }
1935
1936 static int __gst_eos_callback(int track_num, void* user_data)
1937 {
1938         if (user_data == NULL) {
1939                 MD_E("Invalid argument");
1940                 return MD_ERROR;
1941         }
1942         mdgst_handle_t *gst_handle = (mdgst_handle_t *)user_data;
1943         if (gst_handle->user_cb[_GST_EVENT_TYPE_EOS])
1944                 ((gst_eos_cb)gst_handle->user_cb[_GST_EVENT_TYPE_EOS])(track_num,
1945                                         gst_handle->user_data[_GST_EVENT_TYPE_EOS]);
1946         else
1947                 MD_E("EOS received, but callback is not set!!!");
1948         return MD_ERROR_NONE;
1949 }