ti_plugins/adecoder/src/gstadecoder.c~

   1 /*
   2  * Plugin Name : adecoder
   3  * Description : A Generic (ARM/DSP based) Audio Decoder for for TI Davinci DM644x
   4  *
   5  * Copyright (C) 2007 Texas Instruments, Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU Lesser General Public License as published
   9  * by the Free Software Foundation version 2.1 of the License.
  10  *
  11  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
  12  * whether express or implied; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  */
  16
  17
  18
  19 #ifdef HAVE_CONFIG_H
  20
  21 #include "config.h"
  22
  23 #endif
  24
  25 #include "gstadecoder.h"
  26
  27 GST_DEBUG_CATEGORY_STATIC(gstadecoder_debug);
  28
  29
  30 #define translate_DspCommError(x) AVPLAYER_APP_DSPCOMM
  31
  32 /* elementfactory information */
  33
  34 static GstElementDetails adecoder_details =
  35 {
  36     "A Generic Audio Decoder",
  37
  38     "Codec/Decoder/Audio",
  39
  40     "Decodes Various Audio Formats using the Codec Engine",
  41
  42     "Yashwant Vijayakumar"
  43 };
  44
  45 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE("sink",
  46
  47                                                                     GST_PAD_SINK,
  48
  49                                                                     GST_PAD_ALWAYS,
  50
  51                                                                     GST_STATIC_CAPS
  52
  53                                                                     ("audio/mpeg, "
  54
  55                                                                      "mpegversion = (int) { 1, 2, 4 }, "
  56
  57                                                                                                                                          "layer = (int) { 1, 2, 3 }; "
  58
  59                                                                                                                                          "audio/x-wma, "
  60
  61                                                                                                                                          "wmaversion = (int) { 1, 2, 3 }, "
  62
  63                                                                                                                                  "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
  64
  65                                                                                                                                  "channels = (int) [ 1, 2 ]"));
  66
  67
  68 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE("src",
  69
  70                                                                    GST_PAD_SRC,
  71
  72                                                                    GST_PAD_ALWAYS,
  73
  74                                                                    GST_STATIC_CAPS
  75
  76                                                                    ("audio/x-raw-int, "
  77
  78                                                                                                                                         "endianness = (int) " G_STRINGIFY (G_BYTE_ORDER) ", "
  79
  80                                                                                                                                         "signed = (boolean)true, "
  81
  82                                                                                                                                         "width = (int) 16, depth = (int) 16, "
  83
  84                                                                                                                                         "rate = (int) {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, "
  85
  86                                                                                                                                         "channels = (int) [ 1, 2 ]"));
  87
  88
  89
  90 static GType gst_adecoder_get_type(void)
  91
  92 {
  93
  94     static GType adecoder_type = 0;
  95
  96     if (!adecoder_type)
  97     {
  98                 static const GTypeInfo adecoder_info =
  99         {
 100             sizeof(GstADecoderClass),
 101
 102             (GBaseInitFunc) gst_adecoder_base_init,
 103
 104             NULL,
 105
 106             (GClassInitFunc) gst_adecoder_class_init,
 107
 108             NULL,
 109
 110             NULL,
 111
 112             sizeof(GstADecoder),
 113
 114             0,
 115
 116             (GInstanceInitFunc) gst_adecoder_init,
 117         };
 118
 119         adecoder_type = g_type_register_static(GST_TYPE_ELEMENT, "GstADecoder",&adecoder_info, 0);
 120
 121         GST_DEBUG_CATEGORY_INIT(gstadecoder_debug,"adecoder",0,"Generic Audio Decoder Element for the ARM");
 122
 123     }
 124
 125     return adecoder_type;
 126
 127 }
 128
 129
 130 static GType gst_adecoder_get_engine_type(void)
 131 {
 132
 133         static GType adecoder_engine_type = 0;
 134
 135         if(!adecoder_engine_type)
 136         {
 137                 static GEnumValue engine_types[] =
 138                 {
 139
 140                         { H264ENGINE, "H264Engine","When running H264 or standalone AAC"},
 141
 142                         { MPEG4ENGINE,"MPEG4Engine","When running MPEG4"},
 143
 144                         { WMENGINE,"WMEngine","When running WMV or standalone WMA"},
 145
 146                         { MP3ENGINE,"MP3Engine","When running standalone MP3"},
 147
 148                         { 0,NULL,NULL }
 149
 150                 };
 151
 152                 adecoder_engine_type = g_enum_register_static("AdecoderEngineName",engine_types);
 153         }
 154
 155         return adecoder_engine_type;
 156
 157 }
 158
 159
 160 static GType gst_adecoder_get_codec_type(void)
 161 {
 162
 163         static GType adecoder_codec_type = 0;
 164
 165         if(!adecoder_codec_type)
 166         {
 167                 static GEnumValue codec_types[] =
 168                 {
 169                         { ST_AUDIO_ARM_MP3, "MP3","When running MP3 Decoder"},
 170
 171                         { ST_AUDIO_WMA,"WMA","When running WMA Decoder"},
 172
 173                         { ST_AUDIO_AAC,"AAC","When running AAC Decoder"},
 174
 175                         { ST_AUDIO_DSP_MP3, "MP3","When running MP3 Decoder"},
 176
 177                         { 0,NULL,NULL }
 178
 179                 };
 180
 181                 adecoder_codec_type = g_enum_register_static("AdecoderCodecName",codec_types);
 182         }
 183
 184         return adecoder_codec_type;
 185
 186 }
 187
 188
 189 static GstCaps *gst_adecoder_sink_getcaps(GstPad * pad)
 190
 191 {
 192     #ifdef DEBUG
 193
 194     printf("Sink getcaps invoked\n");
 195
 196     #endif
 197
 198         return gst_caps_copy(gst_pad_get_pad_template_caps(pad));
 199
 200 }
 201
 202
 203 static GstCaps *gst_adecoder_src_getcaps(GstPad * pad)
 204
 205 {
 206         #ifdef DEBUG
 207
 208     printf("Src getcaps invoked\n");
 209
 210     #endif
 211
 212         return gst_caps_copy(gst_pad_get_pad_template_caps(pad));
 213 }
 214
 215
 216
 217 static gboolean gst_adecoder_sink_setcaps(GstPad * pad, GstCaps * caps)
 218
 219 {
 220     GstADecoder *adecoder;
 221
 222     GstStructure *structure;
 223
 224     GstCaps *intersection;
 225
 226     const guchar *mime;
 227
 228     #ifdef DEBUG
 229
 230     printf("Inside set caps...\n");
 231
 232     #endif
 233
 234     adecoder = GST_ADECODER(GST_PAD_PARENT(pad));
 235
 236     intersection = gst_caps_intersect(gst_pad_get_pad_template_caps(pad), caps);
 237
 238     if (gst_caps_is_empty(intersection))
 239     {
 240                 #ifdef DEBUG
 241
 242         printf(" Caps empty...\n");
 243
 244         #endif
 245
 246         return FALSE;
 247     }
 248
 249     gst_caps_unref(intersection);
 250
 251     structure = gst_caps_get_structure(caps, 0);
 252
 253     mime = gst_structure_get_name(structure);
 254
 255     if (!strcmp("audio/mpeg", mime))
 256     {
 257         int version = 0;
 258
 259         gst_structure_get_int(structure, "mpegversion", &version);
 260
 261         if (!version){
 262              return FALSE;
 263         }
 264
 265         if (version == 1){                              //version 1  -> mp3
 266             adecoder->codec = ST_AUDIO_DSP_MP3;
 267             printf("Audio is MP3\n");
 268         }
 269         else{                                                   //version 2 or 4 -> aac
 270             adecoder->codec = ST_AUDIO_AAC;
 271             printf("Audio is AAC\n");
 272         }
 273       }else if (!strcmp("audio/x-wma",mime)){
 274                 adecoder->codec = ST_AUDIO_WMA;
 275                 printf("Audio is WMA\n");
 276       }else{
 277         printf(" Unknown mime type...\n");
 278         return FALSE;
 279     }
 280
 281     adecoder->isCodecPropSet = TRUE;
 282     return TRUE;
 283
 284 }
 285
 286 static void gst_adecoder_base_init(GstADecoderClass * klass)
 287
 288 {
 289     GstElementClass *element_class = GST_ELEMENT_CLASS(klass);
 290
 291     klass->sink_template = gst_static_pad_template_get(&sink_template);
 292
 293     klass->src_template = gst_static_pad_template_get(&src_template);
 294
 295     gst_element_class_add_pad_template(element_class, klass->src_template);
 296
 297     gst_element_class_add_pad_template(element_class,klass->sink_template);
 298
 299     gst_element_class_set_details(element_class, &adecoder_details);
 300
 301 }
 302
 303 static void gst_adecoder_class_init(GstADecoderClass * klass)
 304
 305 {
 306     GstElementClass *gstelement_class = (GstElementClass *) klass;
 307
 308     GObjectClass *object_class = (GObjectClass *)(klass);
 309
 310     parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
 311
 312     gstelement_class->change_state = gst_adecoder_change_state;
 313
 314         object_class->set_property = gst_adecoder_set_property;
 315
 316         g_object_class_install_property(object_class,ARG_ENGINE_NAME,g_param_spec_enum ("Engine","Engine","Name of Engine to open"
 317
 318         ,GST_TYPE_ADECODER_ENGINE,0,G_PARAM_WRITABLE));
 319
 320         g_object_class_install_property(object_class,ARG_CODEC_NAME,g_param_spec_enum ("Codec","Codec","Name of Codec to run"
 321
 322         ,GST_TYPE_ADECODER_CODEC,0,G_PARAM_WRITABLE));
 323
 324         g_object_class_install_property(object_class,ARG_ENABLE_PROCESSING,g_param_spec_boolean ("Enable_Processing","Enable_Processing","Used during dsp on/off"
 325
 326         ,TRUE,G_PARAM_WRITABLE));
 327
 328 }
 329
 330 static void gst_adecoder_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec)
 331 {
 332         GstADecoder *adecoder = GST_ADECODER(object);
 333
 334         switch(prop_id)
 335         {
 336                 case ARG_ENGINE_NAME:
 337
 338                 adecoder->engine = g_value_get_enum(value);
 339
 340                 adecoder->isEnginePropSet = TRUE;
 341
 342                 #ifdef DEBUG
 343
 344                 printf("Engine handle set to value %x\n",adecoder->ce);
 345
 346                 #endif
 347
 348                 break;
 349
 350                 case ARG_CODEC_NAME:
 351
 352                 adecoder->codec = g_value_get_enum(value);
 353
 354                 adecoder->isCodecPropSet = TRUE;
 355
 356                 #ifdef DEBUG
 357
 358                 printf("Codec set to enum value %d\n",adecoder->codec);
 359
 360                 #endif
 361
 362                 break;
 363
 364                 case ARG_ENABLE_PROCESSING:
 365
 366                 if(adecoder->enable_processing != g_value_get_boolean(value))
 367                 {
 368
 369                         adecoder->enable_processing = g_value_get_boolean(value);
 370
 371                         if(adecoder->enable_processing == TRUE)
 372                         {
 373                                 #ifdef DEBUG
 374
 375                                 printf("Enable_processing\n");
 376
 377                                 #endif
 378
 379                                 pthread_mutex_unlock(adecoder->start_decode);
 380                         }
 381
 382                         else
 383                         {
 384                                 #ifdef DEBUG
 385
 386                                 printf("Disable_processing\n");
 387
 388                                 #endif
 389
 390                                 //pthread_mutex_lock(adecoder->start_decode);
 391
 392                         }
 393                 }
 394
 395                 break;
 396
 397                 default:
 398
 399                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 400
 401                 break;
 402
 403         }
 404
 405         //gst_object_unref(adecoder); //getting seg.fault when unref is done.
 406
 407 }
 408
 409
 410 static void gst_adecoder_init(GstADecoder * adecoder)
 411
 412 {
 413     GstADecoderClass *klass = GST_ADECODER_GET_CLASS(adecoder);
 414
 415     GstElementClass *element_class = GST_ELEMENT_CLASS(klass);
 416
 417     adecoder->sinkpad = gst_pad_new_from_template(klass->sink_template, "sink");
 418
 419     gst_pad_set_activate_function(adecoder->sinkpad,GST_DEBUG_FUNCPTR(gst_adecoder_sink_activate));
 420
 421     gst_pad_set_activatepull_function(adecoder->sinkpad,GST_DEBUG_FUNCPTR(gst_adecoder_sink_activate_pull));
 422
 423     gst_pad_set_event_function(adecoder->sinkpad,GST_DEBUG_FUNCPTR(gst_adecoder_sink_event));
 424
 425     gst_pad_set_chain_function(adecoder->sinkpad, gst_adecoder_chain);
 426
 427     gst_pad_set_getcaps_function(adecoder->sinkpad,gst_adecoder_sink_getcaps);
 428
 429     gst_pad_set_setcaps_function(adecoder->sinkpad,gst_adecoder_sink_setcaps);
 430
 431     gst_element_add_pad(GST_ELEMENT(adecoder), adecoder->sinkpad);
 432
 433         adecoder->srcpad = gst_pad_new_from_template(klass->src_template, "src");
 434
 435     gst_pad_set_event_function(adecoder->srcpad,GST_DEBUG_FUNCPTR(gst_adecoder_src_event));
 436
 437         gst_pad_set_getcaps_function(adecoder->srcpad,gst_adecoder_src_getcaps);
 438
 439     gst_element_add_pad(GST_ELEMENT(adecoder), adecoder->srcpad);
 440
 441     element_class->query = gst_adecoder_query;
 442
 443     gst_adecoder_initialize_handle(adecoder);
 444
 445 }
 446
 447
 448 static gboolean gst_adecoder_query(GstElement *element, GstQuery *query)
 449 {
 450         GstStructure *query_struct;
 451
 452         GValue bitRate = {0};
 453
 454         GValue dspLoad = { 0, };
 455
 456         GstADecoder *adecoder = GST_ADECODER(element);
 457
 458         g_value_init(&bitRate,G_TYPE_UINT);
 459
 460         g_value_set_uint(&bitRate,adecoder->Status->bitRate);
 461
 462         g_value_init(&dspLoad, G_TYPE_INT);
 463
 464         g_value_set_int(&dspLoad, Engine_getCpuLoad(adecoder->ce));
 465
 466         query_struct = gst_query_get_structure(query);
 467
 468         gst_structure_set_value(query_struct,"bitRate",&bitRate);
 469
 470         gst_structure_set_value(query_struct, "dspCpuLoad", &dspLoad);
 471         g_value_unset(&bitRate);
 472
 473         g_value_unset(&dspLoad);
 474
 475         gst_object_unref(adecoder);
 476
 477         return TRUE;
 478 }
 479
 480 static void gst_adecoder_initialize_handle(GstADecoder * adecoder)
 481 {
 482
 483         adecoder->firstFrame = TRUE;
 484
 485         adecoder->inbuf = adecoder->inbuf_start_addr = NULL;
 486
 487         adecoder->outbuf[0] = NULL;
 488
 489         adecoder->outbuf[1] = NULL;
 490
 491         adecoder->readOffset = 0;
 492
 493         adecoder->codec_handle = NULL;
 494
 495         adecoder->ce = NULL;
 496
 497         adecoder->bytes_not_decoded = 0;
 498
 499         adecoder->bytesConsumed = 0;
 500
 501         adecoder->frameCount = 0;
 502
 503         adecoder->isEof = FALSE;
 504
 505         adecoder->isEos = FALSE;
 506
 507         adecoder->codec = 0;
 508
 509         adecoder->engine = 0;
 510
 511         adecoder->isEnginePropSet = FALSE;
 512
 513         adecoder->isCodecPropSet = FALSE;
 514
 515         adecoder->isPaused = FALSE;
 516
 517         adecoder->isStopped = FALSE;
 518
 519         adecoder->frame_time = 0;
 520
 521         adecoder->enable_processing = TRUE;
 522
 523         adecoder->start_decode = malloc(sizeof(pthread_mutex_t));
 524
 525         pthread_mutex_init(adecoder->start_decode, NULL);
 526
 527         pthread_mutex_lock(adecoder->start_decode);
 528
 529 }
 530
 531 static gboolean gst_adecoder_sink_activate(GstPad * sinkpad)
 532
 533 {
 534     GstADecoder *adecoder = GST_ADECODER(gst_pad_get_parent(sinkpad));
 535
 536     #ifdef DEBUG
 537
 538     printf("Sink Activate invoked\n");
 539
 540     #endif
 541
 542     if (gst_pad_check_pull_range(sinkpad))
 543     {
 544         adecoder->isInPushMode = FALSE;
 545
 546         gst_object_unref(adecoder);
 547
 548         return gst_pad_activate_pull(sinkpad, TRUE);
 549     }
 550
 551     else
 552     {
 553                 #ifdef DEBUG
 554
 555         printf("pull_range not supported on sinkpad\n");
 556
 557         printf("Running In Push Mode\n");
 558
 559         #endif
 560
 561         adecoder->isInPushMode = TRUE;
 562
 563         gst_object_unref(adecoder);
 564
 565         return gst_pad_activate_push(sinkpad, TRUE);
 566     }
 567
 568 }
 569
 570
 571 static gboolean gst_adecoder_sink_activate_pull(GstPad * sinkpad, gboolean active)
 572
 573 {
 574         GstADecoder *adecoder = GST_ADECODER(gst_pad_get_parent(sinkpad));
 575
 576         #ifdef DEBUG
 577
 578         printf("Activate pull invoked\n");
 579
 580         #endif
 581
 582         if (active)
 583
 584         gst_pad_start_task(sinkpad, (GstTaskFunction) gst_adecoder_loop,sinkpad);/* if we have a scheduler we can start the task */
 585
 586         else
 587
 588     gst_pad_stop_task(sinkpad);
 589
 590         gst_object_unref(adecoder);
 591
 592         return TRUE;
 593
 594 }
 595
 596 static void gst_adecoder_loop(GstPad * pad)
 597 {
 598         GstADecoder *adecoder = GST_ADECODER(gst_pad_get_parent(pad));
 599
 600         if(adecoder->isEos == FALSE && adecoder->isStopped == FALSE)
 601         {
 602
 603                 if(adecoder->initialized == FALSE)
 604                 {
 605                         if((adecoder->initialized = gst_adecoder_decoder_initialize(adecoder,NULL)) == FALSE)
 606                         {
 607                                 #ifdef DEBUG
 608
 609                                 printf("Could not initialize\n");
 610
 611                                 #endif
 612
 613                                 gst_object_unref(adecoder);
 614
 615                                 return;
 616                         }
 617                 }
 618
 619                 if(gst_adecoder_loop_get_data(adecoder) == FALSE)
 620                 {
 621                         gst_object_unref(adecoder);
 622
 623                         return;
 624                 }
 625
 626                 if (adecoder->enable_processing == FALSE)
 627                 {
 628 #ifdef DEBUG
 629
 630                         printf("Waiting on lock\n");
 631
 632 #endif
 633
 634                         pthread_mutex_lock(adecoder->start_decode);
 635
 636 #ifdef DEBUG
 637
 638                         printf("Lock succeeded\n");
 639
 640 #endif
 641
 642                 }
 643
 644                 if (adecoder->isPaused == TRUE)
 645                 {
 646                         gst_object_unref(adecoder);
 647
 648                         return;
 649                 }
 650
 651                 if(gst_adecoder_process_data(adecoder) == FALSE)
 652                 {
 653                         gst_object_unref(adecoder);
 654
 655                         return;
 656                 }
 657
 658                 if(adecoder->firstFrame == TRUE)
 659
 660                 gst_adecoder_initialize_osssink(adecoder);
 661
 662                 gst_adecoder_output_data(adecoder);
 663
 664         }
 665
 666         gst_object_unref(adecoder);
 667
 668 }
 669
 670 static gboolean gst_adecoder_loop_get_data(GstADecoder *adecoder)
 671 {
 672         GstBuffer *buf = NULL;
 673
 674         if(adecoder->bytes_not_decoded < adecoder->inBufSize && adecoder->isEof == FALSE)
 675         {
 676
 677                 if (gst_pad_pull_range(adecoder->sinkpad,adecoder->readOffset,INPUT_BUFFER_SIZE - adecoder->bytes_not_decoded,&buf) != GST_FLOW_OK)
 678                 {
 679                         #ifdef DEBUG
 680
 681                         printf("Pad pull range failed\n");
 682
 683                         #endif
 684
 685                         gst_pad_push_event(adecoder->srcpad, gst_event_new_eos());
 686
 687                         return FALSE;
 688
 689                 }
 690
 691                 if(GST_BUFFER_SIZE(buf) < INPUT_BUFFER_SIZE - adecoder->bytes_not_decoded)
 692
 693                 adecoder->isEof = TRUE;
 694
 695                 memmove(adecoder->inbuf_start_addr,adecoder->inbuf,adecoder->bytes_not_decoded);
 696
 697                 adecoder->inbuf = adecoder->inbuf_start_addr;
 698
 699                 memcpy((guint8 *) ((guint32) adecoder->inbuf + adecoder->bytes_not_decoded),GST_BUFFER_DATA(buf), GST_BUFFER_SIZE(buf));
 700
 701                 adecoder->bytes_not_decoded += GST_BUFFER_SIZE(buf);
 702
 703                 adecoder->readOffset += GST_BUFFER_SIZE(buf);
 704
 705                 gst_buffer_unref(buf);
 706
 707         }
 708
 709         if(adecoder->bytes_not_decoded <= 10)
 710         {
 711                 #ifdef DEBUG
 712
 713                 printf("No more data to decode....Sending EOS event to terminate...\n");
 714
 715                 printf("Bytes not decoded:%d\n",adecoder->bytes_not_decoded);
 716
 717                 #endif
 718
 719                 gst_pad_push_event(adecoder->srcpad, gst_event_new_eos());
 720
 721                 adecoder->isEos = TRUE;
 722
 723                 return FALSE;
 724
 725         }
 726
 727         return TRUE;
 728
 729 }
 730
 731 static GstFlowReturn gst_adecoder_chain(GstPad * pad,GstBuffer * input_buffer)
 732
 733 {
 734         GstADecoder *adecoder = GST_ADECODER(gst_pad_get_parent(pad));
 735
 736         if(adecoder->initialized == FALSE)
 737         {
 738
 739                 if((adecoder->initialized = gst_adecoder_decoder_initialize(adecoder,input_buffer)) == FALSE)
 740                 {
 741                         #ifdef DEBUG
 742
 743                         printf("Could not initialize\n");
 744
 745                         #endif
 746
 747                         gst_object_unref(adecoder);
 748
 749                         gst_buffer_unref(input_buffer);
 750
 751                         return GST_FLOW_ERROR;
 752                 }
 753
 754                 adecoder->initTimeStamp = GST_BUFFER_TIMESTAMP(input_buffer);
 755
 756         }
 757
 758         #ifdef DEBUG
 759
 760         printf("Buffer size from Demuxer:%d\n",GST_BUFFER_SIZE(input_buffer));
 761
 762         #endif
 763
 764         if(gst_adecoder_chain_get_data(adecoder,input_buffer) == FALSE)
 765         {
 766
 767                 gst_object_unref(adecoder);
 768
 769                 return GST_FLOW_OK;
 770         }
 771
 772         while(adecoder->bytes_not_decoded > adecoder->inBufSize && adecoder->isStopped == FALSE)
 773         {
 774                 if (adecoder->enable_processing == FALSE)
 775                 {
 776                         #ifdef DEBUG
 777
 778                         printf("Waiting on lock\n");
 779
 780                         #endif
 781
 782                         pthread_mutex_lock(adecoder->start_decode);
 783
 784                         #ifdef DEBUG
 785
 786                         printf("Lock succeeded\n");
 787
 788                         #endif
 789
 790                 }
 791
 792                 if( gst_adecoder_process_data(adecoder) == FALSE)
 793                 {
 794                         gst_object_unref(adecoder);
 795
 796                         return GST_FLOW_OK;
 797                 }
 798
 799                 if(adecoder->firstFrame == TRUE)
 800
 801                 gst_adecoder_initialize_osssink(adecoder);
 802
 803
 804                 if(gst_adecoder_output_data(adecoder) == FALSE)
 805                 {
 806                         gst_object_unref(adecoder);
 807
 808                         return GST_FLOW_ERROR;
 809                 }
 810         }
 811
 812         gst_object_unref(adecoder);
 813
 814         return GST_FLOW_OK;
 815 }
 816
 817
 818
 819 static gboolean gst_adecoder_chain_get_data(GstADecoder *adecoder,GstBuffer * buffer)
 820 {
 821         guint32 buf_size = GST_BUFFER_SIZE(buffer);
 822
 823         if(adecoder->inbuf != adecoder->inbuf_start_addr)
 824         {
 825
 826                 memmove(adecoder->inbuf_start_addr,adecoder->inbuf,adecoder->bytes_not_decoded);
 827
 828                 adecoder->inbuf = adecoder->inbuf_start_addr;
 829         }
 830
 831         if(adecoder->bytes_not_decoded + buf_size >= INPUT_BUFFER_SIZE)
 832         {
 833                 #ifdef DEBUG
 834
 835                 printf("Push mode:Not enough memory to save the buffer....current size:%d\n",adecoder->bytes_not_decoded);
 836
 837                 #endif
 838
 839                 gst_buffer_unref(buffer);
 840
 841                 return FALSE;
 842         }
 843
 844         memcpy((guint8 *) ((guint32) adecoder->inbuf + adecoder->bytes_not_decoded),(char *)(GST_BUFFER_DATA(buffer)),buf_size);
 845
 846         gst_buffer_unref(buffer);
 847
 848         adecoder->bytes_not_decoded += buf_size;
 849
 850         if(adecoder->bytes_not_decoded < adecoder->inBufSize)
 851
 852         return FALSE;
 853
 854         return TRUE;
 855
 856 }
 857
 858
 859 static gboolean gst_adecoder_process_data(GstADecoder *adecoder)
 860
 861 {
 862         #ifdef DEBUG
 863
 864         printf("Before calling AUDDEC_process\n");
 865
 866         #endif
 867
 868         if(AUDDEC_process(adecoder->codec_handle,&(adecoder->inBufDesc),&(adecoder->outBufDesc),adecoder->InArgs,adecoder->OutArgs) == AUDDEC_EOK)
 869         {
 870
 871                 #ifdef DEBUG
 872
 873                 printf("AUDDEC_process returned successfully,bytesConsumed:%d\n",adecoder->OutArgs->bytesConsumed);
 874
 875                 #endif
 876
 877                 adecoder->inbuf += adecoder->OutArgs->bytesConsumed;
 878
 879                 adecoder->bytes_not_decoded -= adecoder->OutArgs->bytesConsumed;
 880
 881                 AUDDEC_control(adecoder->codec_handle,XDM_GETSTATUS,adecoder->DyParams,adecoder->Status);
 882
 883                 adecoder->frameCount++;
 884
 885                 #ifdef DEBUG
 886
 887                 printf("FrameCount:%u FrameLen:%d SampleRate:%d BitsPerSample:%d BitRate:%d ",adecoder->frameCount,
 888
 889                 adecoder->Status->frameLen,adecoder->Status->sampleRate,adecoder->Status->outputBitsPerSample,adecoder->Status->bitRate);
 890
 891                 if(adecoder->Status->numChannels == IAUDIO_MONO)
 892
 893                 printf("IAUDIO_MONO\n");
 894
 895                 else
 896
 897                 printf("IAUDIO_STEREO\n");
 898
 899                 printf("bytes_not_decoded:%d\n",adecoder->bytes_not_decoded);
 900
 901                 #endif
 902
 903                 return TRUE;
 904
 905         }
 906
 907         else
 908         {
 909
 910                 #ifdef DEBUG
 911
 912                 printf("AUDDEC_process returned with failure\n");
 913
 914                 #endif
 915
 916                 return FALSE;
 917         }
 918
 919 }
 920
 921 static void gst_adecoder_initialize_osssink(GstADecoder *adecoder)
 922 {
 923         GstCaps *othercaps, *getcaps;
 924
 925         GstStructure *structure;
 926
 927         gint rate;
 928
 929         othercaps = gst_caps_new_simple ("audio/x-raw-int",
 930
 931         "endianness", G_TYPE_INT, G_BYTE_ORDER,
 932
 933         "signed", G_TYPE_BOOLEAN, TRUE,
 934
 935         "width", G_TYPE_INT, 16,
 936
 937         "depth", G_TYPE_INT, 16,
 938
 939         "rate", G_TYPE_INT,adecoder->Status->sampleRate,
 940
 941         "channels", G_TYPE_INT,DEFAULT_NO_OF_OUTPUT_CHANNELS, NULL);
 942
 943         if(gst_pad_set_caps(adecoder->srcpad, othercaps) == FALSE)
 944
 945         {
 946                 #ifdef DEBUG
 947
 948                 printf("Initialize osssink failed\n");
 949
 950                 #endif
 951
 952         }
 953
 954         gst_pad_use_fixed_caps(adecoder->srcpad);
 955
 956         getcaps = gst_pad_get_caps(adecoder->srcpad);
 957
 958         structure = gst_caps_get_structure(getcaps, 0);
 959
 960         gst_structure_get_int(structure,"rate",&rate);
 961
 962         #ifdef DEBUG
 963
 964         printf("Sampling Rate:%d\n",rate);
 965
 966         #endif
 967
 968         gst_caps_unref(othercaps);
 969
 970         if(adecoder->isInPushMode == FALSE)
 971
 972         gst_pad_push_event(adecoder->srcpad,
 973
 974                                            gst_event_new_new_segment(   FALSE,
 975
 976                                                                                                         adecoder->segment.rate,
 977
 978                                                                                                         adecoder->segment.format,
 979
 980                                                                                                         adecoder->segment.start,
 981
 982                                                                                                         adecoder->segment.duration,
 983
 984                                                                                                         adecoder->segment.start));
 985
 986
 987         if(adecoder->firstFrame == TRUE)
 988
 989         adecoder->firstFrame = FALSE;
 990
 991
 992 }
 993
 994 static gboolean gst_adecoder_output_data(GstADecoder *adecoder)
 995 {
 996         GstFlowReturn ret;
 997
 998         GstBuffer *outbuf[2];
 999
1000         guint32 frameLen = adecoder->Status->frameLen;
1001
1002         guint32 bitsPerSample = adecoder->Status->outputBitsPerSample;
1003
1004         guint8 numChannels = adecoder->Status->numChannels;
1005
1006     if(frameLen != 0)
1007     {
1008                 int i;
1009
1010                 for( i = 0; (i < adecoder->outBufDesc.numBufs);i++)
1011                 {
1012                         ret = gst_pad_alloc_buffer(adecoder->srcpad, GST_BUFFER_OFFSET_NONE,frameLen * DEFAULT_NO_OF_OUTPUT_CHANNELS * bitsPerSample / 8
1013
1014                         ,GST_PAD_CAPS(adecoder->srcpad),&(outbuf[i]));
1015
1016
1017                         if (ret != GST_FLOW_OK)
1018                         {
1019                                 #ifdef DEBUG
1020
1021                                 printf("failed when allocating a %ld bytes buffer\n",frameLen * DEFAULT_NO_OF_OUTPUT_CHANNELS * bitsPerSample / 8);
1022
1023                                 #endif
1024
1025                                 if ( (adecoder->isInPushMode == FALSE) && (adecoder->isPaused == FALSE) )
1026
1027                                 gst_pad_pause_task(adecoder->sinkpad);
1028
1029                                 return FALSE;
1030                         }
1031
1032                 }
1033
1034                 for( i = 0;(i < adecoder->outBufDesc.numBufs);i++)
1035             {
1036
1037                         if(adecoder->codec == ST_AUDIO_WMA && numChannels == IAUDIO_MONO) //WMA Decoder is not replicating data in case of MONO.
1038
1039                         {
1040                                 memcpy((char *)((unsigned)(adecoder->outbuf[i]) + frameLen * bitsPerSample / 8),
1041
1042                                 (char *)(adecoder->outbuf[i]),frameLen * bitsPerSample / 8);
1043
1044                                 block_to_interleaved((XDAS_Int16 *)(adecoder->outbuf[i]),(XDAS_Int8 *)GST_BUFFER_DATA(outbuf[i]),frameLen);
1045
1046                         }
1047
1048                         else
1049
1050                         {
1051                                 #ifndef INTERLEAVED
1052
1053                                 block_to_interleaved((XDAS_Int16 *)(adecoder->outbuf[i]),(XDAS_Int8 *)GST_BUFFER_DATA(outbuf[i]),frameLen);
1054
1055                                 #endif
1056
1057                                 memcpy((char *)GST_BUFFER_DATA(outbuf[i]),(char *)adecoder->outbuf[i],
1058
1059                                 frameLen * DEFAULT_NO_OF_OUTPUT_CHANNELS * bitsPerSample / 8);
1060
1061                         }
1062
1063                         if (gst_adecoder_send_data(adecoder,outbuf[i]) != GST_FLOW_OK)
1064
1065                         {
1066                                 #ifdef DEBUG
1067
1068                                 printf("Send data to osssink failed\n");
1069
1070                                 #endif
1071
1072                                 return FALSE;
1073                         }
1074
1075
1076                 }
1077
1078         }
1079
1080         return TRUE;
1081
1082 }
1083
1084
1085 static gboolean gst_adecoder_decoder_initialize(GstADecoder * adecoder,GstBuffer * input_buffer)
1086 {
1087         #ifdef DEBUG
1088
1089         printf ("Entering gst_adecoder_decoder_initialize...\n");
1090
1091         #endif
1092
1093         if(gst_adecoder_open_engine(adecoder) == FALSE)
1094
1095         return FALSE;
1096
1097         if(gst_adecoder_create_codec(adecoder,input_buffer) == FALSE)
1098
1099         return FALSE;
1100
1101         if(gst_adecoder_initialize_codec(adecoder) == FALSE)
1102
1103         return FALSE;
1104
1105         if(adecoder->isInPushMode == FALSE)
1106
1107         gst_segment_init(&adecoder->segment, GST_FORMAT_TIME);
1108
1109         #ifdef DEBUG
1110
1111         printf ("Exiting gst_adecoder_decoder_initialize...\n");
1112
1113         #endif
1114
1115         return TRUE;
1116 }
1117
1118
1119 static gboolean gst_adecoder_open_engine(GstADecoder * adecoder)
1120 {
1121
1122         CERuntime_init();
1123
1124         //GT_set("*=01234567,CE-1");
1125
1126         if(adecoder->isEnginePropSet == TRUE)
1127         {
1128                 switch (adecoder->engine)
1129
1130                 {
1131                         case H264ENGINE:
1132
1133                         #ifdef DEBUG
1134
1135                         printf ("Opening H264 Engine...\n");
1136
1137                         #endif
1138
1139                         adecoder->ce = Engine_open("H264Engine", NULL, NULL);
1140
1141                         break;
1142
1143                         case MPEG4ENGINE:
1144
1145                         #ifdef DEBUG
1146
1147                         printf ("Opening MPEG4 Engine...\n");
1148
1149                         #endif
1150
1151                         adecoder->ce = Engine_open("MPEG4Engine", NULL, NULL);
1152
1153                         break;
1154
1155                         case WMENGINE:
1156
1157                         #ifdef DEBUG
1158
1159                         printf ("Opening WM Engine...\n");
1160
1161                         #endif
1162
1163                         adecoder->ce = Engine_open("WMEngine", NULL, NULL);
1164
1165                         break;
1166
1167                         case MP3ENGINE:
1168
1169                         #ifdef DEBUG
1170
1171                         printf ("Opening MP3 Engine...\n");
1172
1173                         #endif
1174
1175                         adecoder->ce = Engine_open("MP3Engine", NULL, NULL);
1176
1177                         break;
1178
1179                 }
1180
1181         }
1182
1183         else if(adecoder->isCodecPropSet == TRUE)               //standalone case
1184         {
1185                 switch (adecoder->codec)
1186
1187                 {
1188                         case ST_AUDIO_AAC:
1189
1190                         #ifdef DEBUG
1191
1192                         printf ("Opening MPEG4 Engine...\n");
1193
1194                         #endif
1195
1196                         adecoder->ce = Engine_open("MPEG4Engine", NULL, NULL);
1197
1198                         break;
1199
1200                         case ST_AUDIO_WMA:
1201
1202                         #ifdef DEBUG
1203
1204                         printf ("Opening WM Engine...\n");
1205
1206                         #endif
1207
1208                         adecoder->ce = Engine_open("WMEngine", NULL, NULL);
1209
1210                         break;
1211
1212                         case ST_AUDIO_DSP_MP3:
1213
1214                         #ifdef DEBUG
1215
1216                         printf ("Opening MP3 Engine...\n");
1217
1218                         #endif
1219
1220                         adecoder->ce = Engine_open("MP3Engine", NULL, NULL);
1221
1222                         break;
1223
1224                 }
1225
1226         }
1227
1228         else
1229         {
1230                 #ifdef DEBUG
1231
1232                 printf ("Both properties not Set.....Opening H264 Engine by default..\n");
1233
1234                 #endif
1235
1236                 adecoder->ce = Engine_open("H264Engine", NULL, NULL);
1237
1238         }
1239
1240         if( adecoder->ce == NULL)
1241         {
1242                 #ifdef DEBUG
1243
1244                 printf("Engine_open failed\n");
1245
1246                 #endif
1247
1248                 return FALSE;
1249         }
1250
1251         return TRUE;
1252
1253 }
1254
1255
1256 static gboolean gst_adecoder_create_codec(GstADecoder * adecoder,GstBuffer * input_buffer)
1257 {
1258
1259     IAUDDEC_Params audParams;
1260     AUDDEC_Handle audDec;
1261
1262
1263     switch (adecoder->codec)
1264     {
1265         case ST_AUDIO_WMA:
1266         {
1267               #ifdef DEBUG
1268                   printf ("Creating WMA Codec...\n");
1269               #endif
1270
1271               audParams.size            =  sizeof(IAUDDEC_Params);
1272               audParams.maxSampleRate   =  48000;
1273               audParams.maxBitrate      =  384000;
1274               audParams.maxNoOfCh       =  IAUDIO_STEREO;
1275               audParams.dataEndianness  =  XDM_BYTE;
1276
1277               audDec = AUDDEC_create(adecoder->ce, "wma9dec", &audParams);
1278
1279               if (audDec == NULL)
1280               {
1281                  #ifdef DEBUG
1282                     printf("Engine handle:%x\n",adecoder->ce);
1283                     printf("AUDDEC_create failed\n");
1284                  #endif
1285                  return FALSE;
1286               }
1287        }
1288        break;
1289
1290        case ST_AUDIO_AAC:
1291        {
1292             #ifdef DEBUG
1293                 printf ("Creating AAC Codec...\n");
1294             #endif
1295
1296             audParams.size             =  sizeof(IAUDDEC_Params);
1297             audParams.maxSampleRate    =  48000;
1298             audParams.maxBitrate       =  448000;
1299             audParams.maxNoOfCh        =  IAUDIO_STEREO;
1300             audParams.dataEndianness   =  XDM_BYTE;
1301
1302             audDec = AUDDEC_create(adecoder->ce, "aachedec", &audParams);
1303
1304             if (audDec == NULL)
1305             {
1306                 #ifdef DEBUG
1307                    printf("AUDDEC_create failed\n");
1308                 #endif
1309                 return FALSE;
1310             }
1311         }
1312         break;
1313
1314         case ST_AUDIO_DSP_MP3:
1315         {
1316             #ifdef DEBUG
1317                 printf ("Creating DSP MP3 Codec...\n");
1318             #endif
1319
1320             audParams.size             =  sizeof(IAUDDEC_Params);
1321             audParams.maxSampleRate    =  48000;
1322             audParams.maxBitrate       =  448000;
1323             audParams.maxNoOfCh        =  IAUDIO_STEREO;
1324             audParams.dataEndianness   =  XDM_BYTE;
1325
1326             audDec = AUDDEC_create(adecoder->ce, "mp3dec", &audParams);
1327
1328             if (audDec == NULL)
1329             {
1330                #ifdef DEBUG
1331                  printf("AUDDEC_create failed\n");
1332                #endif
1333                return FALSE;
1334             }
1335         }
1336         break;
1337
1338         default:
1339                return FALSE;
1340     }
1341     adecoder->codec_handle = audDec;
1342
1343     #ifdef DEBUG
1344         printf ("Exiting Create Codec...\n");
1345     #endif
1346     return TRUE;
1347 }
1348
1349 static gboolean gst_adecoder_initialize_codec(GstADecoder * adecoder)
1350 {
1351
1352         IAUDDEC_DynamicParams *audDynamicParams = NULL;
1353         IAUDDEC_Status *audStatus = NULL;
1354         IAUDDEC_InArgs *InArgs = NULL;
1355         IAUDDEC_OutArgs *OutArgs = NULL;
1356         XDAS_Int32 ret1,ret2,ret3,ret4;
1357
1358
1359         #ifdef DEBUG
1360           printf ("Entering gst_adecoder_initialize_codec...\n");
1361         #endif
1362
1363         switch(adecoder->codec)
1364         {
1365                 case ST_AUDIO_WMA:
1366                 {
1367                    InArgs = (IAUDDEC_InArgs *)malloc(sizeof(IAUDDEC_InArgs));
1368                    InArgs->size =  sizeof(IAUDDEC_InArgs);
1369
1370                    OutArgs = (IAUDDEC_OutArgs *)malloc(sizeof(IAUDDEC_OutArgs));
1371                    OutArgs->size = sizeof(IAUDDEC_OutArgs);
1372
1373                    audStatus = (IAUDDEC_Status *)malloc(sizeof(IAUDDEC_Status));
1374                    audStatus->size =    sizeof(IAUDDEC_Status);
1375
1376                    audDynamicParams = (IAUDDEC_DynamicParams *)malloc(sizeof(IAUDDEC_DynamicParams));
1377                    audDynamicParams->size = sizeof(IAUDDEC_DynamicParams);
1378                 }
1379
1380                 break;
1381
1382                 case ST_AUDIO_AAC:
1383                 {
1384                    audStatus = (IAUDDEC_Status *)malloc(sizeof(IAUDDEC_Status));
1385                    audStatus->size =    sizeof(IAUDDEC_Status);
1386                 }
1387                 break;
1388         }
1389
1390         if(InArgs == NULL)
1391         {
1392                 InArgs = (IAUDDEC_InArgs *)malloc(sizeof(IAUDDEC_InArgs));
1393                 InArgs->size = sizeof(IAUDDEC_InArgs);
1394         }
1395
1396         if(audDynamicParams == NULL)
1397         {
1398                 audDynamicParams = (IAUDDEC_DynamicParams *)malloc(sizeof(IAUDDEC_DynamicParams));
1399                 audDynamicParams->size = sizeof(IAUDDEC_DynamicParams);
1400         }
1401
1402         if(OutArgs == NULL)
1403         {
1404                 OutArgs = (IAUDDEC_OutArgs *)malloc(sizeof(IAUDDEC_OutArgs));
1405                 OutArgs->size = sizeof(IAUDDEC_OutArgs);
1406         }
1407
1408         if(audStatus == NULL)
1409         {
1410                 audStatus       = (IAUDDEC_Status *)malloc(sizeof(IAUDDEC_Status));
1411                 audStatus->size = sizeof(IAUDDEC_Status);
1412         }
1413
1414         #ifdef DEBUG
1415
1416            printf("handle:%x audDynamicParams:%x Status:%x\n",adecoder->codec_handle,audDynamicParams,audStatus);
1417
1418         #endif
1419
1420            // ret1 = AUDDEC_control(adecoder->codec_handle,XDM_RESET,audDynamicParams,audStatus);
1421
1422            //   if (ret1 != AUDDEC_EOK)
1423            //{
1424            //#ifdef DEBUG
1425            //  printf("AUDDEC_control() 1 returned failure in gst_adecoder_initialize_codec()\n");
1426            //#endif
1427            //return FALSE;
1428            //}
1429
1430
1431         ret2 = AUDDEC_control(adecoder->codec_handle,XDM_SETDEFAULT,audDynamicParams,audStatus);
1432
1433
1434         #ifdef INTERLEAVED
1435             audDynamicParams->outputFormat = IAUDIO_INTERLEAVED;
1436         #else
1437             audDynamicParams->outputFormat = IAUDIO_BLOCK;
1438         #endif
1439
1440         ret3 = AUDDEC_control(adecoder->codec_handle,XDM_SETPARAMS, audDynamicParams,audStatus);
1441         ret4 = AUDDEC_control(adecoder->codec_handle,XDM_GETBUFINFO, audDynamicParams, audStatus);
1442
1443         if (ret2!= AUDDEC_EOK)
1444         {
1445                 #ifdef DEBUG
1446
1447                 printf("AUDDEC_control() 2 returned failure in gst_adecoder_initialize_codec()\n");
1448
1449                 #endif
1450
1451                 return FALSE;
1452         }
1453
1454         //      if (ret1 != AUDDEC_EOK || ret2!= AUDDEC_EOK || ret3 != AUDDEC_EOK || ret4 != AUDDEC_EOK)
1455         if (ret3 != AUDDEC_EOK)
1456         {
1457                 #ifdef DEBUG
1458
1459                 printf("AUDDEC_control() 3 returned failure in gst_adecoder_initialize_codec()\n");
1460
1461                 #endif
1462
1463                 return FALSE;
1464         }
1465
1466         if (ret4 != AUDDEC_EOK)
1467         {
1468                 #ifdef DEBUG
1469
1470                 printf("AUDDEC_control() 4 returned failure in gst_adecoder_initialize_codec()\n");
1471
1472                 #endif
1473
1474                 return FALSE;
1475         }
1476
1477
1478
1479         adecoder->inBufSize = audStatus->bufInfo.minInBufSize[0];
1480
1481         #ifdef DEBUG
1482
1483         printf("Input buffer size = %ld\n",audStatus->bufInfo.minInBufSize[0]);
1484
1485         #endif
1486
1487         adecoder->inbuf_start_addr = adecoder->inbuf = (XDAS_Int8 *) Memory_contigAlloc(INPUT_BUFFER_SIZE,Memory_DEFAULTALIGNMENT);
1488
1489         if (adecoder->inbuf == NULL)
1490         {
1491                 #ifdef DEBUG
1492
1493                 printf("Failed to allocate input buffer using CMEM\n");
1494
1495                 #endif
1496
1497                 return FALSE;
1498         }
1499
1500         {
1501                 int i;
1502
1503                 for(i = 0;i < audStatus->bufInfo.minNumOutBufs;i++)
1504                 {
1505                         adecoder->outBufSize[i] = audStatus->bufInfo.minOutBufSize[i];
1506
1507                         adecoder->outbuf[i] = (XDAS_Int8 *) Memory_contigAlloc(adecoder->outBufSize[i],Memory_DEFAULTALIGNMENT);
1508
1509                         if(adecoder->outbuf[i] == NULL)
1510                         {
1511                                 #ifdef DEBUG
1512
1513                                 printf("Failed to allocate output buffer using CMEM\n");
1514
1515                                 #endif
1516
1517                                 return FALSE;
1518                         }
1519                 }
1520         }
1521
1522
1523         adecoder->outBufDesc.bufSizes = adecoder->outBufSize;
1524
1525         adecoder->outBufDesc.numBufs = audStatus->bufInfo.minNumOutBufs;
1526
1527         adecoder->inBufDesc.bufSizes = &adecoder->inBufSize;
1528
1529         adecoder->inBufDesc.numBufs = 1;
1530
1531         adecoder->outBufDesc.bufs = adecoder->outbuf;
1532
1533         adecoder->inBufDesc.bufs = &(adecoder->inbuf);
1534
1535     InArgs->numBytes = adecoder->inBufSize;
1536
1537         adecoder->DyParams = audDynamicParams;
1538
1539         adecoder->Status = audStatus;
1540
1541         adecoder->InArgs = InArgs;
1542
1543         adecoder->OutArgs = OutArgs;
1544
1545         #ifdef DEBUG
1546
1547         printf ("Exiting gst_adecoder_initialize_codec...\n");
1548
1549         #endif
1550
1551         return TRUE;
1552
1553 }
1554
1555
1556 static void block_to_interleaved(XDAS_Int16 *src,XDAS_Int8 *dest,guint32 frameLen)
1557 {
1558         short i,j;
1559
1560         unsigned short c,c1,c2;
1561
1562         for(i = 0,j = 0;i < frameLen;i++,j += 4)
1563         {
1564                         /* Left Channel */
1565
1566                         c  = src[i];
1567
1568                         c1 = (c >> 8) & 0xff;
1569
1570                         c2 = c & 0xff;
1571
1572                         dest[j] = c2;
1573
1574                         dest[j+1] = c1;
1575
1576                         /* Right Channel  */
1577
1578                         c    = src[i+frameLen];
1579
1580                         c1 = (c >> 8) & 0xff;
1581
1582                         c2 = c & 0xff;
1583
1584                         dest[j+2] = c2;
1585
1586                         dest[j+3] = c1;
1587         }
1588
1589 }
1590
1591 #ifdef PROFILE
1592
1593 static unsigned long timeDiffMs(struct timespec *pTs1, struct timespec *pTs2)
1594 {
1595    unsigned long  delta = 0;
1596
1597    pTs1->tv_nsec /= 1000;
1598
1599    pTs2->tv_nsec /= 1000;
1600
1601    delta  = pTs2->tv_nsec > pTs1->tv_nsec ?
1602
1603             (pTs2->tv_sec - pTs1->tv_sec) * 1000000 + (pTs2->tv_nsec - pTs1->tv_nsec) :
1604
1605             (pTs2->tv_sec - pTs1->tv_sec - 1) * 1000000 + (1000000 - pTs1->tv_nsec + pTs2->tv_nsec);
1606
1607    return (delta);
1608 }
1609
1610 #endif
1611
1612 static GstFlowReturn gst_adecoder_send_data(GstADecoder * adecoder,GstBuffer * buffer)
1613 {
1614         #ifdef TIMESTAMP_ENABLE
1615
1616         if(adecoder->isInPushMode == TRUE)      //No timestamps in case of Pull mode / Standalone playback.
1617         {
1618
1619                 if(adecoder->frame_time == 0 && adecoder->initTimeStamp != 0)
1620
1621                 adecoder->frame_time = adecoder->initTimeStamp;
1622
1623                 else
1624
1625                 adecoder->frame_time += adecoder->Status->frameLen * NANO_SEC_PER_SEC / adecoder->Status->sampleRate;
1626
1627                 GST_BUFFER_TIMESTAMP(buffer) = adecoder->frame_time;
1628
1629                 #ifdef DEBUG
1630
1631                 printf("Timestamp value:%llu\n",GST_BUFFER_TIMESTAMP(buffer));
1632
1633                 #endif
1634         }
1635
1636         #endif
1637
1638         return gst_pad_push(adecoder->srcpad, buffer);
1639 }
1640
1641 static gboolean gst_adecoder_sink_event(GstPad * pad, GstEvent * event)
1642 {
1643
1644     GstADecoder *adecoder = GST_ADECODER(GST_PAD_PARENT(pad));
1645
1646     gboolean ret = TRUE;
1647
1648     #ifdef DEBUG
1649
1650     printf("Got %s event on sink pad\n", GST_EVENT_TYPE_NAME(event));
1651
1652     #endif
1653
1654     switch (GST_EVENT_TYPE(event))
1655     {
1656                 case GST_EVENT_NEWSEGMENT:
1657
1658                 ret = gst_pad_event_default(pad, event);
1659
1660                 break;
1661
1662         case GST_EVENT_FLUSH_START:
1663
1664         ret = gst_pad_event_default(pad, event);
1665
1666         break;
1667
1668         case GST_EVENT_FLUSH_STOP:
1669
1670         ret = gst_pad_event_default(pad, event);
1671
1672         break;
1673
1674         case GST_EVENT_EOS:
1675
1676                 gst_adecoder_decode_remaining(adecoder);
1677
1678         ret = gst_pad_event_default(pad, event);
1679
1680         break;
1681
1682         default:
1683
1684         ret = gst_pad_event_default(pad, event);
1685
1686         break;
1687     }
1688
1689     return ret;
1690 }
1691
1692 static void gst_adecoder_decode_remaining(GstADecoder * adecoder)
1693 {
1694
1695         while(adecoder->bytes_not_decoded > 10 && adecoder->isStopped == FALSE)
1696         {
1697                 if(adecoder->enable_processing == FALSE)
1698
1699                 pthread_mutex_lock(adecoder->start_decode);
1700
1701                 gst_adecoder_process_data(adecoder);
1702
1703                 if(gst_adecoder_output_data(adecoder) == FALSE)
1704
1705                 break;
1706
1707         }
1708
1709         #ifdef DEBUG
1710
1711         printf("bytes_not_decoded:%d\n",adecoder->bytes_not_decoded);
1712
1713         #endif
1714
1715 }
1716
1717 static gboolean gst_adecoder_src_event(GstPad * pad, GstEvent * event)
1718 {
1719     gboolean res;
1720
1721     GstADecoder *adecoder;
1722
1723     adecoder = GST_ADECODER(GST_PAD_PARENT(pad));
1724
1725     if (adecoder->codec_handle == NULL)
1726
1727     goto no_decoder;
1728
1729     res = gst_pad_push_event(adecoder->sinkpad, event);
1730
1731     return res;
1732
1733     no_decoder:
1734     {
1735         GST_DEBUG_OBJECT(adecoder, "no decoder, cannot handle event");
1736
1737         gst_event_unref(event);
1738
1739         return FALSE;
1740     }
1741 }
1742
1743 static GstStateChangeReturn gst_adecoder_change_state(GstElement * element, GstStateChange transition)
1744 {
1745     GstStateChangeReturn result;
1746
1747     GstADecoder *adecoder = GST_ADECODER(element);
1748
1749         switch (transition)
1750     {
1751         case GST_STATE_CHANGE_NULL_TO_READY:
1752
1753         GST_DEBUG_OBJECT(adecoder, "State Changed from NULL_TO_READY\n");
1754
1755         break;
1756
1757
1758         case GST_STATE_CHANGE_READY_TO_PAUSED:
1759
1760         GST_DEBUG_OBJECT(adecoder, "State Changed from READY_TO_PAUSED\n");
1761
1762         break;
1763
1764                 case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1765
1766         adecoder->isPaused = FALSE;
1767
1768                 break;
1769
1770                 default:
1771
1772         break;
1773     }
1774
1775     result = GST_ELEMENT_CLASS(parent_class)->change_state(element, transition);
1776
1777     switch (transition)
1778     {
1779         case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1780
1781         adecoder->isPaused = TRUE;
1782
1783         #ifdef DEBUG
1784
1785         printf("playing to paused\n");
1786
1787         #endif
1788
1789         break;
1790
1791         case GST_STATE_CHANGE_PAUSED_TO_READY:
1792
1793         adecoder->isStopped = TRUE;
1794
1795         #ifdef DEBUG
1796
1797         printf("paused to ready\n");
1798
1799         #endif
1800
1801         break;
1802
1803         case GST_STATE_CHANGE_READY_TO_NULL:
1804
1805         #ifdef DEBUG
1806
1807         printf("Ready to Null\n");
1808
1809         #endif
1810
1811         free(adecoder->DyParams);
1812
1813         free(adecoder->Status);
1814
1815         free(adecoder->InArgs);
1816
1817         free(adecoder->OutArgs);
1818
1819         pthread_mutex_unlock(adecoder->start_decode);
1820
1821         free(adecoder->start_decode);
1822
1823         if (adecoder->inbuf != NULL)
1824
1825                 Memory_contigFree((XDAS_Int8 *) (adecoder->inbuf_start_addr),INPUT_BUFFER_SIZE);
1826
1827                 if (adecoder->outbuf[0] != NULL)
1828
1829                 Memory_contigFree((XDAS_Int8 *) (adecoder->outbuf[0]),adecoder->outBufSize[0]);
1830
1831                 if (adecoder->outbuf[1] != NULL)
1832
1833                 Memory_contigFree((XDAS_Int8 *) (adecoder->outbuf[1]),adecoder->outBufSize[1]);
1834
1835                 AUDDEC_delete(adecoder->codec_handle);
1836
1837         Engine_close(adecoder->ce);
1838
1839                 gst_adecoder_initialize_handle(adecoder);
1840
1841         break;
1842
1843         default:
1844
1845         break;
1846     }
1847
1848     return result;
1849 }
1850
1851 static gboolean plugin_init(GstPlugin * plugin)
1852 {
1853     if (!gst_element_register(plugin, "adecoder", GST_RANK_PRIMARY, GST_TYPE_ADECODER))
1854
1855     return FALSE;
1856
1857         return TRUE;
1858 }
1859
1860 GST_PLUGIN_DEFINE(GST_VERSION_MAJOR,
1861
1862                   GST_VERSION_MINOR,
1863
1864                   "adecoder",
1865
1866                   "Audio Decoders",
1867
1868                   plugin_init,
1869
1870                   VERSION,
1871
1872                   GST_LICENSE_UNKNOWN, "adecoder", "http://www.ti.com/")
1873