ti_plugins/davinci/src/gstadecoder.c

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