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
 703         if (!tmp) {
 704                 MD_I("trak is NULL\n");
 705                 MEDIADEMUXER_FLEAVE();
 706                 return;
 707         }
 708
 709         while (tmp->next)
 710                 tmp = tmp->next;
 711         if (!tmp || !tmp->caps_string) {
 712                 MD_I("trak or trak caps_string is NULL\n");
 713                 MEDIADEMUXER_FLEAVE();
 714                 return;
 715         }
 716         if (tmp->caps_string[0] == 'v') {
 717                 MD_I("found Video Pad\n");
 718                 (head_track->num_video_track)++;
 719         } else if (tmp->caps_string[0] == 'a') {
 720                 MD_I("found Audio Pad\n");
 721                 (head_track->num_audio_track)++;
 722         } else if (tmp->caps_string[0] == 's') {
 723                 MD_I("found subtitle(or Text) Pad\n");
 724                 (head_track->num_subtitle_track)++;
 725         } else {
 726                 MD_W("found Pad, caps: %s\n", tmp->caps_string);
 727                 (head_track->num_other_track)++;
 728         }
 729         MEDIADEMUXER_FLEAVE();
 730 }
 731
 732 static int __gst_create_audio_only_pipeline(gpointer data,  GstCaps *caps)
 733 {
 734         MEDIADEMUXER_FENTER();
 735         mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
 736         GstPad *pad = NULL;
 737         track_info *head_track = &(gst_handle->info);
 738
 739         gst_handle->is_valid_container = true;
 740
 741         pad = gst_element_get_static_pad(gst_handle->typefind, "src");
 742         if (!pad) {
 743                 MD_E("fail to get typefind src pad.\n");
 744                 goto ERROR;
 745         }
 746
 747         gst_handle->total_tracks++;
 748         if (__gst_add_track_info(pad, caps, &(head_track->head), gst_handle->pipeline) != MD_ERROR_NONE) {
 749                 MD_E("unable to added track info");
 750                 head_track->num_audio_track = 0;
 751                 head_track->num_video_track = 0;
 752                 head_track->num_subtitle_track = 0;
 753                 head_track->num_other_track = 0;
 754                 __gst_free_stuct(&(head_track->head));
 755                 goto ERROR;
 756         }
 757
 758         (head_track->num_audio_track)++;
 759
 760         /* unref pads */
 761         if (pad)
 762                 gst_object_unref(pad);
 763
 764         /* In the case of audio only, there is no gst_handle->demux. So we pass NULL */
 765         __gst_no_more_pad(NULL, data);
 766
 767         MEDIADEMUXER_FLEAVE();
 768         return MD_ERROR_NONE;
 769
 770 ERROR:
 771         gst_handle->is_valid_container = false;
 772
 773         if (pad)
 774                 gst_object_unref(pad);
 775
 776         MEDIADEMUXER_FLEAVE();
 777         return MD_ERROR;
 778 }
 779
 780 static void __gst_cb_typefind(GstElement *tf, guint probability,
 781                                         GstCaps *caps, gpointer data)
 782 {
 783         MEDIADEMUXER_FENTER();
 784         mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
 785         GstPad *pad = NULL;
 786         GstPad *demuxer_pad = NULL;
 787         GstPad *fake_pad = NULL;
 788         gchar *type = NULL;
 789         MEDIADEMUXER_CHECK_NULL_VOID(gst_handle);
 790         type = gst_caps_to_string(caps);
 791
 792         if (!type) {
 793                 MD_E("Fail to get caps string");
 794                 goto ERROR;
 795         }
 796
 797         MD_I("Media type %s found, probability %d%%\n", type, probability);
 798         if (strstr(type, "quicktime") || strstr(type, "audio/x-m4a") ||
 799                 strstr(type, "x-3gp") || strstr(type, "ogg") ||
 800                 strstr(type, "flv") || strstr(type, "x-msvideo")) {
 801                 gst_handle->is_valid_container = true;
 802                 if (strstr(type, "ogg"))
 803                         gst_handle->demux = gst_element_factory_make("oggdemux", NULL);
 804                 else if (strstr(type, "flv"))
 805                         gst_handle->demux = gst_element_factory_make("flvdemux", NULL);
 806                 else if (strstr(type, "x-msvideo"))
 807                         gst_handle->demux = gst_element_factory_make("avidemux", NULL);
 808                 else
 809                         gst_handle->demux = gst_element_factory_make("qtdemux", NULL);
 810
 811                 if (!gst_handle->demux) {
 812                         gst_handle->is_valid_container = false;
 813                         MD_E("factory not able to create qtdemux\n");
 814                         goto ERROR;
 815                 }
 816                 g_signal_connect(gst_handle->demux, "pad-added",
 817                                                 G_CALLBACK(__gst_on_pad_added), gst_handle);
 818                 g_signal_connect(gst_handle->demux, "no-more-pads",
 819                                                 G_CALLBACK(__gst_no_more_pad), gst_handle);
 820                 gst_element_set_locked_state(gst_handle->demux, TRUE);
 821                 if (!gst_bin_add(GST_BIN(gst_handle->pipeline), gst_handle->demux)) {
 822                         MD_E("fail add demuxer(%s) in pipeline",
 823                                 GST_ELEMENT_NAME(gst_handle->demux));
 824                         gst_object_unref(gst_handle->demux);
 825                         gst_handle->demux = NULL;
 826                         goto ERROR;
 827                 }
 828
 829                 pad = gst_element_get_static_pad(gst_handle->typefind, "src");
 830                 if (!pad) {
 831                         MD_E("fail to get typefind src pad.\n");
 832                         goto ERROR;
 833                 }
 834                 demuxer_pad = gst_element_get_static_pad(gst_handle->demux, "sink");
 835                 if (!demuxer_pad) {
 836                         MD_E("fail to get qtdemuc sink pad.\n");
 837                         goto ERROR;
 838                 }
 839                 fake_pad = gst_element_get_static_pad(gst_handle->fakesink, "sink");
 840                 if (!fake_pad) {
 841                         MD_E("fail to get fakesink sink pad.\n");
 842                         goto ERROR;
 843                 }
 844                 gst_pad_unlink(pad, fake_pad);
 845                 MEDIADEMUXER_LINK_PAD(pad, demuxer_pad, ERROR);
 846
 847                 MEDIADEMUXER_SYNC_STATE_WITH_PARENT(gst_handle->demux, ERROR);
 848                 gst_element_set_locked_state(gst_handle->demux, FALSE);
 849                 if (pad)
 850                         gst_object_unref(pad);
 851                 if (demuxer_pad)
 852                         gst_object_unref(demuxer_pad);
 853                 if (fake_pad)
 854                         gst_object_unref(fake_pad);
 855
 856         } else if ((strstr(type, "adts"))
 857                    || (strstr(type, "audio/mpeg"))
 858                    || (strstr(type, "audio/x-wav"))
 859                    || (strstr(type, "audio/x-flac"))
 860                    || (strstr(type, "application/x-id3"))
 861                    || (strstr(type, "audio/x-amr-nb-sh"))
 862                    || (strstr(type, "audio/x-amr-wb-sh"))) {
 863                 MD_I("Audio only format is found\n");
 864                 pad = gst_element_get_static_pad(gst_handle->typefind, "src");
 865                 if (!pad) {
 866                         MD_E("fail to get typefind src pad.\n");
 867                         goto ERROR;
 868                 }
 869                 fake_pad = gst_element_get_static_pad(gst_handle->fakesink, "sink");
 870                 if (!fake_pad) {
 871                         MD_E("fail to get fakesink sink pad.\n");
 872                         goto ERROR;
 873                 }
 874                 gst_pad_unlink(pad, fake_pad);
 875                 if (pad)
 876                         gst_object_unref(pad);
 877                 if (fake_pad)
 878                         gst_object_unref(fake_pad);
 879
 880                 __gst_create_audio_only_pipeline(data, caps);
 881         } else {
 882                 gst_handle->is_valid_container = false;
 883                 MD_E("Not supported container %s\n", type);
 884         }
 885
 886         g_free(type);
 887         MEDIADEMUXER_FLEAVE();
 888         return;
 889
 890 ERROR:
 891         gst_handle->is_valid_container = false;
 892         if (type)
 893                 g_free(type);
 894         if (gst_handle->demux)
 895                 gst_element_set_locked_state(gst_handle->demux, FALSE);
 896         if (pad)
 897                 gst_object_unref(pad);
 898         if (demuxer_pad)
 899                 gst_object_unref(demuxer_pad);
 900         if (fake_pad)
 901                 gst_object_unref(fake_pad);
 902         MEDIADEMUXER_FLEAVE();
 903         return;
 904 }
 905
 906 static int _gst_create_pipeline(mdgst_handle_t *gst_handle, char *uri)
 907 {
 908         MEDIADEMUXER_FENTER();
 909         int ret = MD_ERROR_NONE;
 910         GstBus *bus = NULL;
 911         char *path = NULL;
 912 #ifdef TIZEN_FEATURE_STREAMING
 913         int remote_streaming = 0;
 914 #endif
 915         GstState element_state = GST_STATE_VOID_PENDING;
 916         GstState element_pending_state = GST_STATE_VOID_PENDING;
 917
 918         /* Initialize GStreamer */
 919         /* Note: Replace the arguments of gst_init to pass the command line args to GStreamer. */
 920         gst_init(NULL, NULL);
 921
 922         /* Create the empty pipeline */
 923         gst_handle->pipeline = gst_pipeline_new("Demuxer Gst pipeline");
 924         if (!gst_handle->pipeline) {
 925                 MD_E("pipeline create fail");
 926                 ret = MD_ERROR;
 927                 goto ERROR;
 928         }
 929
 930         /* Create the elements */
 931         if ((path = strstr(uri, "http://"))) {
 932 #ifdef TIZEN_FEATURE_STREAMING
 933                 gst_handle->filesrc  = gst_element_factory_make("souphttpsrc", NULL);
 934                 remote_streaming = 1;
 935                 MD_I("Source is http stream. \n");
 936 #else
 937                 MD_I("Source is http stream. Didn't support streaming\n");
 938                 goto ERROR;
 939 #endif
 940         } else {
 941                 gst_handle->filesrc = gst_element_factory_make("filesrc", NULL);
 942                 MD_I("Source is file stream \n");
 943         }
 944         if (!gst_handle->filesrc) {
 945                 MD_E("filesrc creation failed");
 946                 ret = MD_ERROR;
 947                 goto ERROR;
 948         }
 949
 950         /* Modify the source's properties */
 951 #ifdef TIZEN_FEATURE_STREAMING
 952         if (remote_streaming == 1)
 953                 g_object_set(G_OBJECT(gst_handle->filesrc), "location", uri, NULL);
 954         else
 955 #endif
 956                 g_object_set(G_OBJECT(gst_handle->filesrc), "location", uri + 7, NULL);
 957         gst_handle->typefind = gst_element_factory_make("typefind", NULL);
 958         if (!gst_handle->typefind) {
 959                 MD_E("typefind creation failed");
 960                 ret = MD_ERROR;
 961                 goto ERROR;
 962         }
 963         g_signal_connect(gst_handle->typefind, "have-type",
 964                                         G_CALLBACK(__gst_cb_typefind), gst_handle);
 965         gst_handle->fakesink = gst_element_factory_make("fakesink", NULL);
 966         if (!gst_handle->fakesink) {
 967                 MD_E("fakesink creation failed");
 968                 ret = MD_ERROR;
 969                 goto ERROR;
 970         }
 971
 972         /* Build the pipeline */
 973         gst_bin_add_many(GST_BIN(gst_handle->pipeline),
 974                                                 gst_handle->filesrc,
 975                                                 gst_handle->typefind,
 976                                                 gst_handle->fakesink,
 977                                                 NULL);
 978         gst_element_link_many(gst_handle->filesrc,
 979                                                         gst_handle->typefind,
 980                                                         gst_handle->fakesink,
 981                                                         NULL);
 982
 983         /* connect signals, bus watcher */
 984         bus = gst_pipeline_get_bus(GST_PIPELINE(gst_handle->pipeline));
 985         gst_handle->bus_watch_id = gst_bus_add_watch(bus, __gst_bus_call, gst_handle);
 986         gst_handle->thread_default = g_main_context_get_thread_default();
 987         gst_object_unref(GST_OBJECT(bus));
 988
 989         /* set pipeline state to PAUSED */
 990         MEDIADEMUXER_SET_STATE(gst_handle->pipeline, GST_STATE_PAUSED, ERROR);
 991
 992         if (gst_element_get_state(gst_handle->pipeline, &element_state, &element_pending_state, 1 * GST_SECOND)
 993                 == GST_STATE_CHANGE_FAILURE) {
 994                 MD_E(" [%s] state : %s   pending : %s \n",
 995                         GST_ELEMENT_NAME(gst_handle->pipeline),
 996                         gst_element_state_get_name(element_state),
 997                         gst_element_state_get_name(element_pending_state));
 998                 ret = MD_ERROR;
 999                 goto ERROR;
1000         }
1001
1002         if (gst_handle->is_prepared != true) {
1003                 MD_E("Error occure");
1004                 ret = MD_ERROR;
1005                 goto ERROR;
1006         }
1007
1008         MEDIADEMUXER_FLEAVE();
1009         return ret;
1010 ERROR:
1011         MEDIADEMUXER_FLEAVE();
1012         return ret;
1013 }
1014
1015 static int gst_demuxer_prepare(MMHandleType pHandle, char *uri)
1016 {
1017         MEDIADEMUXER_FENTER();
1018         int ret = MD_ERROR_NONE;
1019         MEDIADEMUXER_CHECK_NULL(pHandle);
1020         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1021
1022         MD_I("gst_demuxer_prepare Creating pipeline %p", new_mediademuxer);
1023         ret = _gst_create_pipeline(new_mediademuxer, uri);
1024         if (ret != MD_ERROR_NONE) {
1025                 MD_E("_gst_create_pipeline() failed. returned %d\n", ret);
1026                 goto ERROR;
1027         }
1028         MEDIADEMUXER_FLEAVE();
1029         return ret;
1030 ERROR:
1031         MEDIADEMUXER_FLEAVE();
1032         return ret;
1033 }
1034
1035 static int gst_demuxer_get_data_count(MMHandleType pHandle, int *count)
1036 {
1037         MEDIADEMUXER_FENTER();
1038         int ret = MD_ERROR_NONE;
1039         MEDIADEMUXER_CHECK_NULL(pHandle);
1040         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1041
1042         *count = (new_mediademuxer->info).num_video_track +
1043                         (new_mediademuxer->info).num_audio_track +
1044                         (new_mediademuxer->info).num_subtitle_track +
1045                         (new_mediademuxer->info).num_other_track;
1046         MEDIADEMUXER_FLEAVE();
1047         return ret;
1048 }
1049
1050 int _gst_set_appsink(track *temp, int index, int loop)
1051 {
1052         MEDIADEMUXER_FENTER();
1053         int ret = MD_ERROR_NONE;
1054         int count = 0;
1055
1056         while (count != index) {
1057                 temp = temp->next;
1058                 count++;
1059         }
1060         gst_app_sink_set_max_buffers((GstAppSink *)(temp->appsink), (guint) MAX_APP_BUFFER);
1061         gst_app_sink_set_drop((GstAppSink *)(temp->appsink), false);
1062         gst_app_sink_set_wait_on_eos((GstAppSink *)(temp->appsink), true);
1063         MEDIADEMUXER_FLEAVE();
1064         return ret;
1065 }
1066
1067 static int gst_demuxer_set_track(MMHandleType pHandle, int track)
1068 {
1069         MEDIADEMUXER_FENTER();
1070         int ret = MD_ERROR_NONE;
1071         MEDIADEMUXER_CHECK_NULL(pHandle);
1072         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1073
1074         MD_I("total_tracks (%d) :: selected  track (%d)", new_mediademuxer->total_tracks, track);
1075         if (track >= new_mediademuxer->total_tracks || track < 0) {
1076                 MD_E("total_tracks is less then selected track, So not support this track");
1077                 ret = MD_ERROR_INVALID_ARGUMENT;
1078                 goto ERROR;
1079         }
1080         new_mediademuxer->selected_tracks[track] = true;
1081         _gst_set_appsink((((mdgst_handle_t *)pHandle)->info).head, track,
1082                                         new_mediademuxer->total_tracks);
1083         MEDIADEMUXER_FLEAVE();
1084         return MD_ERROR_NONE;
1085 ERROR:
1086         MEDIADEMUXER_FLEAVE();
1087         return ret;
1088 }
1089
1090 static int _gst_unlink_unselected_track(track *temp, int index)
1091 {
1092         MEDIADEMUXER_FENTER();
1093         int ret = MD_ERROR_NONE;
1094         int count = 0;
1095         GstPad *queue_sink_pad = NULL;
1096         while (count != index) {
1097                 temp = temp->next;
1098                 count++;
1099         }
1100         queue_sink_pad = gst_element_get_static_pad(temp->queue, "sink");
1101         if (!queue_sink_pad) {
1102                 MD_E("queue_sink_pad of appsink not avaible\n");
1103                 return MD_ERROR;
1104         }
1105         if (gst_pad_unlink(temp->pad, queue_sink_pad) != TRUE)
1106                 MD_W("demuxer is already unlinked from queue for track %d\n", index);
1107
1108         gst_object_unref(queue_sink_pad);
1109         MEDIADEMUXER_FLEAVE();
1110         return ret;
1111 }
1112
1113 static int gst_demuxer_start(MMHandleType pHandle)
1114 {
1115         MEDIADEMUXER_FENTER();
1116         int ret = MD_ERROR_NONE;
1117         MEDIADEMUXER_CHECK_NULL(pHandle);
1118         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1119
1120         int indx;
1121         for (indx = 0; indx < gst_handle->total_tracks; indx++) {
1122                 MD_I("track indx[%d] is marked as [%d]. (0- not selected, 1= selected)\n",
1123                         indx, gst_handle->selected_tracks[indx]);
1124                 /*
1125                 if (gst_handle->selected_tracks[indx] ==  false)
1126                         _gst_demuxer_unset(pHandle, indx);
1127                 */
1128                 if (gst_handle->selected_tracks[indx] != true) {
1129                         if (_gst_unlink_unselected_track((((mdgst_handle_t *)pHandle)->info).head, indx) != MD_ERROR_NONE) {
1130                                 MD_E("Failed to unlink unselected tracks\n");
1131                                 ret = MD_INTERNAL_ERROR;
1132                                 goto ERROR;
1133                         }
1134                 }
1135
1136         }
1137
1138         track_info *head_track = &(gst_handle->info);
1139         MD_I("Total Audio track=%d, Video track=%d, text track=%d\n",
1140                         head_track->num_audio_track, head_track->num_video_track,
1141                         head_track->num_subtitle_track);
1142
1143         track *temp = head_track->head;
1144         indx = 0;
1145         while (temp) {
1146                 MD_I("Got one element %p\n", temp->appsink);
1147                 if (gst_element_set_state(temp->appsink, GST_STATE_PLAYING) ==
1148                         GST_STATE_CHANGE_FAILURE) {
1149                         MD_E("Failed to set into PLAYING state");
1150                         ret = MD_INTERNAL_ERROR;
1151                         goto ERROR;
1152                 }
1153                 MD_I("set the state to playing\n");
1154                 indx++;
1155                 if (temp->next) {
1156                         track *next = temp->next;
1157                         temp = next;
1158                 } else {
1159                         temp = NULL;
1160                 }
1161         }
1162
1163         MD_I("gst_demuxer_start pipeine %p", gst_handle);
1164         MEDIADEMUXER_FLEAVE();
1165         return ret;
1166 ERROR:
1167         MEDIADEMUXER_FLEAVE();
1168         return ret;
1169 }
1170
1171 int _set_mime_text(media_format_h format, track *head)
1172 {
1173         MEDIADEMUXER_FENTER();
1174         int ret = MD_ERROR_NONE;
1175         GstStructure *struc = NULL;
1176         struc = gst_caps_get_structure(head->caps, 0);
1177         if (!struc) {
1178                 MD_E("cannot get structure from caps.\n");
1179                 goto ERROR;
1180         }
1181         if (gst_structure_has_name(struc, "text/x-raw")) {
1182                 if (media_format_set_text_mime(format, MEDIA_FORMAT_TEXT_MP4))
1183                         goto ERROR;
1184         } else {
1185                 MD_I("Text mime not supported so far\n");
1186                 goto ERROR;
1187         }
1188
1189         MEDIADEMUXER_FLEAVE();
1190         return ret;
1191 ERROR:
1192         MEDIADEMUXER_FLEAVE();
1193         return MD_ERROR;
1194 }
1195
1196 int _set_mime_video(media_format_h format, track *head)
1197 {
1198         MEDIADEMUXER_FENTER();
1199         int ret = MD_ERROR_NONE;
1200         GstStructure *struc = NULL;
1201         int src_width;
1202         int src_height;
1203         int frame_rate_numerator = 0;
1204         int frame_rate_denominator = 0;
1205         int frame_rate = 0;
1206         media_format_mimetype_e mime_type = MEDIA_FORMAT_MAX;
1207         struc = gst_caps_get_structure(head->caps, 0);
1208         if (!struc) {
1209                 MD_E("cannot get structure from caps.\n");
1210                 goto ERROR;
1211         }
1212         if (gst_structure_has_name(struc, "video/x-h264")) {
1213                 mime_type = MEDIA_FORMAT_H264_SP;
1214         } else if (gst_structure_has_name(struc, "video/x-h263")) {
1215                 mime_type = MEDIA_FORMAT_H263;
1216         } else if (gst_structure_has_name(struc, "video/mpeg")) {
1217                 mime_type = MEDIA_FORMAT_MPEG4_SP;
1218         } else {
1219                 MD_W("Video mime (%s) not supported so far\n", gst_structure_get_name(struc));
1220                 goto ERROR;
1221         }
1222         if (media_format_set_video_mime(format, mime_type)) {
1223                 MD_E("Unable to set video mime type (%x)\n", mime_type);
1224                 goto ERROR;
1225         }
1226         gst_structure_get_int(struc, "width", &src_width);
1227         gst_structure_get_int(struc, "height", &src_height);
1228         if (media_format_set_video_width(format, src_width)) {
1229                 MD_E("Unable to set video width\n");
1230                 goto ERROR;
1231         }
1232         if (media_format_set_video_height(format, src_height)) {
1233                 MD_E("Unable to set video height\n");
1234                 goto ERROR;
1235         }
1236         gst_structure_get_fraction(struc, "framerate",  &frame_rate_numerator, &frame_rate_denominator);
1237
1238         /* Round off the framerate */
1239         if (frame_rate_denominator)
1240                 frame_rate = (int)floor(((gdouble)frame_rate_numerator / frame_rate_denominator) + 0.5);
1241
1242         MD_I("set frame rate %d", frame_rate);
1243         if (media_format_set_video_frame_rate(format, frame_rate)) {
1244                 MD_E("Unable to set video frame rate\n");
1245                 goto ERROR;
1246         }
1247         MEDIADEMUXER_FLEAVE();
1248         return ret;
1249 ERROR:
1250         MEDIADEMUXER_FLEAVE();
1251         return MD_ERROR;
1252 }
1253
1254 int _set_mime_audio(media_format_h format, track *head)
1255 {
1256         MEDIADEMUXER_FENTER();
1257         int ret = MD_ERROR_NONE;
1258         GstStructure *struc = NULL;
1259         int rate = 0;
1260         int bit = 0;
1261         int channels = 0;
1262         int id3_flag = 0;
1263         const gchar *stream_format = NULL;
1264         media_format_mimetype_e mime_type = MEDIA_FORMAT_MAX;
1265
1266         struc = gst_caps_get_structure(head->caps, 0);
1267         if (!struc) {
1268                 MD_E("cannot get structure from caps.\n");
1269                 goto ERROR;
1270         }
1271
1272         if (gst_structure_has_name(struc, "application/x-id3"))
1273                 id3_flag = 1;
1274         if (gst_structure_has_name(struc, "audio/mpeg") || id3_flag) {
1275                 gint mpegversion;
1276                 int layer;
1277                 gst_structure_get_int(struc, "mpegversion", &mpegversion);
1278                 if (mpegversion == 4 || mpegversion == 2) {
1279                         mime_type = MEDIA_FORMAT_AAC_LC;
1280                         if (media_format_set_audio_mime(format, mime_type))
1281                                 goto ERROR;
1282                         stream_format = gst_structure_get_string(struc, "stream-format");
1283
1284                         if (stream_format) {
1285                                 if (strncmp(stream_format, "adts", 4) == 0)
1286                                         media_format_set_audio_aac_type(format, 1);
1287                                 else
1288                                         media_format_set_audio_aac_type(format, 0);
1289                         }
1290
1291                 } else if (mpegversion == 1 || id3_flag) {
1292                         gst_structure_get_int(struc, "layer", &layer);
1293                         if ((layer == 3) || (id3_flag == 1)) {
1294                                 mime_type = MEDIA_FORMAT_MP3;
1295                         } else {
1296                                 MD_I("No Support for MPEG%d Layer %d media\n", mpegversion, layer);
1297                                 goto ERROR;
1298                         }
1299                 }
1300         } else if (gst_structure_has_name(struc, "audio/x-amr-nb-sh") ||
1301                 gst_structure_has_name(struc, "audio/x-amr-wb-sh")) {
1302                 if (gst_structure_has_name(struc, "audio/x-amr-nb-sh")) {
1303                         mime_type = MEDIA_FORMAT_AMR_NB;
1304                         rate = 8000;
1305                 } else {
1306                         mime_type = MEDIA_FORMAT_AMR_WB;
1307                         rate = 16000;
1308                 }
1309         } else if (gst_structure_has_name(struc, "audio/AMR")) {
1310                 mime_type = MEDIA_FORMAT_AMR_NB;
1311         } else if (gst_structure_has_name(struc, "audio/AMR-WB")) {
1312                 mime_type = MEDIA_FORMAT_AMR_WB;
1313         } else if (gst_structure_has_name(struc, "audio/x-wav")) {
1314                 mime_type = MEDIA_FORMAT_PCM;
1315         } else if (gst_structure_has_name(struc, "audio/x-flac")) {
1316                 mime_type = MEDIA_FORMAT_FLAC;
1317         } else if (gst_structure_has_name(struc, "audio/x-vorbis")) {
1318                 mime_type = MEDIA_FORMAT_VORBIS;
1319         } else {
1320                 MD_W("Audio mime (%s) not supported so far\n", gst_structure_get_name(struc));
1321                 goto ERROR;
1322         }
1323         if (media_format_set_audio_mime(format, mime_type))
1324                 goto ERROR;
1325         gst_structure_get_int(struc, "channels", &channels);
1326         if (channels == 0) {    /* default */
1327                 if (mime_type == MEDIA_FORMAT_AMR_NB || mime_type == MEDIA_FORMAT_AMR_WB)
1328                         channels = 1;
1329                 else
1330                         channels = 2;
1331         }
1332         if (media_format_set_audio_channel(format, channels))
1333                 goto ERROR;
1334         if (rate == 0)
1335                 gst_structure_get_int(struc, "rate", &rate);
1336         if (rate == 0)
1337                 rate = 44100;   /* default */
1338         if (media_format_set_audio_samplerate(format, rate))
1339                 goto ERROR;
1340         gst_structure_get_int(struc, "bit", &bit);
1341         if (bit == 0)
1342                 bit = 16;       /* default */
1343         if (media_format_set_audio_bit(format, bit))
1344                 goto ERROR;
1345         MEDIADEMUXER_FLEAVE();
1346         return ret;
1347 ERROR:
1348         MEDIADEMUXER_FLEAVE();
1349         return MD_ERROR;
1350 }
1351
1352 static int gst_demuxer_get_track_info(MMHandleType pHandle,
1353                                                         media_format_h *format, int index)
1354 {
1355         MEDIADEMUXER_FENTER();
1356         int ret = MD_ERROR_NONE;
1357         MEDIADEMUXER_CHECK_NULL(pHandle);
1358         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1359
1360         track *temp = NULL;
1361         int loop;
1362         int count = 0;
1363         temp = (new_mediademuxer->info).head;
1364         loop = (new_mediademuxer->info).num_video_track +
1365                         (new_mediademuxer->info).num_audio_track +
1366                         (new_mediademuxer->info).num_subtitle_track +
1367                         (new_mediademuxer->info).num_other_track;
1368         if (index >= loop || index < 0) {
1369                 MD_E("total tracks(loop) is less then selected track(index), So not support this track");
1370                 ret = MD_ERROR;
1371                 goto ERROR;
1372         }
1373
1374         while (count != index) {
1375                 temp = temp->next;
1376                 count++;
1377         }
1378         if (temp->format != NULL) {
1379                 ret = media_format_ref(temp->format);
1380                 if (ret != MEDIA_FORMAT_ERROR_NONE) {
1381                         MD_E("Mediaformat reference count increment failed. returned %d\n", ret);
1382                         ret = MD_INTERNAL_ERROR;
1383                         goto ERROR;
1384                 }
1385                 ret = media_format_make_writable(temp->format, format); /* copy the content */
1386                 if (ret != MEDIA_FORMAT_ERROR_NONE) {
1387                         MD_E("Mediaformat create copy failed. returned %d\n", ret);
1388                         media_format_unref(temp->format);
1389                         ret = MD_INTERNAL_ERROR;
1390                         goto ERROR;
1391                 }
1392                 MEDIADEMUXER_FLEAVE();
1393                 return ret;
1394         }
1395         ret = media_format_create(&(temp->format));
1396         if (ret != MEDIA_FORMAT_ERROR_NONE) {
1397                 MD_E("Mediaformat creation failed. returned %d\n", ret);
1398                 ret = MD_INTERNAL_ERROR;
1399                 goto ERROR;
1400         }
1401
1402         MD_I("CAPS for selected track [%d] is [%s]\n", index, temp->caps_string);
1403         MD_I("format ptr[%p]\n", temp->format);
1404         if (temp->caps_string[0] == 'a') {
1405                 MD_I("Setting for Audio \n");
1406                 _set_mime_audio(temp->format, temp);
1407         } else if (temp->caps_string[0] == 'v') {
1408                 MD_I("Setting for Video \n");
1409                 _set_mime_video(temp->format, temp);
1410         } else if (temp->caps_string[0] == 't') {
1411                 MD_I("Setting for Subtitle\n");
1412                 _set_mime_text(temp->format, temp);
1413         } else {
1414                 MD_W("Not supported so far (except audio, video and subtitle)\n");
1415         }
1416
1417         ret = media_format_ref(temp->format);   /* increment the ref to retain the original content */
1418         if (ret != MEDIA_FORMAT_ERROR_NONE) {
1419                 MD_E("Mediaformat reference count increment failed. returned %d\n", ret);
1420                 ret = MD_INTERNAL_ERROR;
1421                 goto ERROR;
1422         }
1423         ret = media_format_make_writable(temp->format, format); /* copy the content */
1424         if (ret != MEDIA_FORMAT_ERROR_NONE) {
1425                 MD_E("Mediaformat create copy failed. returned %d\n", ret);
1426                 media_format_unref(temp->format);
1427                 ret = MD_INTERNAL_ERROR;
1428                 goto ERROR;
1429         }
1430         MEDIADEMUXER_FLEAVE();
1431         return ret;
1432 ERROR:
1433         MEDIADEMUXER_FLEAVE();
1434         return ret;
1435 }
1436
1437 static int _gst_copy_buf_to_media_packet(media_packet_h out_pkt,
1438                                                         GstBuffer *buffer, GstBuffer *codec_data)
1439 {
1440         MEDIADEMUXER_FENTER();
1441         int ret = MD_ERROR_NONE;
1442         MEDIADEMUXER_CHECK_NULL(out_pkt);
1443         void *pkt_data;
1444         uint64_t size;
1445         GstMapInfo map;
1446
1447         if (!gst_buffer_map(buffer, &map, GST_MAP_READ)) {
1448                 MD_E("gst_buffer_map failed\n");
1449                 ret = MD_ERROR_UNKNOWN;
1450                 goto ERROR;
1451         }
1452         /* copy data */
1453         media_packet_get_buffer_size(out_pkt, &size);
1454         MD_I("Media packet Buffer capacity: %llu GST Buffer size = %d\n", size, map.size);
1455         if (size < (uint64_t)map.size) {
1456                 MD_W("Media packet Buffer capacity[%llu] is \
1457                         less than the GST Buffer size[%d]. Resizing...\n", size, map.size);
1458                 ret = media_packet_set_buffer_size(out_pkt, (uint64_t)map.size);
1459                 media_packet_get_buffer_size(out_pkt, &size);
1460                 MD_I("Media packet Buffer NEW  capacity: %llu \n", size);
1461         }
1462         if (media_packet_get_buffer_data_ptr(out_pkt, &pkt_data)) {
1463                 MD_E("unable to get the buffer pointer from media_packet_get_buffer_data_ptr\n");
1464                 ret = MD_ERROR_UNKNOWN;
1465                 goto ERROR;
1466         }
1467         memcpy((char *)pkt_data, map.data, map.size);
1468         if (media_packet_set_pts(out_pkt, GST_BUFFER_PTS(buffer))) {
1469                 MD_E("unable to set the pts\n");
1470                 ret = MD_ERROR_UNKNOWN;
1471                 goto ERROR;
1472         }
1473         if (media_packet_set_dts(out_pkt, GST_BUFFER_DTS(buffer))) {
1474                 MD_E("unable to set the dts\n");
1475                 ret = MD_ERROR_UNKNOWN;
1476                 goto ERROR;
1477         }
1478         if (media_packet_set_duration(out_pkt, GST_BUFFER_DURATION(buffer))) {
1479                 MD_E("unable to set the duration\n");
1480                 ret = MD_ERROR_UNKNOWN;
1481                 goto ERROR;
1482         }
1483         if (media_packet_set_buffer_size(out_pkt, gst_buffer_get_size(buffer))) {
1484                 MD_E("unable to set the buffer size\n");
1485                 ret = MD_ERROR_UNKNOWN;
1486                 goto ERROR;
1487         }
1488         if (!GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT)) {
1489                 if (media_packet_set_flags(out_pkt, MEDIA_PACKET_SYNC_FRAME)) {
1490                         MD_E("unable to set the buffer flag\n");
1491                         ret = MD_ERROR_UNKNOWN;
1492                         goto ERROR;
1493                 }
1494         }
1495         /* set codec data into media packet */
1496         if (codec_data) {
1497                 GstMapInfo codec_data_map;
1498                 if (!gst_buffer_map(codec_data, &codec_data_map, GST_MAP_READ)) {
1499                         MD_E("codec data buffer map failed\n");
1500                         ret = MD_ERROR_UNKNOWN;
1501                         goto ERROR;
1502                 }
1503                 if (media_packet_set_codec_data(out_pkt, (void *)codec_data_map.data,
1504                         (unsigned int)codec_data_map.size)) {
1505                         MD_E("unable to set the codec data\n");
1506                         ret = MD_ERROR_UNKNOWN;
1507                         gst_buffer_unmap(codec_data, &codec_data_map);
1508                         goto ERROR;
1509                 }
1510                 gst_buffer_unmap(codec_data, &codec_data_map);
1511
1512                 media_buffer_flags_e flags;
1513                 media_packet_get_flags(out_pkt, &flags);
1514                 media_packet_set_flags(out_pkt, flags | MEDIA_PACKET_CODEC_CONFIG);
1515         }
1516 ERROR:
1517         gst_buffer_unmap(buffer, &map);
1518         MEDIADEMUXER_FLEAVE();
1519         return ret;
1520 }
1521
1522 static int _gst_demuxer_create_eos_packet(media_format_h fmt, media_packet_h *outbuf)
1523 {
1524         media_packet_h mediabuf = NULL;
1525         int ret = MD_ERROR_NONE;
1526
1527         MEDIADEMUXER_FENTER();
1528         if (media_packet_create_alloc(fmt, NULL, NULL, &mediabuf)) {
1529                 MD_E("media_packet_create_alloc failed\n");
1530                 ret = MD_ERROR;
1531                 goto ERROR;
1532         }
1533
1534         if (media_packet_set_flags(mediabuf, MEDIA_PACKET_END_OF_STREAM)) {
1535                 MD_E("unable to set EOS flag\n");
1536                 ret = MD_ERROR_UNKNOWN;
1537                 goto ERROR;
1538         }
1539
1540         *outbuf = mediabuf;
1541         MEDIADEMUXER_FLEAVE();
1542
1543         return ret;
1544 ERROR:
1545         if (mediabuf)
1546                 media_packet_destroy(mediabuf);
1547         *outbuf = NULL;
1548         MEDIADEMUXER_FLEAVE();
1549         return ret;
1550 }
1551
1552 static int gst_demuxer_read_sample(MMHandleType pHandle,
1553                                                 media_packet_h *outbuf, int track_indx)
1554 {
1555         MEDIADEMUXER_FENTER();
1556         int ret = MD_ERROR_NONE;
1557         MEDIADEMUXER_CHECK_NULL(pHandle);
1558         mdgst_handle_t *demuxer = (mdgst_handle_t *)pHandle;
1559
1560         media_packet_h mediabuf = NULL;
1561         int indx = 0;
1562
1563         track *atrack = demuxer->info.head;
1564         if ((demuxer->selected_tracks)[track_indx] == false) {
1565                 MD_E("Track Not selected\n");
1566                 ret = MD_ERROR;
1567                 goto ERROR;
1568         }
1569         while (atrack) {
1570                 if (indx == track_indx)  /* Got the requird track details */
1571                         break;
1572                 if (atrack->next) {
1573                         track *next = atrack->next;
1574                         atrack = next;
1575                 } else {
1576                         MD_E("Invalid track Index\n");
1577                         ret = MD_ERROR_INVALID_ARGUMENT;
1578                         goto ERROR;
1579                 }
1580                 indx++;
1581         }
1582
1583         if (!atrack) {
1584                 MD_E("atrack is NULL\n");
1585                 goto ERROR;
1586         }
1587
1588         if (indx != track_indx) {
1589                 MD_E("Invalid track Index\n");
1590                 ret = MD_ERROR_INVALID_ARGUMENT;
1591                 goto ERROR;
1592         }
1593         GstElement *sink = atrack->appsink;
1594         GstSample *sample = NULL;
1595
1596         sample = gst_app_sink_pull_sample((GstAppSink *) sink);
1597         if (sample == NULL) {
1598                 if (gst_app_sink_is_eos((GstAppSink *) sink)) {
1599                         MD_W("End of stream (EOS) reached, triggering the eos callback\n");
1600                         ret = MD_ERROR_NONE;
1601                         *outbuf = NULL;
1602                         __gst_eos_callback(track_indx, demuxer);
1603
1604                         //Make EOS packet
1605                         _gst_demuxer_create_eos_packet(atrack->format, outbuf);
1606                         return ret;
1607                 } else {
1608                         MD_E("gst_demuxer_read_sample failed\n");
1609                         *outbuf = NULL;
1610                         ret = MD_ERROR_UNKNOWN;
1611                         return ret;
1612                 }
1613         }
1614
1615         if (media_packet_create_alloc(atrack->format, NULL, NULL, &mediabuf)) {
1616                 MD_E("media_packet_create_alloc failed\n");
1617                 ret = MD_ERROR;
1618                 goto ERROR;
1619         }
1620
1621         GstBuffer *buffer = gst_sample_get_buffer(sample);
1622         if (buffer == NULL) {
1623                 MD_E("gst_sample_get_buffer returned NULL pointer\n");
1624                 ret = MD_ERROR_UNKNOWN;
1625                 goto ERROR;
1626         }
1627
1628         GstBuffer *codec_data_buffer = NULL;
1629         /* Need to Check : Only the first frame need set codec_data, what about Resolution changed instance ...*/
1630         if (atrack->need_codec_data) {
1631                 atrack->need_codec_data = FALSE;
1632                 /* Create the codec data and pass to _gst_copy_buf_to_media_packet() to add into the media packet */
1633                 GstStructure *structure = NULL;
1634                 const GValue *value = NULL;
1635
1636                 structure = gst_caps_get_structure(atrack->caps, 0);
1637                 /* get codec data from caps*/
1638                 value = gst_structure_get_value(structure, "codec_data");
1639                 if (value)
1640                         codec_data_buffer = gst_value_get_buffer(value);
1641         }
1642
1643         /* Fill the media_packet with proper information */
1644         ret = _gst_copy_buf_to_media_packet(mediabuf, buffer, codec_data_buffer);
1645         gst_sample_unref(sample);
1646         *outbuf = mediabuf;
1647
1648         MEDIADEMUXER_FLEAVE();
1649         return ret;
1650 ERROR:
1651         if (mediabuf)
1652                 media_packet_destroy(mediabuf);
1653         *outbuf = NULL;
1654         MEDIADEMUXER_FLEAVE();
1655         return ret;
1656 }
1657
1658 static int gst_demuxer_seek(MMHandleType pHandle, gint64 pos1)
1659 {
1660         MEDIADEMUXER_FENTER();
1661         MEDIADEMUXER_CHECK_NULL(pHandle);
1662         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1663
1664         gint64 pos = 0;
1665         gdouble rate = 1;
1666         track_info *head_track = &(gst_handle->info);
1667         track *temp = head_track->head;
1668         track *temp_track = head_track->head;
1669         int indx = 0;
1670         bool is_seek = FALSE;
1671
1672         /* Setting each appsink to paused state before seek */
1673         while (temp_track) {
1674                 if (gst_handle->selected_tracks[indx] == true) {
1675                         if (gst_element_set_state(temp_track->appsink, GST_STATE_PAUSED) == GST_STATE_CHANGE_FAILURE) {
1676                                 MD_E("Failed to set into PAUSED state");
1677                                 goto ERROR;
1678                         }
1679                         MD_I("set the state to paused\n");
1680                 }
1681                 indx++;
1682                 if (temp_track->next) {
1683                         track *next = temp_track->next;
1684                         temp_track = next;
1685                 } else {
1686                         temp_track = NULL;
1687                 }
1688         }
1689
1690         pos = pos1 * GST_MSECOND;
1691
1692         MD_I("NEW Time: %" GST_TIME_FORMAT, GST_TIME_ARGS(pos));
1693
1694         indx = 0;
1695         while (temp) {
1696                 MD_I("Got one element %p {%s}\n", temp->appsink, GST_ELEMENT_NAME(temp->appsink));
1697                 if (gst_handle->selected_tracks[indx] == true) {
1698                         temp->need_codec_data = TRUE;
1699
1700                         if (!is_seek) {
1701                                 if (!gst_element_seek(temp->appsink, rate, GST_FORMAT_TIME,
1702                                         GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT | GST_SEEK_FLAG_SNAP_BEFORE,
1703                                         GST_SEEK_TYPE_SET, pos, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE)) {
1704                                         MD_E("Seek failed!\n");
1705                                         goto ERROR;
1706                                 }
1707                                 is_seek = TRUE;
1708                         }
1709                         MD_I("Seek success...setting appsink to playing state\n");
1710                         if (gst_element_set_state(temp->appsink, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
1711                                 MD_E("Failed to set into PLAYING state");
1712                                 goto ERROR;
1713                         }
1714                 }
1715                 indx++;
1716                 if (temp->next) {
1717                         track *next = temp->next;
1718                         temp = next;
1719                 } else {
1720                         temp = NULL;
1721                 }
1722         }
1723
1724         MEDIADEMUXER_FLEAVE();
1725         return MD_ERROR_NONE;
1726 ERROR:
1727         MEDIADEMUXER_FLEAVE();
1728         return MD_ERROR;
1729 }
1730
1731 int _gst_unset_appsink(track *temp, int index, int loop)
1732 {
1733         MEDIADEMUXER_FENTER();
1734         int ret = MD_ERROR_NONE;
1735         int count = 0;
1736
1737         while (count != index) {
1738                 temp = temp->next;
1739                 count++;
1740         }
1741         gst_app_sink_set_max_buffers((GstAppSink *)(temp->appsink), (guint)0);
1742         gst_app_sink_set_drop((GstAppSink *)(temp->appsink), true);
1743         gst_app_sink_set_wait_on_eos((GstAppSink *)(temp->appsink), false);
1744         MEDIADEMUXER_FLEAVE();
1745         return ret;
1746 }
1747
1748 static int gst_demuxer_unset_track(MMHandleType pHandle, int track)
1749 {
1750         MEDIADEMUXER_FENTER();
1751         int ret = MD_ERROR_NONE;
1752         MEDIADEMUXER_CHECK_NULL(pHandle);
1753         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1754
1755         if (track >= new_mediademuxer->total_tracks || track < 0) {
1756                 MD_E("total tracks is less then unselected track, So not support this track");
1757                 ret = MD_ERROR_INVALID_ARGUMENT;
1758                 goto ERROR;
1759         }
1760         new_mediademuxer->selected_tracks[track] = false;
1761         _gst_unset_appsink((((mdgst_handle_t *)pHandle)->info).head, track,
1762                                         new_mediademuxer->total_tracks);
1763         MEDIADEMUXER_FLEAVE();
1764         return ret;
1765 ERROR:
1766         MEDIADEMUXER_FLEAVE();
1767         return ret;
1768 }
1769
1770 static int gst_demuxer_stop(MMHandleType pHandle)
1771 {
1772         MEDIADEMUXER_FENTER();
1773         int ret = MD_ERROR_NONE;
1774         MEDIADEMUXER_CHECK_NULL(pHandle);
1775         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1776
1777         MD_I("gst_demuxer_stop pipeine %p", gst_handle);
1778         if (gst_element_set_state(gst_handle->pipeline, GST_STATE_PAUSED) ==
1779             GST_STATE_CHANGE_FAILURE) {
1780                 MD_E("Failed to set into PAUSE state");
1781                 ret = MD_INTERNAL_ERROR;
1782                 goto ERROR;
1783         }
1784         MEDIADEMUXER_FLEAVE();
1785         return ret;
1786 ERROR:
1787         MEDIADEMUXER_FLEAVE();
1788         return ret;
1789 }
1790
1791 void  _gst_clear_struct(mdgst_handle_t *gst_handle)
1792 {
1793         MEDIADEMUXER_FENTER();
1794         MEDIADEMUXER_CHECK_NULL_VOID(gst_handle);
1795         if (gst_handle->selected_tracks) {
1796                 MD_I("Deallocating gst_handle->selected_tracks %p\n",
1797                      gst_handle->selected_tracks);
1798                 g_free(gst_handle->selected_tracks);
1799                 gst_handle->selected_tracks = NULL;
1800         }
1801         if ((gst_handle->info).head)
1802                 __gst_free_stuct(&(gst_handle->info).head);
1803         MEDIADEMUXER_FLEAVE();
1804 }
1805
1806 int _md_gst_destroy_pipeline(GstElement *pipeline)
1807 {
1808         MEDIADEMUXER_FENTER();
1809         int ret = MD_ERROR_NONE;
1810         if (pipeline)
1811                 MEDIADEMUXER_SET_STATE(pipeline, GST_STATE_NULL, ERROR);
1812         if (pipeline)
1813                 gst_object_unref(GST_OBJECT(pipeline));
1814         MEDIADEMUXER_FLEAVE();
1815         return ret;
1816 ERROR:
1817         if (pipeline)
1818                 gst_object_unref(GST_OBJECT(pipeline));
1819         MEDIADEMUXER_FLEAVE();
1820         return MD_ERROR;
1821 }
1822
1823 static int gst_demuxer_unprepare(MMHandleType pHandle)
1824 {
1825         MEDIADEMUXER_FENTER();
1826         int ret = MD_ERROR_NONE;
1827         MEDIADEMUXER_CHECK_NULL(pHandle);
1828         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1829
1830         /*Modification : Fix pipeline state change was block by appsink When EOS received and appsink also has many datas*/
1831         int indx = 0;
1832         track *atrack = gst_handle->info.head;
1833         while (atrack) {
1834                 if ((gst_handle->selected_tracks)[indx] == false) {
1835                         MD_I("Track [%d] Not selected\n", indx);
1836                 } else {
1837                         MD_I("Track [%d] to unset appsink...\n", indx);
1838                         gst_demuxer_unset_track(pHandle, indx);
1839                 }
1840                 if (atrack->next) {
1841                         track *next = atrack->next;
1842                         atrack = next;
1843                 } else {
1844                         break;
1845                 }
1846                 indx++;
1847         }
1848
1849         _gst_clear_struct(gst_handle);
1850         if (gst_handle->bus_watch_id) {
1851                 GSource *source = NULL;
1852                 source = g_main_context_find_source_by_id(gst_handle->thread_default, gst_handle->bus_watch_id);
1853                 if (source) {
1854                         g_source_destroy(source);
1855                         LOGD("Deallocation bus watch id");
1856                 }
1857         }
1858
1859         MD_I("gst_demuxer_stop pipeine %p\n", gst_handle->pipeline);
1860         if (_md_gst_destroy_pipeline(gst_handle->pipeline) != MD_ERROR_NONE) {
1861                 ret = MD_ERROR;
1862                 goto ERROR;
1863         }
1864         MEDIADEMUXER_FLEAVE();
1865         return ret;
1866 ERROR:
1867         MEDIADEMUXER_FLEAVE();
1868         return ret;
1869 }
1870
1871 static int gst_demuxer_destroy(MMHandleType pHandle)
1872 {
1873         MEDIADEMUXER_FENTER();
1874         int ret = MD_ERROR_NONE;
1875         MEDIADEMUXER_CHECK_NULL(pHandle);
1876         mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
1877
1878         MD_I("gst_demuxer_destroy deallocating new_mediademuxer:%p\n",
1879              new_mediademuxer);
1880         g_free(new_mediademuxer);
1881         MEDIADEMUXER_FLEAVE();
1882         return ret;
1883 }
1884
1885 int gst_set_error_cb(MMHandleType pHandle,
1886                         gst_error_cb callback, void *user_data)
1887 {
1888         MEDIADEMUXER_FENTER();
1889         int ret = MD_ERROR_NONE;
1890         MEDIADEMUXER_CHECK_NULL(pHandle);
1891         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1892
1893         if (gst_handle->user_cb[_GST_EVENT_TYPE_ERROR]) {
1894                 MD_E("Already set mediademuxer_error_cb\n");
1895                 ret = MD_ERROR_INVALID_ARGUMENT;
1896                 goto ERROR;
1897         } else {
1898                 if (!callback) {
1899                         MD_E("fail invaild argument (callback)\n");
1900                         ret = MD_ERROR_INVALID_ARGUMENT;
1901                         goto ERROR;
1902                 }
1903         }
1904
1905         MD_I("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
1906
1907         gst_handle->user_cb[_GST_EVENT_TYPE_ERROR] = (gst_error_cb)callback;
1908         gst_handle->user_data[_GST_EVENT_TYPE_ERROR] = user_data;
1909         MEDIADEMUXER_FLEAVE();
1910         return MD_ERROR_NONE;
1911 ERROR:
1912         MEDIADEMUXER_FLEAVE();
1913         return ret;
1914 }
1915
1916 int gst_set_eos_cb(MMHandleType pHandle, gst_eos_cb callback, void *user_data)
1917 {
1918         MEDIADEMUXER_FENTER();
1919         int ret = MD_ERROR_NONE;
1920         MEDIADEMUXER_CHECK_NULL(pHandle);
1921         mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
1922
1923         if (gst_handle->user_cb[_GST_EVENT_TYPE_EOS]) {
1924                 MD_E("Already set mediademuxer_eos_cb\n");
1925                 ret = MD_ERROR_INVALID_ARGUMENT;
1926                 goto ERROR;
1927         } else {
1928                 if (!callback) {
1929                         MD_E("fail invaild argument (callback)\n");
1930                         ret = MD_ERROR_INVALID_ARGUMENT;
1931                         goto ERROR;
1932                 }
1933         }
1934
1935         MD_I("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
1936         gst_handle->user_cb[_GST_EVENT_TYPE_EOS] = (gst_eos_cb)callback;
1937         gst_handle->user_data[_GST_EVENT_TYPE_EOS] = user_data;
1938         MEDIADEMUXER_FLEAVE();
1939         return MD_ERROR_NONE;
1940 ERROR:
1941         MEDIADEMUXER_FLEAVE();
1942         return ret;
1943 }
1944
1945 static int __gst_eos_callback(int track_num, void* user_data)
1946 {
1947         if (user_data == NULL) {
1948                 MD_E("Invalid argument");
1949                 return MD_ERROR;
1950         }
1951         mdgst_handle_t *gst_handle = (mdgst_handle_t *)user_data;
1952         if (gst_handle->user_cb[_GST_EVENT_TYPE_EOS])
1953                 ((gst_eos_cb)gst_handle->user_cb[_GST_EVENT_TYPE_EOS])(track_num,
1954                                         gst_handle->user_data[_GST_EVENT_TYPE_EOS]);
1955         else
1956                 MD_E("EOS received, but callback is not set!!!");
1957         return MD_ERROR_NONE;
1958 }