hardware/ti/omap3/omx/audio/src/openmax_il/wma_dec/src/OMX_WmaDec_Utils.c

   1
   2 /*
   3  * Copyright (C) Texas Instruments - http://www.ti.com/
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; 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  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21 /* =============================================================================
  22  *             Texas Instruments OMAP (TM) Platform Software
  23  *  (c) Copyright Texas Instruments, Incorporated.  All Rights Reserved.
  24  *
  25  *  Use of this software is controlled by the terms and conditions found
  26  *  in the license agreement under which this software has been supplied.
  27  * =========================================================================== */
  28 /**
  29  * @file OMX_WmaDec_Utils.c
  30  *
  31  * This file implements OMX Component for WMA decoder that
  32  * is fully compliant with the OMX Audio specification 1.0.
  33  *
  34  * @path  $(CSLPATH)\
  35  *
  36  * @rev  0.1
  37  */
  38 /* ----------------------------------------------------------------------------
  39  *!
  40  *! Revision History
  41  *! ===================================
  42  *! 10-Sept-2005 mf:  Initial Version. Change required per OMAPSWxxxxxxxxx
  43  *! to provide _________________.
  44  *!
  45  *!
  46  *! 10-Sept-2005 mf:
  47  *! This is newest file
  48  * =========================================================================== */
  49
  50
  51 /* ------compilation control switches -------------------------*/
  52 /****************************************************************
  53  *  INCLUDE FILES
  54  ****************************************************************/
  55 /* ----- system and platform files ----------------------------*/
  56 #ifdef UNDER_CE
  57 #include <windows.h>
  58 #include <oaf_osal.h>
  59 #include <omx_core.h>
  60 #include <stdlib.h>
  61 #else
  62 #include <unistd.h>
  63 #include <sys/types.h>
  64
  65 #include <sys/types.h>
  66 #include <sys/stat.h>
  67 #include <dlfcn.h>
  68 #include <malloc.h>
  69 #include <memory.h>
  70 #include <fcntl.h>
  71 #include <errno.h>
  72 #include <dlfcn.h>
  73 #endif
  74 #include <dbapi.h>
  75 #include <string.h>
  76 #include <stdio.h>
  77
  78 #include "OMX_WmaDec_Utils.h"
  79 #include "wmadecsocket_ti.h"
  80 #include <decode_common_ti.h>
  81 #include "usn.h"
  82
  83 #ifdef UNDER_CE
  84 #define HASHINGENABLE 1
  85
  86
  87 void sleep(DWORD Duration)
  88 {
  89     Sleep(Duration);
  90 }
  91 #endif
  92
  93 /* ========================================================================== */
  94 /**
  95  * @WMADECFill_LCMLInitParams () This function is used by the component thread to
  96  * fill the all of its initialization parameters, buffer deatils  etc
  97  * to LCML structure,
  98  *
  99  * @param pComponent  handle for this instance of the component
 100  * @param plcml_Init  pointer to LCML structure to be filled
 101  *
 102  * @pre
 103  *
 104  * @post
 105  *
 106  * @return none
 107  */
 108 /* ========================================================================== */
 109 OMX_ERRORTYPE WMADECFill_LCMLInitParams(OMX_COMPONENTTYPE* pComponent,
 110                                         LCML_DSP *plcml_Init, OMX_U16 arr[])
 111 {
 112     OMX_ERRORTYPE eError = OMX_ErrorNone;
 113     OMX_U32 nIpBuf,nIpBufSize,nOpBuf,nOpBufSize;
 114     OMX_U16 i;
 115     OMX_BUFFERHEADERTYPE *pTemp;
 116     int size_lcml;
 117     OMX_U16 index;
 118     LCML_WMADEC_BUFHEADERTYPE *pTemp_lcml = NULL;
 119     LCML_STRMATTR *strmAttr = NULL;
 120     LCML_DSP_INTERFACE *pHandle;
 121     WMADEC_COMPONENT_PRIVATE *pComponentPrivate, *pComponentPrivate_CC;
 122
 123     pComponentPrivate = pComponent->pComponentPrivate;
 124     pComponentPrivate_CC = pComponentPrivate;
 125     pHandle = (LCML_DSP_INTERFACE *)pComponent;
 126
 127     OMX_PRINT2(pComponentPrivate->dbg, "[WMADECFill_LCMLInitParams] pComponent = %p",pComponent);
 128     OMX_PRINT2(pComponentPrivate->dbg, "[WMADECFill_LCMLInitParams] pComponentPrivate = %p",
 129                   pComponentPrivate);
 130     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entered WMADECFill_LCMLInitParams",__LINE__);
 131     OMX_PRINT2(pComponentPrivate->dbg, "%d :: WMADECFill_LCMLInitParams - pComponentPrivate = %p",
 132                   __LINE__,pComponentPrivate);
 133     OMX_PRINT2(pComponentPrivate->dbg, "%d :: WMADECFill_LCMLInitParams - pHandle = %p",__LINE__,
 134                   pHandle);
 135
 136     nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
 137     pComponentPrivate->nRuntimeInputBuffers = nIpBuf;
 138     nIpBufSize = INPUT_WMADEC_BUFFER_SIZE;
 139     nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
 140     pComponentPrivate->nRuntimeOutputBuffers = nOpBuf;
 141     nOpBufSize = pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferSize;
 142
 143     /* Fill Input Buffers Info for LCML */
 144     plcml_Init->In_BufInfo.nBuffers = nIpBuf;
 145     plcml_Init->In_BufInfo.nSize = nIpBufSize;
 146     plcml_Init->In_BufInfo.DataTrMethod = DMM_METHOD;
 147
 148
 149     /* Fill Output Buffers Info for LCML */
 150     plcml_Init->Out_BufInfo.nBuffers = pComponentPrivate_CC->pOutputBufferList->numBuffers;
 151     plcml_Init->Out_BufInfo.nSize = nOpBufSize;
 152     plcml_Init->Out_BufInfo.DataTrMethod = DMM_METHOD;
 153
 154     /*Copy the node information */
 155     plcml_Init->NodeInfo.nNumOfDLLs = 3;
 156
 157     plcml_Init->NodeInfo.AllUUIDs[0].uuid = &WMADECSOCKET_TI_UUID;
 158
 159     strcpy ((char *) plcml_Init->NodeInfo.AllUUIDs[0].DllName,WMADEC_DLL_NAME);
 160     plcml_Init->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
 161
 162     plcml_Init->NodeInfo.AllUUIDs[1].uuid = &WMADECSOCKET_TI_UUID;
 163     strcpy ((char *) plcml_Init->NodeInfo.AllUUIDs[1].DllName,WMADEC_DLL_NAME);
 164     plcml_Init->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
 165
 166     plcml_Init->NodeInfo.AllUUIDs[2].uuid = &USN_TI_UUID;
 167     strcpy ((char *) plcml_Init->NodeInfo.AllUUIDs[2].DllName,WMADEC_USN_DLL_NAME);
 168     plcml_Init->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
 169
 170
 171     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 172     plcml_Init->DeviceInfo.TypeofDevice =0;
 173
 174     OMX_MALLOC_SIZE_DSPALIGN(pComponentPrivate->pDynParams, sizeof(WMADEC_UALGParams), WMADEC_UALGParams);
 175
 176     pComponentPrivate->first_buffer=1;
 177
 178     if(pComponentPrivate_CC->dasfmode == 1)
 179     {
 180         OMX_MALLOC_SIZE_DSPALIGN(pComponentPrivate->pParams, sizeof(WMADEC_AudioCodecParams), WMADEC_AudioCodecParams);
 181
 182         OMX_MALLOC_GENERIC(strmAttr, LCML_STRMATTR);
 183         OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[ALLOC] %p",__LINE__,strmAttr);
 184
 185         if (strmAttr == NULL)
 186         {
 187             OMX_ERROR4(pComponentPrivate->dbg, "strmAttr - failed to malloc");
 188             eError = OMX_ErrorInsufficientResources;
 189             goto EXIT;
 190         }
 191         pComponentPrivate_CC->strmAttr = strmAttr;
 192         OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[ALLOC] %p",__LINE__,strmAttr);
 193         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 194
 195         strmAttr->uSegid = 0;
 196         strmAttr->uAlignment = 0;
 197         strmAttr->uTimeout = -1;
 198         strmAttr->uBufsize = pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferSize;
 199         strmAttr->uNumBufs = NUM_WMADEC_OUTPUT_BUFFERS_DASF;
 200         strmAttr->lMode = STRMMODE_PROCCOPY;
 201         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 202
 203         plcml_Init->DeviceInfo.TypeofDevice =1;
 204         plcml_Init->DeviceInfo.AllUUIDs[0].uuid = &DCTN_TI_UUID;
 205         plcml_Init->DeviceInfo.DspStream = strmAttr;
 206     }
 207
 208     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 209
 210     /*copy the other information */
 211     plcml_Init->SegID = OMX_WMADEC_DEFAULT_SEGMENT;
 212     plcml_Init->Timeout = OMX_WMADEC_SN_TIMEOUT;
 213     plcml_Init->Alignment = 0;
 214     plcml_Init->Priority = OMX_WMADEC_SN_PRIORITY;
 215     plcml_Init->ProfileID = -1;
 216     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 217     pComponentPrivate_CC->iWmaSamplingFrequeny = WMADEC_DEFAULT_SAMPLING_FREQUENCY;
 218
 219     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 220
 221
 222     /*Accessing these 2 has the problem/creates problem in state transition tests*/
 223     pComponentPrivate_CC->iWmaChannels =
 224         pComponentPrivate_CC->wmaParams[OUTPUT_PORT]->nChannels;
 225     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 226
 227     arr[0] = WMADEC_STREAM_COUNT;
 228     arr[1] = INPUT_PORT;
 229     arr[2] = DMM;
 230     if (pComponentPrivate_CC->pInputBufferList->numBuffers)
 231     {
 232         arr[3] = pComponentPrivate_CC->pInputBufferList->numBuffers;
 233     }
 234     else
 235     {
 236         arr[3] = 1;
 237     }
 238
 239     arr[4] = OUTPUT_PORT;
 240
 241     if(pComponentPrivate_CC->dasfmode == 1)
 242     {
 243         arr[5] = OUTSTRM;
 244         arr[6] = NUM_WMADEC_OUTPUT_BUFFERS_DASF;
 245     }
 246     else
 247     {
 248         OMX_PRDSP2(pComponentPrivate->dbg, "FILE MODE");
 249         arr[5] = DMM;
 250         if (pComponentPrivate_CC->pOutputBufferList->numBuffers)
 251         {
 252             arr[6] = pComponentPrivate_CC->pOutputBufferList->numBuffers;
 253         }
 254         else
 255         {
 256             arr[6] = 1;
 257         }
 258     }
 259     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 260
 261     index = WMADEC_STREAM_COUNT * 3 + 1;
 262     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 263
 264
 265 #ifndef UNDER_CE
 266     arr[index] = END_OF_CR_PHASE_ARGS;
 267
 268     for (i=0; i < index+1; i++) {
 269         OMX_PRINT2(pComponentPrivate->dbg, "arr[%d] = %d",i,arr[i]);
 270     }
 271
 272 #else
 273     arr[7] = END_OF_CR_PHASE_ARGS;
 274 #endif
 275
 276     plcml_Init->pCrPhArgs = arr;
 277
 278     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 279     size_lcml = nIpBuf * sizeof(LCML_WMADEC_BUFHEADERTYPE);
 280     OMX_MALLOC_SIZE(pTemp_lcml, size_lcml, LCML_WMADEC_BUFHEADERTYPE);
 281     OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[ALLOC] %p",__LINE__,pTemp_lcml);
 282     OMX_PRDSP2(pComponentPrivate->dbg, "Line %d::pTemp_lcml = %p",__LINE__,pTemp_lcml);
 283     if(pTemp_lcml == NULL)
 284     {
 285         /* Free previously allocated memory before bailing */
 286         OMX_MEMFREE_STRUCT(strmAttr);
 287         eError = OMX_ErrorInsufficientResources;
 288         goto EXIT;
 289     }
 290     pComponentPrivate_CC->pLcmlBufHeader[INPUT_PORT] = pTemp_lcml;
 291
 292     OMX_PRBUFFER2(pComponentPrivate->dbg, "nIpBuf = %ld",nIpBuf);
 293     for (i=0; i<nIpBuf; i++)
 294     {
 295         pTemp = pComponentPrivate_CC->pInputBufferList->pBufHdr[i];
 296         pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
 297         pTemp->nAllocLen = nIpBufSize;
 298         if(pComponentPrivate_CC->dasfmode == 0)
 299         {
 300             pTemp->nFilledLen = nIpBufSize;
 301         }
 302         else
 303         {
 304             pTemp->nFilledLen = 0;
 305         }
 306         pTemp->nVersion.s.nVersionMajor = WMADEC_MAJOR_VER;
 307         pTemp->nVersion.s.nVersionMinor = WMADEC_MINOR_VER;
 308         pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
 309         pTemp->nTickCount = NOT_USED;
 310         pTemp_lcml->buffer = pTemp;
 311         pTemp_lcml->eDir = OMX_DirInput;
 312         OMX_MALLOC_SIZE_DSPALIGN(pTemp_lcml->pIpParam,
 313                              sizeof(WMADEC_UAlgInBufParamStruct),
 314                              WMADEC_UAlgInBufParamStruct);
 315         if (pTemp_lcml->pIpParam == NULL)
 316         {
 317             /* Free previously allocated memory before bailing */
 318             OMX_MEMFREE_STRUCT(strmAttr);
 319             OMX_MEMFREE_STRUCT(pTemp_lcml );
 320
 321             goto EXIT;
 322         }
 323         pTemp_lcml->pIpParam->bLastBuffer = 0;
 324
 325         /* This means, it is not a last buffer. This flag is to be modified by
 326          * the application to indicate the last buffer */
 327         pTemp->nFlags = NORMAL_BUFFER;
 328
 329         pTemp_lcml++;
 330     }
 331
 332     /* Allocate memory for all output buffer headers..
 333      * This memory pointer will be sent to LCML */
 334     size_lcml = pComponentPrivate_CC->pOutputBufferList->numBuffers * sizeof(LCML_WMADEC_BUFHEADERTYPE);
 335     OMX_MALLOC_SIZE(pTemp_lcml, size_lcml, LCML_WMADEC_BUFHEADERTYPE);
 336     OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[ALLOC] %p",__LINE__,pTemp_lcml);
 337     if(pTemp_lcml == NULL)
 338     {
 339         /* Free previously allocated memory before bailing */
 340         OMX_MEMFREE_STRUCT(strmAttr);
 341         eError = OMX_ErrorInsufficientResources;
 342         goto EXIT;
 343     }
 344     pComponentPrivate_CC->pLcmlBufHeader[OUTPUT_PORT] = pTemp_lcml;
 345
 346     pComponentPrivate_CC->pOutputBufferList->EosFlagSent      = 0;
 347     pComponentPrivate_CC->InputEosSet = 0;
 348
 349     for (i=0; i<nOpBuf; i++)
 350     {
 351         pTemp = pComponentPrivate_CC->pOutputBufferList->pBufHdr[i];
 352         pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
 353         pTemp->nAllocLen = nOpBufSize;
 354         pTemp->nFilledLen = nOpBufSize;
 355         pTemp->nVersion.s.nVersionMajor = WMADEC_MAJOR_VER;
 356         pTemp->nVersion.s.nVersionMinor = WMADEC_MINOR_VER;
 357         pComponentPrivate_CC->nVersion = pTemp->nVersion.nVersion;
 358         pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
 359         pTemp->nTickCount = NOT_USED;
 360         /* This means, it is not a last buffer. This flag is to be modified by
 361          * the application to indicate the last buffer */
 362
 363         pTemp_lcml->buffer = pTemp;
 364         pTemp_lcml->eDir = OMX_DirOutput;
 365
 366         pTemp->nFlags = NORMAL_BUFFER;
 367
 368         pTemp++;
 369         pTemp_lcml++;
 370     }
 371     pComponentPrivate_CC->bPortDefsAllocated = 1;
 372
 373 #ifdef __PERF_INSTRUMENTATION__
 374     pComponentPrivate_CC->nLcml_nCntIp = 0;
 375     pComponentPrivate_CC->nLcml_nCntOpReceived = 0;
 376 #endif
 377     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting WMADECFill_LCMLInitParams",__LINE__);
 378
 379     pComponentPrivate_CC->bInitParamsInitialized = 1;
 380  EXIT:
 381     return eError;
 382 }
 383
 384
 385 /* ========================================================================== */
 386 /**
 387  * @WMADEC_StartComponentThread() This function is called by the component to create
 388  * the component thread, command pipe, data pipe and LCML Pipe.
 389  *
 390  * @param pComponent  handle for this instance of the component
 391  *
 392  * @pre
 393  *
 394  * @post
 395  *
 396  * @return none
 397  */
 398 /* ========================================================================== */
 399 OMX_ERRORTYPE WMADEC_StartComponentThread(OMX_HANDLETYPE pComponent)
 400 {
 401
 402     OMX_ERRORTYPE eError = OMX_ErrorNone;
 403     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 404     WMADEC_COMPONENT_PRIVATE *pComponentPrivate =
 405         (WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
 406 #ifdef UNDER_CE
 407     pthread_attr_t attr;
 408     memset(&attr, 0, sizeof(attr));
 409     attr.__inheritsched = PTHREAD_EXPLICIT_SCHED;
 410     attr.__schedparam.__sched_priority = OMX_AUDIO_DECODER_THREAD_PRIORITY;
 411 #endif
 412
 413     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Inside  WMADEC_StartComponentThread", __LINE__);
 414     /* Initialize all the variables*/
 415     pComponentPrivate->bIsStopping = 0;
 416     pComponentPrivate->bIsEOFSent = 0;
 417
 418
 419
 420     OMX_PRINT2(pComponentPrivate->dbg, "WMADEC_StartComponentThread  pComponentPrivate = %p",
 421                   pComponentPrivate);
 422     /* create the pipe used to send buffers to the thread */
 423     eError = pipe (pComponentPrivate->cmdDataPipe);
 424     if (eError)
 425     {
 426         eError = OMX_ErrorInsufficientResources;
 427         goto EXIT;
 428     }
 429
 430     /* create the pipe used to send buffers to the thread */
 431     eError = pipe (pComponentPrivate->dataPipe);
 432     if (eError)
 433     {
 434         eError = OMX_ErrorInsufficientResources;
 435         goto EXIT;
 436     }
 437
 438     /* create the pipe used to send commands to the thread */
 439     eError = pipe (pComponentPrivate->cmdPipe);
 440     if (eError)
 441     {
 442         eError = OMX_ErrorInsufficientResources;
 443         goto EXIT;
 444     }
 445
 446     /* Create the Component Thread */
 447 #ifdef UNDER_CE
 448     eError = pthread_create (&(pComponentPrivate->ComponentThread), &attr,
 449                              WMADEC_ComponentThread, pComponentPrivate);
 450 #else
 451     eError = pthread_create (&(pComponentPrivate->ComponentThread), NULL,
 452                              WMADEC_ComponentThread, pComponentPrivate);
 453 #endif
 454     if (eError || !pComponentPrivate->ComponentThread)
 455     {
 456         eError = OMX_ErrorInsufficientResources;
 457         goto EXIT;
 458     }
 459     pComponentPrivate->bCompThreadStarted = 1;
 460  EXIT:
 461     if (eError != OMX_ErrorNone ) {
 462         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
 463                                                pComponentPrivate->pHandle->pApplicationPrivate,
 464                                                OMX_EventError,
 465                                                eError,
 466                                                OMX_TI_ErrorSevere,
 467                                                NULL);
 468     }
 469     return eError;
 470 }
 471
 472 /* ========================================================================== */
 473 /**
 474  * @Mp3Dec_FreeCompResources() This function is called by the component during
 475  * de-init to close component thread, Command pipe, data pipe & LCML pipe.
 476  *
 477  * @param pComponent  handle for this instance of the component
 478  *
 479  * @pre
 480  *
 481  * @post
 482  *
 483  * @return none
 484  */
 485 /* ========================================================================== */
 486
 487 OMX_ERRORTYPE WMADEC_FreeCompResources(OMX_HANDLETYPE pComponent)
 488 {
 489     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 490     WMADEC_COMPONENT_PRIVATE *pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)
 491         pHandle->pComponentPrivate;
 492
 493     OMX_ERRORTYPE eError = OMX_ErrorNone;
 494     OMX_ERRORTYPE err = OMX_ErrorNone;
 495     OMX_U32 nIpBuf = 0;
 496     OMX_U32 nOpBuf = 0;
 497
 498     OMX_PRINT1(pComponentPrivate->dbg, "%d :: WMADEC_FreeCompResources", __LINE__);
 499
 500     OMX_PRBUFFER1(pComponentPrivate->dbg, "%d:::pComponentPrivate->bPortDefsAllocated = %ld",
 501                   __LINE__,pComponentPrivate->bPortDefsAllocated);
 502     if (pComponentPrivate->bPortDefsAllocated)
 503     {
 504         nIpBuf = pComponentPrivate->pPortDef[INPUT_PORT]->nBufferCountActual;
 505         nOpBuf = pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferCountActual;
 506     }
 507
 508     if (pComponentPrivate->bCompThreadStarted)
 509     {
 510         err = close (pComponentPrivate->dataPipe[0]);
 511
 512         if (0 != err && OMX_ErrorNone == eError)
 513         {
 514             eError = OMX_ErrorHardware;
 515         }
 516
 517         err = close (pComponentPrivate->dataPipe[1]);
 518         if (0 != err && OMX_ErrorNone == eError)
 519         {
 520             eError = OMX_ErrorHardware;
 521         }
 522
 523         err = close (pComponentPrivate->cmdPipe[0]);
 524         if (0 != err && OMX_ErrorNone == eError)
 525         {
 526             eError = OMX_ErrorHardware;
 527         }
 528
 529         err = close (pComponentPrivate->cmdPipe[1]);
 530         if (0 != err && OMX_ErrorNone == eError)
 531         {
 532             eError = OMX_ErrorHardware;
 533         }
 534
 535         OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 536         err = close (pComponentPrivate->cmdDataPipe[0]);
 537         OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 538         if (0 != err && OMX_ErrorNone == eError)
 539         {
 540             OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 541             eError = OMX_ErrorHardware;
 542             OMX_ERROR2(pComponentPrivate->dbg, "%d :: Error while closing cmdPipe",__LINE__);
 543         }
 544
 545         OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 546         err = close (pComponentPrivate->cmdDataPipe[1]);
 547         OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 548         if (0 != err && OMX_ErrorNone == eError)
 549         {
 550             OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 551             eError = OMX_ErrorHardware;
 552             OMX_ERROR2(pComponentPrivate->dbg, "%d :: Error while closing cmdPipe",__LINE__);
 553         }
 554
 555     }
 556
 557     if (pComponentPrivate->bPortDefsAllocated)
 558     {
 559         OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 560         if (pComponentPrivate->pPortDef[INPUT_PORT])
 561         {
 562             OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 563             OMX_PRCOMM2(pComponentPrivate->dbg, "freeing pComponentPrivate->pPortDef[INPUT_PORT] = \
 564                           %p",pComponentPrivate->pPortDef[INPUT_PORT]);
 565             OMX_MEMFREE_STRUCT(pComponentPrivate->pPortDef[INPUT_PORT]);
 566         }
 567         OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 568
 569         if (pComponentPrivate->pPortDef[OUTPUT_PORT])
 570         {
 571             OMX_PRINT1(pComponentPrivate->dbg, "%d:::[WMADEC_FreeCompResources] ", __LINE__);
 572             OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[OUTPUT_PORT] = %p",
 573                           pComponentPrivate->pPortDef[OUTPUT_PORT]);
 574             OMX_MEMFREE_STRUCT(pComponentPrivate->pPortDef[OUTPUT_PORT]);
 575         }
 576
 577         if (pComponentPrivate->wmaParams[INPUT_PORT])
 578         {
 579             OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->wmaParams[INPUT_PORT] = %p",
 580                           pComponentPrivate->wmaParams[INPUT_PORT]);
 581             OMX_MEMFREE_STRUCT(pComponentPrivate->wmaParams[INPUT_PORT]);
 582         }
 583
 584         if (pComponentPrivate->wmaParams[OUTPUT_PORT])
 585         {
 586             OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->wmaParams[OUTPUT_PORT] = %p",
 587                           pComponentPrivate->wmaParams[OUTPUT_PORT]);
 588             OMX_PRCOMM2(pComponentPrivate->dbg, "wmaParams[OUTPUT_PORT]->nPortIndex = %ld",
 589                           pComponentPrivate->wmaParams[OUTPUT_PORT]->nPortIndex);
 590             OMX_MEMFREE_STRUCT(pComponentPrivate->wmaParams[OUTPUT_PORT]);
 591             OMX_PRCOMM2(pComponentPrivate->dbg, "after pComponentPrivate->wmaParams[OUTPUT_PORT] = \
 592                           %p",pComponentPrivate->wmaParams[OUTPUT_PORT]);
 593         }
 594     }
 595     pComponentPrivate->bPortDefsAllocated = 0;
 596 #ifndef UNDER_CE
 597     OMX_PRDSP2(pComponentPrivate->dbg, "\n\n FreeCompResources: Destroying mutexes.\n");
 598     pthread_mutex_destroy(&pComponentPrivate->InLoaded_mutex);
 599     pthread_cond_destroy(&pComponentPrivate->InLoaded_threshold);
 600
 601     pthread_mutex_destroy(&pComponentPrivate->InIdle_mutex);
 602     pthread_cond_destroy(&pComponentPrivate->InIdle_threshold);
 603
 604     pthread_mutex_destroy(&pComponentPrivate->AlloBuf_mutex);
 605     pthread_cond_destroy(&pComponentPrivate->AlloBuf_threshold);
 606 #else
 607     OMX_DestroyEvent(&(pComponentPrivate->InLoaded_event));
 608     OMX_DestroyEvent(&(pComponentPrivate->InIdle_event));
 609     OMX_DestroyEvent(&(pComponentPrivate->AlloBuf_event));
 610
 611 #endif
 612
 613     OMX_PRINT1(pComponentPrivate->dbg, "Exiting Successfully WMADEC_FreeCompResources()");
 614     return eError;
 615 }
 616
 617
 618
 619 /* ========================================================================== */
 620 /**
 621  * WMADEC_CleanupInitParams() This functions cleans up initialization
 622  * parameters when shutting down
 623  *
 624  * @param pComponent  handle for this instance of the component
 625  *
 626  * @pre
 627  *
 628  * @post
 629  *
 630  * @return OMX Error code
 631  */
 632 /* ========================================================================== */
 633 OMX_ERRORTYPE WMADEC_CleanupInitParams(OMX_HANDLETYPE pComponent)
 634 {
 635
 636     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 637     WMADEC_COMPONENT_PRIVATE *pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)
 638         pHandle->pComponentPrivate;
 639
 640     LCML_WMADEC_BUFHEADERTYPE *pTemp_lcml;
 641
 642     OMX_ERRORTYPE eError = OMX_ErrorNone;
 643     OMX_U32 nIpBuf = 0;
 644     OMX_U16 i=0;
 645
 646     OMX_MEMFREE_STRUCT(pComponentPrivate->strmAttr);
 647
 648     OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pDynParams, WMADEC_UALGParams);
 649
 650     if (pComponentPrivate->dasfmode == 1)
 651     {
 652         OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pParams, WMADEC_AudioCodecParams);
 653     }
 654
 655     nIpBuf = pComponentPrivate->nRuntimeInputBuffers;
 656
 657     pTemp_lcml = pComponentPrivate->pLcmlBufHeader[INPUT_PORT];
 658     if(pTemp_lcml)
 659     {
 660         for(i=0; i<nIpBuf; i++)
 661         {
 662             OMX_PRDSP2(pComponentPrivate->dbg, "freeing pTemp_lcml->pIpParam = %p", pTemp_lcml->pIpParam);
 663             OMX_MEMFREE_STRUCT_DSPALIGN(pTemp_lcml->pIpParam, WMADEC_UAlgInBufParamStruct);
 664             pTemp_lcml++;
 665         }
 666     }
 667     OMX_PRCOMM2(pComponentPrivate->dbg, "freeing pComponentPrivate->pLcmlBufHeader[INPUT_PORT] = %p",
 668                   pComponentPrivate->pLcmlBufHeader[INPUT_PORT]);
 669
 670     OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[FREE] %p",__LINE__,
 671                     pComponentPrivate->pLcmlBufHeader[INPUT_PORT]);
 672
 673     OMX_MEMFREE_STRUCT(pComponentPrivate->pLcmlBufHeader[INPUT_PORT]);
 674     OMX_PRCOMM2(pComponentPrivate->dbg, "freeing pComponentPrivate->pLcmlBufHeader[OUTPUT_PORT] = %p",
 675                   pComponentPrivate->pLcmlBufHeader[OUTPUT_PORT]);
 676
 677     OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[FREE] %p",__LINE__,
 678                     pComponentPrivate->pLcmlBufHeader[OUTPUT_PORT]);
 679
 680     OMX_MEMFREE_STRUCT(pComponentPrivate->pLcmlBufHeader[OUTPUT_PORT]);
 681     OMX_PRINT1(pComponentPrivate->dbg, "Exiting Successfully WMADEC_CleanupInitParams()");
 682     return eError;
 683 }
 684
 685 /* ========================================================================== */
 686 /**
 687  * @WMADEC_StopComponentThread() This function is called by the component during
 688  * de-init to close component thread, Command pipe, data pipe & LCML pipe.
 689  *
 690  * @param pComponent  handle for this instance of the component
 691  *
 692  * @pre
 693  *
 694  * @post
 695  *
 696  * @return none
 697  */
 698 /* ========================================================================== */
 699
 700 OMX_ERRORTYPE WMADEC_StopComponentThread(OMX_HANDLETYPE pComponent)
 701 {
 702
 703     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 704     WMADEC_COMPONENT_PRIVATE *pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)
 705         pHandle->pComponentPrivate;
 706
 707     OMX_ERRORTYPE eError = OMX_ErrorNone;
 708     OMX_ERRORTYPE threadError = OMX_ErrorNone;
 709     int pthreadError = 0;
 710
 711     /*Join the component thread */
 712     pComponentPrivate->bIsStopping = 1;
 713     write (pComponentPrivate->cmdPipe[1], &pComponentPrivate->bIsStopping, sizeof(OMX_U16));
 714     OMX_PRINT1(pComponentPrivate->dbg, "%d:::About to call pthread_join",__LINE__);
 715     pthreadError = pthread_join (pComponentPrivate->ComponentThread,
 716                                  (void*)&threadError);
 717     OMX_PRDSP2(pComponentPrivate->dbg, "%d:::called pthread_join",__LINE__);
 718     if (0 != pthreadError)
 719     {
 720         eError = OMX_ErrorHardware;
 721         OMX_ERROR2(pComponentPrivate->dbg, "%d :: Error while closing Component Thread - pthreadError = %d",
 722                        __LINE__,pthreadError);
 723     }
 724
 725     /*Check for the errors */
 726     if (OMX_ErrorNone != threadError && OMX_ErrorNone != eError)
 727     {
 728         eError = OMX_ErrorInsufficientResources;
 729         OMX_ERROR2(pComponentPrivate->dbg, "%d :: Error while closing Component Thread",__LINE__);
 730     }
 731     OMX_PRINT1(pComponentPrivate->dbg, "Exiting Successfully from Stop Component thread");
 732     return eError;
 733 }
 734
 735
 736 /* ========================================================================== */
 737 /**
 738  * @WMADECHandleCommand() This function is called by the component when ever it
 739  * receives the command from the application
 740  *
 741  * @param pComponentPrivate  Component private data
 742  *
 743  * @pre
 744  *
 745  * @post
 746  *
 747  * @return none
 748  */
 749 /* ========================================================================== */
 750
 751 OMX_U32 WMADECHandleCommand (WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
 752 {
 753
 754     OMX_COMMANDTYPE command;
 755     OMX_STATETYPE commandedState;
 756     OMX_U32 commandData;
 757     char *pArgs = "damedesuStr";
 758 #ifndef UNDER_CE
 759     OMX_U16 i;
 760 #endif
 761     OMX_ERRORTYPE eError = OMX_ErrorNone;
 762     LCML_DSP_INTERFACE *pLcmlHandle;
 763     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
 764     pLcmlHandle = (LCML_DSP_INTERFACE *) pComponentPrivate->pLcmlHandle;
 765
 766     OMX_PRINT1(pComponentPrivate->dbg, "WMADECHandleCommand");
 767     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering WMADECHandleCommand Function - curState = %d",
 768                    __LINE__,pComponentPrivate->curState);
 769     read (pComponentPrivate->cmdPipe[0], &command, sizeof (command));
 770     if ((int)(read) == -1){
 771         pComponentPrivate->cbInfo.EventHandler (pHandle,
 772                                                 pHandle->pApplicationPrivate,
 773                                                 OMX_EventError,
 774                                                 eError,
 775                                                 OMX_TI_ErrorSevere,
 776                                                 NULL);
 777     }
 778     OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: Just read from the command pipe",__LINE__);
 779     OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: command = %d",__LINE__,command);
 780     read (pComponentPrivate->cmdDataPipe[0], &commandData, sizeof (commandData));
 781     if ((int)(read) == -1){
 782         pComponentPrivate->cbInfo.EventHandler (pHandle,
 783                                                 pHandle->pApplicationPrivate,
 784                                                 OMX_EventError,
 785                                                 eError,
 786                                                 OMX_TI_ErrorSevere,
 787                                                 NULL);
 788     }
 789
 790     OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: command = %d",__LINE__,command);
 791     OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: commandData = %ld",__LINE__,commandData);
 792
 793 #ifdef __PERF_INSTRUMENTATION__
 794     PERF_ReceivedCommand(pComponentPrivate->pPERFcomp,
 795                          command,
 796                          commandData,
 797                          PERF_ModuleLLMM);
 798 #endif
 799
 800
 801     if (command == OMX_CommandStateSet)
 802     {
 803         commandedState = (OMX_STATETYPE)commandData;
 804         switch(commandedState)
 805         {
 806         case OMX_StateIdle:
 807             eError = WMADEC_CommandToIdle(pComponentPrivate);
 808             break;
 809
 810         case OMX_StateExecuting:
 811
 812             eError = WMADEC_CommandToExecuting(pComponentPrivate);
 813             break;
 814
 815         case OMX_StateLoaded:
 816
 817             eError = WMADEC_CommandToLoaded(pComponentPrivate);
 818             break;
 819
 820         case OMX_StatePause:
 821
 822             eError = WMADEC_CommandToPause(pComponentPrivate);
 823             break;
 824
 825
 826         case OMX_StateWaitForResources:
 827
 828             eError = WMADEC_CommandToWaitForResources(pComponentPrivate);
 829             break;
 830
 831
 832         case OMX_StateInvalid:
 833
 834             OMX_PRSTATE2(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd OMX_StateInvalid:",
 835                           __LINE__);
 836
 837             if (pComponentPrivate->curState == commandedState)
 838             {
 839                 pComponentPrivate->cbInfo.EventHandler (pHandle,
 840                                                         pHandle->pApplicationPrivate,
 841                                                         OMX_EventError,
 842                                                         OMX_ErrorSameState,
 843                                                         OMX_TI_ErrorMinor,
 844                                                         NULL);
 845                 OMX_ERROR2(pComponentPrivate->dbg, "%d :: Error: Same State Given by Application",
 846                               __LINE__);
 847             }
 848             else
 849             {
 850                 if (pComponentPrivate->curState != OMX_StateWaitForResources &&
 851                     pComponentPrivate->curState != OMX_StateInvalid &&
 852                     pComponentPrivate->curState != OMX_StateLoaded)
 853                 {
 854
 855                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
 856                                                EMMCodecControlDestroy, (void *)pArgs);
 857                 }
 858                 OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
 859                 pComponentPrivate->curState = OMX_StateInvalid;
 860
 861                 pComponentPrivate->cbInfo.EventHandler(pHandle,
 862                                                        pHandle->pApplicationPrivate,
 863                                                        OMX_EventError,
 864                                                        OMX_ErrorInvalidState,
 865                                                        OMX_TI_ErrorMajor,
 866                                                        NULL);
 867
 868                 WMADEC_CleanupInitParams(pHandle);
 869             }
 870             break;
 871
 872         case OMX_StateMax:
 873             OMX_PRSTATE2(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd OMX_StateMax::",
 874                           __LINE__);
 875             break;
 876         default:
 877             OMX_PRSTATE2(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd Unknown::",
 878                           __LINE__);
 879             break;
 880         } /* End of Switch */
 881
 882     }
 883     else if (command == OMX_CommandMarkBuffer)
 884     {
 885         OMX_PRBUFFER2(pComponentPrivate->dbg, "command OMX_CommandMarkBuffer received %d",__LINE__);
 886         if(!pComponentPrivate->pMarkBuf)
 887         {
 888             OMX_PRBUFFER2(pComponentPrivate->dbg, "command OMX_CommandMarkBuffer received %d",__LINE__);
 889             /* TODO Need to handle multiple marks */
 890             pComponentPrivate->pMarkBuf = (OMX_MARKTYPE *)(commandData);
 891         }
 892     }
 893     else if (command == OMX_CommandPortDisable)
 894     {
 895         if (!pComponentPrivate->bDisableCommandPending)
 896         if(commandData == 0x0){
 897             /* disable port */
 898             for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
 899                 OMX_PRBUFFER2(pComponentPrivate->dbg, "pComponentPrivate->pInputBufferList->bBufferPending[%d] = %ld",i,
 900                               pComponentPrivate->pInputBufferList->bBufferPending[i]);
 901                 if (WMADEC_IsPending(pComponentPrivate,pComponentPrivate->pInputBufferList->pBufHdr[i],OMX_DirInput)) {
 902                     /* Real solution is flush buffers from DSP.  Until we have the ability to do that
 903                        we just call EmptyBufferDone() on any pending buffers */
 904                     OMX_PRBUFFER2(pComponentPrivate->dbg, "Forcing EmptyBufferDone");
 905 #ifdef __PERF_INSTRUMENTATION__
 906                     PERF_SendingFrame(pComponentPrivate->pPERFcomp,
 907                                       PREF(pComponentPrivate->pInputBufferList->pBufHdr[i], pBuffer),
 908                                       0,
 909                                       PERF_ModuleHLMM);
 910 #endif
 911                     pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
 912                                                                pComponentPrivate->pHandle->pApplicationPrivate,
 913                                                                pComponentPrivate->pInputBufferList->pBufHdr[i]);
 914                     pComponentPrivate->nEmptyBufferDoneCount++;
 915                 }
 916             }
 917             pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled = OMX_FALSE;
 918         }
 919
 920         if(commandData == -1){
 921             /* disable port */
 922             pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled = OMX_FALSE;
 923         }
 924         if(commandData == 0x1 || commandData == -1)
 925         {
 926
 927             pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled = OMX_FALSE;
 928             if (pComponentPrivate->curState == OMX_StateExecuting)
 929             {
 930                 pComponentPrivate->bNoIdleOnStop = OMX_TRUE;
 931                 if (pComponentPrivate->codecStop_waitingsignal == 0){
 932                     pthread_mutex_lock(&pComponentPrivate->codecStop_mutex);
 933                 }
 934                 eError = LCML_ControlCodec(
 935                                            ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
 936                                            MMCodecControlStop,(void *)pArgs);
 937                 if (pComponentPrivate->codecStop_waitingsignal == 0){
 938                     pthread_cond_wait(&pComponentPrivate->codecStop_threshold, &pComponentPrivate->codecStop_mutex);
 939                     pComponentPrivate->codecStop_waitingsignal = 0;
 940                     pthread_mutex_unlock(&pComponentPrivate->codecStop_mutex);
 941                 }
 942             }
 943         }
 944         OMX_PRCOMM2(pComponentPrivate->dbg, "commandData = %ld",commandData);
 945         OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated = %d",
 946                       pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated);
 947         OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated = %d",
 948                       pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated);
 949
 950         if(commandData == 0x0)
 951         {
 952             if(!pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated)
 953             {
 954                 /* return cmdcomplete event if input unpopulated */
 955                 pComponentPrivate->cbInfo.EventHandler(pHandle,
 956                                                        pHandle->pApplicationPrivate,
 957                                                        OMX_EventCmdComplete,
 958                                                        OMX_CommandPortDisable,
 959                                                        INPUT_PORT,
 960                                                        NULL);
 961                 pComponentPrivate->bDisableCommandPending = 0;
 962             }
 963             else
 964             {
 965                 pComponentPrivate->bDisableCommandPending = 1;
 966                 pComponentPrivate->bDisableCommandParam = commandData;
 967             }
 968         }
 969
 970         if(commandData == 0x1)
 971         {
 972             if (!pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated)
 973             {
 974                 /* return cmdcomplete event if output unpopulated */
 975                 pComponentPrivate->cbInfo.EventHandler(pHandle,
 976                                                        pHandle->pApplicationPrivate,
 977                                                        OMX_EventCmdComplete,
 978                                                        OMX_CommandPortDisable,
 979                                                        OUTPUT_PORT,
 980                                                        NULL);
 981                 pComponentPrivate->bDisableCommandPending = 0;
 982             }
 983             else
 984             {
 985                 pComponentPrivate->bDisableCommandPending = 1;
 986                 pComponentPrivate->bDisableCommandParam = commandData;
 987             }
 988         }
 989
 990         if(commandData == -1){
 991             if (!pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated &&
 992                 !pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated)
 993             {
 994
 995                 /* return cmdcomplete event if inout & output unpopulated */
 996                 pComponentPrivate->cbInfo.EventHandler(pHandle,
 997                                                        pHandle->pApplicationPrivate,
 998                                                        OMX_EventCmdComplete,
 999                                                        OMX_CommandPortDisable,
1000                                                        INPUT_PORT,
1001                                                        NULL);
1002
1003                 pComponentPrivate->cbInfo.EventHandler(pHandle,
1004                                                        pHandle->pApplicationPrivate,
1005                                                        OMX_EventCmdComplete,
1006                                                        OMX_CommandPortDisable,
1007                                                        OUTPUT_PORT,
1008                                                        NULL);
1009                 pComponentPrivate->bDisableCommandPending = 0;
1010             }
1011             else
1012             {
1013                 pComponentPrivate->bDisableCommandPending = 1;
1014                 pComponentPrivate->bDisableCommandParam = commandData;
1015             }
1016         }
1017     }
1018     else if (command == OMX_CommandPortEnable)
1019     {
1020         if(!pComponentPrivate->bEnableCommandPending){
1021             if(commandData == 0x0 || commandData == -1)
1022             {
1023                 /* enable in port */
1024                 OMX_PRCOMM2(pComponentPrivate->dbg, "setting input port to enabled");
1025                 pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled = OMX_TRUE;
1026                 OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled = %d",
1027                               pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled);
1028             }
1029             if(commandData == 0x1 || commandData == -1)
1030             {
1031                 /* enable out port */
1032                 char *pArgs = "damedesuStr";
1033                 pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled = OMX_TRUE;
1034                 OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled = %d",
1035                               pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled);
1036
1037                 if (pComponentPrivate->curState == OMX_StateExecuting && pComponentPrivate->bDspStoppedWhileExecuting){
1038                     pComponentPrivate->bDspStoppedWhileExecuting = OMX_FALSE;
1039
1040                     eError = LCML_ControlCodec(
1041                                                ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1042                                                EMMCodecControlStart,(void *)pArgs);
1043                 }
1044             }
1045         }
1046
1047         OMX_PRSTATE2(pComponentPrivate->dbg, "commandData = %ld",commandData);
1048         OMX_PRSTATE2(pComponentPrivate->dbg, "pComponentPrivate->curState = %d",
1049                       pComponentPrivate->curState);
1050         OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated = %d",
1051                       pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated);
1052         if(commandData == 0x0 )
1053         {
1054             if(pComponentPrivate->curState == OMX_StateLoaded ||
1055                pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated)
1056             {
1057                 if(pComponentPrivate->AlloBuf_waitingsignal)
1058                 {
1059                     pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1060                     pComponentPrivate->AlloBuf_waitingsignal = 0;
1061                     pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1062                     pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1063                 }
1064                 pComponentPrivate->cbInfo.EventHandler(pHandle,
1065                                                        pHandle->pApplicationPrivate,
1066                                                        OMX_EventCmdComplete,
1067                                                        OMX_CommandPortEnable,
1068                                                        INPUT_PORT, NULL);
1069                 pComponentPrivate->bEnableCommandPending = 0;
1070             }
1071             else
1072             {
1073                 pComponentPrivate->bEnableCommandPending = 1;
1074                 pComponentPrivate->bEnableCommandParam = commandData;
1075             }
1076         }
1077         else if(commandData == 0x1)
1078         {
1079             if(pComponentPrivate->curState ==
1080                OMX_StateLoaded ||
1081                pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated)
1082             {
1083                 if(pComponentPrivate->AlloBuf_waitingsignal){
1084                     pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1085                     pComponentPrivate->AlloBuf_waitingsignal = 0;
1086                     pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1087                     pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1088                 }
1089                 pComponentPrivate->cbInfo.EventHandler(pHandle,
1090                                                        pHandle->pApplicationPrivate,
1091                                                        OMX_EventCmdComplete,
1092                                                        OMX_CommandPortEnable,
1093                                                        OUTPUT_PORT, NULL);
1094                 if(pComponentPrivate->reconfigOutputPort){
1095                     pComponentPrivate->reconfigOutputPort = 0;
1096                     WMADECFill_LCMLInitParamsEx(pHandle,commandData);
1097                 }
1098
1099                 OMX_PRBUFFER2(pComponentPrivate->dbg, "pComponentPrivate->nNumInputBufPending=%ld",pComponentPrivate->nNumInputBufPending);
1100                 for (i=0; i < pComponentPrivate->nNumInputBufPending; i++){
1101                     if (pComponentPrivate->pInputBufHdrPending[i]){
1102                         LCML_WMADEC_BUFHEADERTYPE *pLcmlHdr;
1103                         if (!WMADEC_IsPending(pComponentPrivate,
1104                                               pComponentPrivate->pInputBufHdrPending[i],
1105                                               OMX_DirInput) ){
1106                             WMADECGetCorresponding_LCMLHeader(
1107                                                               pComponentPrivate,
1108                                                               pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
1109                                                               OMX_DirInput,
1110                                                               &pLcmlHdr);
1111                             WMADEC_SetPending(pComponentPrivate,
1112                                               pComponentPrivate->pInputBufHdrPending[i],
1113                                               OMX_DirInput);
1114                             OMX_PRBUFFER2(pComponentPrivate->dbg, "QUEUEING INPUT BUFFER");
1115                             OMX_PRBUFFER2(pComponentPrivate->dbg, "nfilledLen= %ld",pComponentPrivate->pInputBufHdrPending[i]->nFilledLen);
1116                             eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1117                                                       EMMCodecInputBuffer,
1118                                                       (OMX_U8 *)pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
1119                                                       pComponentPrivate->pInputBufHdrPending[i]->nAllocLen,
1120                                                       pComponentPrivate->pInputBufHdrPending[i]->nFilledLen,
1121                                                       (OMX_U8 *) pLcmlHdr->pIpParam,
1122                                                       sizeof(WMADEC_UAlgInBufParamStruct),
1123                                                       NULL);
1124                             if (eError != OMX_ErrorNone)
1125                             {
1126                                 OMX_ERROR4(pComponentPrivate->dbg, "ERROR IN QUEUEBUFFER");
1127                                 eError = OMX_ErrorHardware;
1128                                 goto EXIT;
1129                             }
1130                             pComponentPrivate->lcml_nCntIp++;
1131
1132                         }
1133                     }
1134                 }
1135                 pComponentPrivate->nNumInputBufPending=0;
1136                 pComponentPrivate->bEnableCommandPending = 0;
1137             }
1138             else
1139             {
1140                 pComponentPrivate->bEnableCommandPending = 1;
1141                 pComponentPrivate->bEnableCommandParam = commandData;
1142             }
1143         }
1144         else if(commandData == -1 )
1145         {
1146             if(pComponentPrivate->curState == OMX_StateLoaded ||
1147                (pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated &&
1148                 pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated))
1149             {
1150                 if(pComponentPrivate->AlloBuf_waitingsignal)
1151                 {
1152                     pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1153                     pComponentPrivate->AlloBuf_waitingsignal = 0;
1154                     pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1155                     pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1156                 }
1157                 pComponentPrivate->cbInfo.EventHandler(pHandle,
1158                                                        pHandle->pApplicationPrivate,
1159                                                        OMX_EventCmdComplete,
1160                                                        OMX_CommandPortEnable,
1161                                                        INPUT_PORT, NULL);
1162
1163                 pComponentPrivate->cbInfo.EventHandler(pHandle,
1164                                                        pHandle->pApplicationPrivate,
1165                                                        OMX_EventCmdComplete,
1166                                                        OMX_CommandPortEnable,
1167                                                        OUTPUT_PORT, NULL);
1168
1169                 pComponentPrivate->bEnableCommandPending = 0;
1170                 pComponentPrivate->reconfigOutputPort = 0;
1171                 WMADECFill_LCMLInitParamsEx(pHandle,commandData);
1172             }
1173             else
1174             {
1175                 pComponentPrivate->bEnableCommandPending = 1;
1176                 pComponentPrivate->bEnableCommandParam = commandData;
1177             }
1178         }
1179     }
1180     else if (command == OMX_CommandFlush)
1181     {
1182         OMX_U32 aParam[3] = {0};
1183         if(commandData == 0x0 || commandData == -1)
1184         {
1185             if (pComponentPrivate->nUnhandledEmptyThisBuffers == 0)  {
1186                 pComponentPrivate->bFlushInputPortCommandPending = OMX_FALSE;
1187
1188                 aParam[0] = USN_STRMCMD_FLUSH;
1189                 aParam[1] = 0x0;
1190                 aParam[2] = 0x0;
1191
1192                 if (pComponentPrivate->codecFlush_waitingsignal == 0){
1193                     pthread_mutex_lock(&pComponentPrivate->codecFlush_mutex);
1194                 }
1195                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1196                                            EMMCodecControlStrmCtrl, (void*)aParam);
1197
1198                 if (pComponentPrivate->codecFlush_waitingsignal == 0){
1199                     pthread_cond_wait(&pComponentPrivate->codecFlush_threshold, &pComponentPrivate->codecFlush_mutex);
1200                     pComponentPrivate->codecFlush_waitingsignal = 0;
1201                     pthread_mutex_unlock(&pComponentPrivate->codecFlush_mutex);
1202                 }
1203                 if (eError != OMX_ErrorNone) {
1204                     goto EXIT;
1205                 }
1206             }else {
1207                 pComponentPrivate->bFlushInputPortCommandPending = OMX_TRUE;
1208             }
1209
1210         }
1211
1212
1213         if(commandData == 0x1 || commandData == -1)
1214         {
1215             if (pComponentPrivate->nUnhandledFillThisBuffers == 0)  {
1216                 pComponentPrivate->bFlushOutputPortCommandPending = OMX_FALSE;
1217                 //ComponentPrivate->first_buff = 0;
1218
1219                 aParam[0] = USN_STRMCMD_FLUSH;
1220                 aParam[1] = 0x1;
1221                 aParam[2] = 0x0;
1222
1223                 OMX_PRCOMM2(pComponentPrivate->dbg, "Flushing output port");
1224                 if (pComponentPrivate->codecFlush_waitingsignal == 0){
1225                     pthread_mutex_lock(&pComponentPrivate->codecFlush_mutex);
1226                 }
1227                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1228                                            EMMCodecControlStrmCtrl, (void*)aParam);
1229
1230                 if (pComponentPrivate->codecFlush_waitingsignal == 0){
1231                     pthread_cond_wait(&pComponentPrivate->codecFlush_threshold, &pComponentPrivate->codecFlush_mutex);
1232                     pComponentPrivate->codecFlush_waitingsignal = 0;
1233                     pthread_mutex_unlock(&pComponentPrivate->codecFlush_mutex);
1234                 }
1235                 if (eError != OMX_ErrorNone) {
1236                     goto EXIT;
1237                 }
1238             } else {
1239                 pComponentPrivate->bFlushOutputPortCommandPending = OMX_TRUE;
1240             }
1241         }
1242
1243     }
1244  EXIT:
1245     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting WMADECHandleCommand Function",__LINE__);
1246     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning %d",__LINE__,eError);
1247     if (eError != OMX_ErrorNone && eError != EXIT_COMPONENT_THRD ) {
1248         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1249                                                pComponentPrivate->pHandle->pApplicationPrivate,
1250                                                OMX_EventError,
1251                                                eError,
1252                                                OMX_TI_ErrorSevere,
1253                                                NULL);
1254     }
1255     return eError;
1256 }
1257
1258 /* ========================================================================== */
1259 /**
1260  * @WMADECHandleDataBuf_FromApp() This function is called by the component when ever it
1261  * receives the buffer from the application
1262  *
1263  * @param pComponentPrivate  Component private data
1264  * @param pBufHeader Buffer from the application
1265  *
1266  * @pre
1267  *
1268  * @post
1269  *
1270  * @return none
1271  */
1272 /* ========================================================================== */
1273
1274 OMX_ERRORTYPE WMADECHandleDataBuf_FromApp(OMX_BUFFERHEADERTYPE* pBufHeader,
1275                                           WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
1276 {
1277     OMX_PRBUFFER2(pComponentPrivate->dbg, "At handle data buff from app device string is =%p",pComponentPrivate->sDeviceString);
1278     OMX_PRCOMM2(pComponentPrivate->dbg, "At handle databuff from app pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated =%d",
1279                   pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated);
1280     OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
1281     OMX_ERRORTYPE eError                                         = OMX_ErrorNone;
1282     OMX_DIRTYPE eDir;
1283     LCML_WMADEC_BUFHEADERTYPE *pLcmlHdr;
1284     LCML_DSP_INTERFACE *pLcmlHandle;
1285     WMADEC_COMPONENT_PRIVATE *pComponentPrivate_CC;
1286     OMX_U32 cmdValues[3];
1287     char *pArgs = "damedesuStr";
1288     char *p = "hello";
1289
1290     pComponentPrivate_CC = pComponentPrivate;
1291     pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLcmlHandle;
1292
1293     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering WMADECHandleDataBuf_FromApp Function",__LINE__);
1294
1295     /*Find the direction of the received buffer from buffer list */
1296     eError = WMADECGetBufferDirection(pBufHeader, &eDir);
1297     if (eError != OMX_ErrorNone)
1298     {
1299         OMX_ERROR4(pComponentPrivate->dbg, "%d :: The PBufHeader is not found in the list", __LINE__);
1300         goto EXIT;
1301     }
1302
1303     if (eDir == OMX_DirInput)
1304     {
1305         pComponentPrivate->nUnhandledEmptyThisBuffers--;
1306         if (pComponentPrivate->curState == OMX_StateIdle){
1307             pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1308                                                        pComponentPrivate->pHandle->pApplicationPrivate,
1309                                                        pBufHeader);
1310             OMX_PRBUFFER2(pComponentPrivate->dbg, ":: %d %s In idle state return input buffers", __LINE__, __FUNCTION__);
1311             goto EXIT;
1312         }
1313         pPortDefIn = pComponentPrivate->pPortDef[OMX_DirInput];
1314         if ( (pBufHeader->nFilledLen > 0) || (pBufHeader->nFlags & OMX_BUFFERFLAG_EOS))
1315         {
1316             pComponentPrivate->bBypassDSP = 0;
1317             eError = WMADECGetCorresponding_LCMLHeader(pComponentPrivate,
1318                                                        pBufHeader->pBuffer,
1319                                                        OMX_DirInput,
1320                                                        &pLcmlHdr);
1321             if (eError != OMX_ErrorNone)
1322             {
1323                 OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Invalid Buffer Came ...",__LINE__);
1324                 goto EXIT;
1325             }
1326
1327             OMX_PRBUFFER2(pComponentPrivate->dbg, "%d Comp:: Sending Filled Input buffer = %p, %p to LCML",
1328                            __LINE__,pBufHeader,pBufHeader->pBuffer);
1329
1330             OMX_PRBUFFER2(pComponentPrivate->dbg, "pBufHeader->nFilledLen :%ld ",pBufHeader->nFilledLen);
1331             pLcmlHdr->pIpParam->bLastBuffer = 0;
1332
1333 #ifdef __PERF_INSTRUMENTATION__
1334             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1335                               PREF(pBufHeader,pBuffer),
1336                               pPortDefIn->nBufferSize,
1337                               PERF_ModuleCommonLayer);
1338 #endif
1339             /** ring tone**/
1340             if(pComponentPrivate->SendAfterEOS == 1){
1341
1342                 if(pComponentPrivate->dasfmode == 1)
1343                 {
1344                     OMX_U32 pValues[4];
1345                     OMX_PRDSP2(pComponentPrivate->dbg, "%d :: ---- Comp: DASF Functionality is ON ---",__LINE__);
1346                     if (pComponentPrivate->pHeaderInfo->iChannel == 1)
1347                     {
1348                         pComponentPrivate->pParams->iAudioFormat = WMA_MONO_CHANNEL;
1349                     }
1350                     else
1351                     {
1352                         pComponentPrivate->pParams->iAudioFormat = WMA_STEREO_NON_INTERLEAVED;
1353                     }
1354                     OMX_PRINT1(pComponentPrivate->dbg, "pParams->iAudioFormat = %d", pComponentPrivate->pParams->iAudioFormat);
1355                     pComponentPrivate->pParams->iStrmId = pComponentPrivate->streamID;
1356                     pComponentPrivate->pParams->iSamplingRate =
1357                         pComponentPrivate->pHeaderInfo->iSamplePerSec;
1358
1359                     OMX_PRINT1(pComponentPrivate->dbg, "pParams->iSamplingRate = %ld",
1360                                   pComponentPrivate->pParams->iSamplingRate);
1361                     OMX_PRINT1(pComponentPrivate->dbg, "pParams->iStrmId = %ld",
1362                                   pComponentPrivate->pParams->iStrmId);
1363                     OMX_PRINT1(pComponentPrivate->dbg, "pParams->iAudioFormat = %d",
1364                                   pComponentPrivate->pParams->iAudioFormat);
1365
1366                     pValues[0] = USN_STRMCMD_SETCODECPARAMS;
1367                     pValues[1] = (OMX_U32)pComponentPrivate->pParams;
1368                     pValues[2] = sizeof(WMADEC_AudioCodecParams);
1369                     pValues[3] = OUTPUT_PORT;
1370                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1371                                                EMMCodecControlStrmCtrl,(void *)pValues);
1372                     if(eError != OMX_ErrorNone)
1373                     {
1374                         OMX_ERROR4(pComponentPrivate->dbg, "%d: Error Occurred in Codec StreamControl..",
1375                                       __LINE__);
1376                         goto EXIT;
1377                     }
1378                 }
1379 #ifdef ANDROID //this is used to separate changes made for integration with opencore 2.1 or later versions
1380
1381                 /* check if the buffer contains config data, it should only be the case in the fist input buffer*/
1382                 if(pBufHeader->nFlags & OMX_BUFFERFLAG_CODECCONFIG){
1383                     pComponentPrivate->bConfigData = 1; /* changed the if statement to use the buffer flag, now this flag doesnt do anything
1384                                                            we will leave it for now incase it becomes useful */
1385                     OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: UTIL: Before parsing ",__LINE__);
1386                     eError=WMADEC_Parser( pBufHeader->pBuffer,pComponentPrivate->rcaheader, pComponentPrivate->dbg);
1387                     OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: UTIL: After parsing ", __LINE__);
1388                     if (eError != OMX_ErrorNone)
1389                     {
1390                         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Parsing invalid ...",__LINE__);
1391                         goto EXIT;
1392                     }
1393                     /*******************Updating if needed*********************/
1394                     OMX_ERROR2(pComponentPrivate->dbg, "OLD: pComponentPrivate->wmaParams[OUTPUT_PORT]->nSamplingRate=%ld ",pComponentPrivate->wmaParams[OUTPUT_PORT]->nSamplingRate);
1395                     /* if(pComponentPrivate->wma_op->nSamplingRate != iSamplePerSec){
1396                        pComponentPrivate->wma_op->nSamplingRate=iSamplePerSec;
1397                        pComponentPrivate->reconfigOutputPort=1;
1398                        OMX_ERROR4(pComponentPrivate->dbg, "=================RECONFIGURATION NEEDED===============");
1399                        OMX_ERROR4(pComponentPrivate->dbg, "NEW: pComponentPrivate->wmaParams[OUTPUT_PORT]->nSamplingRate=%d ",pComponentPrivate->wmaParams[OUTPUT_PORT]->nSamplingRate);
1400                        }
1401                        if(pComponentPrivate->wma_op->nChannels != iChannel){
1402                        pComponentPrivate->wma_op->nChannels = iChannel;
1403                        pComponentPrivate->reconfigOutputPort=1;
1404                        OMX_ERROR4(pComponentPrivate->dbg, "=================RECONFIGURATION NEEDED===============");
1405                        }
1406                        if(pComponentPrivate->reconfigOutputPort){
1407                        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1408                        pComponentPrivate->pHandle->pApplicationPrivate,
1409                        OMX_EventPortSettingsChanged,
1410                        OUTPUT_PORT,
1411                        0,
1412                        NULL);
1413                        OMX_ERROR4(pComponentPrivate->dbg, "================= sent reconfig event to client==============="); */
1414                     pBufHeader->nFilledLen = 0;
1415                     pComponentPrivate->cbInfo.EmptyBufferDone (
1416                                                                pComponentPrivate->pHandle,
1417                                                                pComponentPrivate->pHandle->pApplicationPrivate,
1418                                                                pBufHeader
1419                                                                );
1420                     pComponentPrivate->nEmptyBufferDoneCount++;
1421
1422                     // }
1423                     pComponentPrivate->bConfigData = 0;
1424                     goto EXIT;
1425                 }
1426 #endif
1427                 if( pComponentPrivate->dasfmode )
1428                 {
1429                     pComponentPrivate->pDynParams->iOutputFormat = WMA_IAUDIO_BLOCK; /* EAUDIO_BLOCKED */
1430                 }
1431                 else
1432                 {
1433                     pComponentPrivate->pDynParams->iOutputFormat = WMA_IAUDIO_INTERLEAVED; /* EAUDIO_INTERLEAVED */
1434                 }
1435                 pComponentPrivate->pDynParams->size = sizeof( WMADEC_UALGParams );
1436
1437                 cmdValues[0] = WMA_IUALG_CMD_SETSTATUS;
1438                 cmdValues[1] = (OMX_U32)( pComponentPrivate->pDynParams );
1439                 cmdValues[2] = sizeof( WMADEC_UALGParams );
1440
1441                 p = (void *)&cmdValues;
1442                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1443                                            EMMCodecControlAlgCtrl, (void *)p);
1444                 if(eError != OMX_ErrorNone){
1445                     OMX_ERROR4(pComponentPrivate->dbg, "%d: Error Occurred in Codec algctrl..", __LINE__);
1446                     goto EXIT;
1447                 }
1448                 pComponentPrivate->bBypassDSP = 0;
1449
1450                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)(pComponentPrivate->pLcmlHandle))->pCodecinterfacehandle,
1451                                            EMMCodecControlStart, (void *)pArgs);
1452
1453                 if(eError != OMX_ErrorNone){
1454                     OMX_ERROR4(pComponentPrivate->dbg, "%d: Error Occurred in Codec Start..", __LINE__);
1455                     goto EXIT;
1456                 }
1457                 pComponentPrivate->SendAfterEOS = 0;
1458             }
1459             if (pBufHeader->nFlags & OMX_BUFFERFLAG_EOS){
1460                 pLcmlHdr->pIpParam->bLastBuffer = 1;
1461                 pComponentPrivate->SendAfterEOS = 1;
1462                 pComponentPrivate->InputEosSet = 1;
1463                 pComponentPrivate->pOutputBufferList->EosFlagSent = 0;
1464                 OMX_PRINT1(pComponentPrivate->dbg, "%d :: OMX_WmaDec_Utils.c : pComponentPrivate->SendAfterEOS %d",__LINE__,pComponentPrivate->SendAfterEOS);
1465              }
1466             /*Store tick count information*/
1467             pComponentPrivate->arrBufIndexTick[pComponentPrivate->IpBufindex] = pBufHeader->nTickCount;
1468             /* Store time stamp information */
1469             pComponentPrivate->arrBufIndex[pComponentPrivate->IpBufindex] = pBufHeader->nTimeStamp;
1470             pComponentPrivate->IpBufindex++;
1471             pComponentPrivate->IpBufindex %= pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferCountActual;
1472             OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: Output Buffer TimeStamp %lld", __LINE__, pComponentPrivate->arrBufIndex[pComponentPrivate->IpBufindex]);
1473 #ifdef ANDROID
1474             if(pComponentPrivate->first_buffer)
1475             {
1476                 pComponentPrivate->rcaheader->iPayload=pBufHeader->nFilledLen;
1477                 pComponentPrivate->rcaheader->iMaxPacketSize = pComponentPrivate->rcaheader->iPayload+31;
1478                 memmove(pBufHeader->pBuffer+75,pBufHeader->pBuffer,pBufHeader->nFilledLen);
1479                 memset(pBufHeader->pBuffer,0x00,75);
1480                 memcpy(pBufHeader->pBuffer + 16, &pComponentPrivate->rcaheader->iMaxPacketSize, 2);
1481                 memcpy(pBufHeader->pBuffer + 36, &pComponentPrivate->rcaheader->iTypeSpecific, 4);
1482                 memcpy(pBufHeader->pBuffer + 42, &pComponentPrivate->rcaheader->iFormatTag, 2);
1483                 memcpy(pBufHeader->pBuffer + 44, &pComponentPrivate->rcaheader->iChannel, 2);
1484                 memcpy(pBufHeader->pBuffer + 46, &pComponentPrivate->rcaheader->iSamplePerSec, 4);
1485                 memcpy(pBufHeader->pBuffer + 50, &pComponentPrivate->rcaheader->iAvgBytesPerSec, 4);
1486                 memcpy(pBufHeader->pBuffer + 54, &pComponentPrivate->rcaheader->iBlockAlign, 2);
1487                 memcpy(pBufHeader->pBuffer + 56, &pComponentPrivate->rcaheader->iValidBitsPerSample, 2);
1488                 memcpy(pBufHeader->pBuffer + 64, &pComponentPrivate->rcaheader->iEncodeOptV, 2);
1489                 memcpy(pBufHeader->pBuffer + 71, &pComponentPrivate->rcaheader->iPayload, 4);
1490                 pBufHeader->nFilledLen+=75;
1491                 pComponentPrivate->first_buffer=0;
1492             }
1493             else
1494             {
1495                 memmove(pBufHeader->pBuffer+5,pBufHeader->pBuffer,pBufHeader->nFilledLen);
1496                 memset(pBufHeader->pBuffer,0x00,5);
1497                 memcpy(pBufHeader->pBuffer + 1, &pComponentPrivate->rcaheader->iPayload, 4);
1498                 pBufHeader->nFilledLen+=5;
1499             }
1500             OMX_PRBUFFER2(pComponentPrivate->dbg, "Before sending input buffer");
1501             OMX_PRBUFFER2(pComponentPrivate->dbg, "pBufHeader->nFilledLen=%ld",pBufHeader->nFilledLen);
1502 #endif
1503             if (pComponentPrivate->curState == OMX_StateExecuting)
1504             {
1505                 if(!pComponentPrivate->bDspStoppedWhileExecuting)
1506                 {
1507                     if (!WMADEC_IsPending(pComponentPrivate,pBufHeader,OMX_DirInput))
1508                     {
1509                         if(!pComponentPrivate->reconfigOutputPort){
1510                             WMADEC_SetPending(pComponentPrivate,pBufHeader,OMX_DirInput);
1511                             eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
1512                                                       EMMCodecInputBuffer,
1513                                                       (OMX_U8 *)pBufHeader->pBuffer,
1514                                                       pBufHeader->nAllocLen,
1515                                                       pBufHeader->nFilledLen,
1516                                                       (OMX_U8 *) pLcmlHdr->pIpParam,
1517                                                       sizeof(WMADEC_UAlgInBufParamStruct),
1518                                                       NULL);
1519                             if (eError != OMX_ErrorNone)
1520                             {
1521                                 OMX_ERROR4(pComponentPrivate->dbg, "ERROR IN QUEUEBUFFER");
1522                                 OMX_ERROR4(pComponentPrivate->dbg, "%d ::IssuingDSP IP: Error Occurred",
1523                                                __LINE__);
1524                                 eError = OMX_ErrorHardware;
1525                                 goto EXIT;
1526                             }
1527                             pComponentPrivate->lcml_nCntIp++;
1528                         }
1529                         else
1530                         {
1531                             OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: UTIL: Bypassing the sending of input buffers to lcml",__LINE__);
1532                             pComponentPrivate->pInputBufHdrPending[pComponentPrivate->nNumInputBufPending++] = pBufHeader;
1533                             OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: UTIL: pComponentPrivate->nNumInputBufPending=%ld",__LINE__,
1534                                           pComponentPrivate->nNumInputBufPending);
1535                             /*pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1536                               pComponentPrivate->pHandle->pApplicationPrivate,
1537                               pBufHeader
1538                               );
1539                             */
1540                             OMX_PRBUFFER2(pComponentPrivate->dbg, "Don't queue buffers during a reconfig");
1541                         }
1542                     }
1543                 }
1544                 else
1545                 {
1546 #ifdef __PERF_INSTRUMENTATION__
1547                     PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1548                                       PREF(pBufHeader,pBuffer),
1549                                       0,
1550                                       PERF_ModuleHLMM);
1551 #endif
1552                     pBufHeader->nFilledLen = 0;
1553                     pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1554                                                                pComponentPrivate->pHandle->pApplicationPrivate,
1555                                                                pBufHeader);
1556
1557                 }
1558             }
1559             else if (pComponentPrivate->curState == OMX_StatePause)
1560             {
1561                 pComponentPrivate->pInputBufHdrPending[pComponentPrivate->nNumInputBufPending++] =
1562                     pBufHeader;
1563             }
1564         }
1565         else
1566         {
1567             pComponentPrivate->bBypassDSP = 1;
1568             OMX_PRBUFFER2(pComponentPrivate->dbg, "Forcing EmptyBufferDone");
1569 #ifdef __PERF_INSTRUMENTATION__
1570             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1571                               PREF(pComponentPrivate->pInputBufferList->pBufHdr[0], pBuffer),
1572                               0, PERF_ModuleHLMM);
1573 #endif
1574             pBufHeader->nFilledLen = 0;
1575             pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1576                                                        pComponentPrivate->pHandle->pApplicationPrivate,
1577                                                        pComponentPrivate->pInputBufferList->pBufHdr[0]);
1578
1579             pComponentPrivate->nEmptyBufferDoneCount++;
1580
1581         }
1582         if(pBufHeader->pMarkData)
1583         {
1584             /* copy mark to output buffer header */
1585             pComponentPrivate->pOutputBufferList->pBufHdr[0]->pMarkData =
1586                 pBufHeader->pMarkData;
1587             pComponentPrivate->pOutputBufferList->pBufHdr[0]->hMarkTargetComponent =
1588                 pBufHeader->hMarkTargetComponent;
1589
1590             /* trigger event handler if we are supposed to */
1591             if (pBufHeader->hMarkTargetComponent == pComponentPrivate->pHandle &&
1592                 pBufHeader->pMarkData)
1593             {
1594                 pComponentPrivate_CC->cbInfo.EventHandler(pComponentPrivate->pHandle,
1595                                                           pComponentPrivate->pHandle->pApplicationPrivate,
1596                                                           OMX_EventMark, 0, 0, pBufHeader->pMarkData);
1597             }
1598         }
1599         if (pComponentPrivate->bFlushInputPortCommandPending)
1600         {
1601             OMX_SendCommand(pComponentPrivate->pHandle,
1602                             OMX_CommandFlush,0,NULL);
1603         }
1604     }
1605     else if (eDir == OMX_DirOutput)
1606     {
1607         pComponentPrivate->nUnhandledFillThisBuffers--;
1608         if (pComponentPrivate->curState == OMX_StateIdle){
1609             pComponentPrivate->cbInfo.FillBufferDone (pComponentPrivate->pHandle,
1610                                                       pComponentPrivate->pHandle->pApplicationPrivate,
1611                                                       pBufHeader);
1612             OMX_PRBUFFER2(pComponentPrivate->dbg, ":: %d %s In idle state return output buffers", __LINE__, __FUNCTION__);
1613             goto EXIT;
1614         }
1615         OMX_PRBUFFER2(pComponentPrivate->dbg, "Sending output buffer to LCML ");
1616         OMX_PRBUFFER2(pComponentPrivate->dbg, "%d Comp:: Sending Emptied Output buffer=%p to LCML",
1617                        __LINE__,pBufHeader);
1618
1619 #ifdef __PERF_INSTRUMENTATION__
1620         PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
1621                           PREF(pBufHeader,pBuffer),
1622                           0,
1623                           PERF_ModuleCommonLayer);
1624 #endif
1625          if (pComponentPrivate->bBypassDSP == 0) {
1626              if (pComponentPrivate->curState == OMX_StateExecuting) {
1627                  if(!(pComponentPrivate->reconfigInputPort || pComponentPrivate->reconfigOutputPort)){
1628                      if (!WMADEC_IsPending(pComponentPrivate,pBufHeader,OMX_DirOutput)){
1629                         if(!pComponentPrivate->bDspStoppedWhileExecuting){
1630                             WMADEC_SetPending(pComponentPrivate,pBufHeader,OMX_DirOutput);
1631                                 pComponentPrivate->LastOutputBufferHdrQueued =  pBufHeader;
1632                                 eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
1633                                                           EMMCodecOuputBuffer,
1634                                                           (OMX_U8 *)pBufHeader->pBuffer,
1635                                                           pBufHeader->nAllocLen,
1636                                                           pBufHeader->nAllocLen,
1637                                                           NULL, 0, NULL);
1638
1639                                 if (eError != OMX_ErrorNone )
1640                                 {
1641                                     OMX_ERROR4(pComponentPrivate->dbg, "%d :: IssuingDSP OP: Error Occurred",
1642                                                    __LINE__);
1643                                     eError = OMX_ErrorHardware;
1644                                     goto EXIT;
1645                                 }
1646                             pComponentPrivate->lcml_nOpBuf++;
1647                             }
1648                         }
1649                 } else{
1650                      pComponentPrivate->pOutputBufHdrPending[pComponentPrivate->nNumOutputBufPending++] = pBufHeader;
1651                    OMX_PRBUFFER2(pComponentPrivate->dbg, "Don't queue while doing a reconfig:: output buffer, num pending = %ld", pComponentPrivate->nNumOutputBufPending);
1652                 }
1653              }else if (pComponentPrivate->curState == OMX_StatePause) {
1654                  pComponentPrivate->pOutputBufHdrPending[pComponentPrivate->nNumOutputBufPending++] = pBufHeader;
1655              }
1656          }
1657          if (pComponentPrivate->bFlushOutputPortCommandPending) {
1658             OMX_SendCommand( pComponentPrivate->pHandle, OMX_CommandFlush, 1, NULL);
1659          }
1660      }
1661     else
1662     {
1663         OMX_PRBUFFER2(pComponentPrivate->dbg, "%d : BufferHeader %p, Buffer %p Unknown ..........",
1664                       __LINE__,pBufHeader, pBufHeader->pBuffer);
1665         eError = OMX_ErrorBadParameter;
1666     }
1667  EXIT:
1668     OMX_PRINT1(pComponentPrivate->dbg, "%d : Exiting from  WMADECHandleDataBuf_FromApp ",__LINE__);
1669     if (eError != OMX_ErrorNone ) {
1670         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1671                                                pComponentPrivate->pHandle->pApplicationPrivate,
1672                                                OMX_EventError,
1673                                                eError,
1674                                                OMX_TI_ErrorSevere,
1675                                                NULL);
1676     }
1677     return eError;
1678 }
1679
1680 /*-------------------------------------------------------------------*/
1681 /**
1682  * WMADECGetBufferDirection () This function is used by the component thread to
1683  * request a buffer from the application.  Since it was called from 2 places,
1684  * it made sense to turn this into a small function.
1685  *
1686  * @param pData pointer to WMA Decoder Context Structure
1687  * @param pCur pointer to the buffer to be requested to be filled
1688  *
1689  * @retval none
1690  **/
1691 /*-------------------------------------------------------------------*/
1692
1693 OMX_ERRORTYPE WMADECGetBufferDirection(OMX_BUFFERHEADERTYPE *pBufHeader, OMX_DIRTYPE *eDir)
1694 {
1695     OMX_ERRORTYPE eError                                            = OMX_ErrorNone;
1696     WMADEC_COMPONENT_PRIVATE *pComponentPrivate = pBufHeader->pPlatformPrivate;
1697     OMX_U16 nBuf;
1698     OMX_BUFFERHEADERTYPE *pBuf                              = NULL;
1699     int flag = 1, i;
1700
1701     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering WMADECGetBufferDirection Function",__LINE__);
1702     OMX_PRINT1(pComponentPrivate->dbg, "%d :: pComponentPrivate = %p",__LINE__,pComponentPrivate);
1703     /*Search this buffer in input buffers list */
1704     OMX_PRBUFFER2(pComponentPrivate->dbg, "%d ::  WMADECGetBufferDirection Function",__LINE__);
1705     OMX_PRINT1(pComponentPrivate->dbg, "%d ::  pComponentPrivate = %p",__LINE__,pComponentPrivate);
1706     OMX_PRBUFFER1(pComponentPrivate->dbg, "%d ::  pComponentPrivate->pInputBufferList = %p",
1707                    __LINE__,pComponentPrivate->pInputBufferList);
1708     OMX_PRBUFFER2(pComponentPrivate->dbg, "%d ::  pComponentPrivate->pInputBufferList->numBuffers = %d",
1709                    __LINE__,pComponentPrivate->pInputBufferList->numBuffers);
1710
1711     nBuf = pComponentPrivate->pInputBufferList->numBuffers;
1712     for(i=0; i<nBuf; i++)
1713     {
1714         pBuf = pComponentPrivate->pInputBufferList->pBufHdr[i];
1715         if(pBufHeader == pBuf)
1716         {
1717             *eDir = OMX_DirInput;
1718             OMX_ERROR2(pComponentPrivate->dbg, "%d :: Buffer %p is INPUT BUFFER",__LINE__, pBufHeader);
1719             flag = 0;
1720             goto EXIT;
1721         }
1722     }
1723
1724     /*Search this buffer in input buffers list */
1725     nBuf = pComponentPrivate->pOutputBufferList->numBuffers;
1726
1727     for(i=0; i<nBuf; i++)
1728     {
1729         pBuf = pComponentPrivate->pOutputBufferList->pBufHdr[i];
1730         if(pBufHeader == pBuf)
1731         {
1732             *eDir = OMX_DirOutput;
1733             OMX_ERROR2(pComponentPrivate->dbg, "%d :: Buffer %p is OUTPUT BUFFER",__LINE__,
1734                            pBufHeader);
1735             flag = 0;
1736             goto EXIT;
1737         }
1738     }
1739
1740     if (flag == 1)
1741     {
1742         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Buffer %p is Not Found in the List",__LINE__,
1743                        pBufHeader);
1744         eError = OMX_ErrorUndefined;
1745         goto EXIT;
1746     }
1747  EXIT:
1748     OMX_ERROR1(pComponentPrivate->dbg, "%d :: Exiting WMADECGetBufferDirection Function",__LINE__);
1749     if (eError != OMX_ErrorNone ) {
1750         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1751                                                pComponentPrivate->pHandle->pApplicationPrivate,
1752                                                OMX_EventError,
1753                                                eError,
1754                                                OMX_TI_ErrorSevere,
1755                                                NULL);
1756     }
1757     return eError;
1758 }
1759
1760 /*-------------------------------------------------------------------*/
1761 /**
1762  * WMADECHandleDataBuf_FromLCML () This function is used by the component thread to
1763  * request a buffer from the application.  Since it was called from 2 places,
1764  * it made sense to turn this into a small function.
1765  *
1766  * @param pData pointer to WMA Decoder Context Structure
1767  * @param pCur pointer to the buffer to be requested to be filled
1768  *
1769  * @retval none
1770  **/
1771 /*-------------------------------------------------------------------*/
1772 OMX_ERRORTYPE WMADECHandleDataBuf_FromLCML(WMADEC_COMPONENT_PRIVATE* pComponentPrivate, LCML_WMADEC_BUFHEADERTYPE* msgBuffer)
1773 {
1774     OMX_ERRORTYPE eError = OMX_ErrorNone;
1775     int ret = 0;
1776
1777     OMX_COMPONENTTYPE* pHandle = (OMX_COMPONENTTYPE*)pComponentPrivate->pHandle;
1778     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering WMADECHandleDataBuf_FromLCML Function",__LINE__);
1779     OMX_PRINT2(pComponentPrivate->dbg, "%d :: pComponentPrivate = %p",__LINE__, pComponentPrivate);
1780     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering WMADECHandleDataBuf_FromLCML Function",  __LINE__);
1781
1782     if (ret == -1)
1783     {
1784         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error While reading from the LCML Pipe",__LINE__);
1785         eError = OMX_ErrorHardware;
1786         goto EXIT;
1787     }
1788
1789     OMX_PRINT2(pComponentPrivate->dbg, "%d :: Entering WMADECHandleDataBuf_FromLCML Function",__LINE__);
1790
1791     if (!(pComponentPrivate->bIsStopping))
1792     {
1793         if (msgBuffer->eDir == OMX_DirInput)
1794         {
1795             OMX_PRCOMM2(pComponentPrivate->dbg, "%d: Component Sending Empty Input buffer%p to App",__LINE__,msgBuffer->buffer);
1796             OMX_PRCOMM2(pComponentPrivate->dbg, "Sending Empty INPUT BUFFER to App = %p", msgBuffer->buffer->pBuffer);
1797
1798 #ifdef __PERF_INSTRUMENTATION__
1799             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1800                               PREF(msgBuffer->buffer,pBuffer),
1801                               0,  PERF_ModuleHLMM);
1802 #endif
1803             msgBuffer->buffer->nFilledLen = 0;
1804             pComponentPrivate->cbInfo.EmptyBufferDone (pHandle,
1805                                                        pHandle->pApplicationPrivate,
1806                                                        msgBuffer->buffer);
1807
1808             pComponentPrivate->nEmptyBufferDoneCount++;
1809         }
1810         else if (msgBuffer->eDir == OMX_DirOutput)
1811         {
1812             OMX_PRCOMM2(pComponentPrivate->dbg, "%d: Component Sending Filled Output buffer%p to App size = %ld",
1813                           __LINE__,msgBuffer->buffer,msgBuffer->buffer->nFilledLen);
1814 #ifdef __PERF_INSTRUMENTATION__
1815             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1816                               msgBuffer->buffer->pBuffer,
1817                               msgBuffer->buffer->nFilledLen,
1818                               PERF_ModuleHLMM);
1819 #endif
1820
1821             /*Copying tick count information to output buffer*/
1822             msgBuffer->buffer->nTickCount = (OMX_U32)pComponentPrivate->arrBufIndexTick[pComponentPrivate->OpBufindex];
1823
1824             /* Copying time stamp information to output buffer */
1825             msgBuffer->buffer->nTimeStamp = (OMX_TICKS)pComponentPrivate->arrBufIndex[pComponentPrivate->OpBufindex];
1826             pComponentPrivate->OpBufindex++;
1827             pComponentPrivate->OpBufindex %= pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferCountActual;
1828
1829             pComponentPrivate->cbInfo.FillBufferDone (pHandle,
1830                                                       pHandle->pApplicationPrivate,
1831                                                       msgBuffer->buffer);
1832
1833             pComponentPrivate->nOutStandingFillDones--;
1834             OMX_PRSTATE2(pComponentPrivate->dbg, "nOutstandingFillDones = %ld\n", pComponentPrivate->nOutStandingFillDones);
1835         }
1836         else
1837         {
1838             OMX_PRINT2(pComponentPrivate->dbg, "%d :: Wrong Direction dir = %d", __LINE__,msgBuffer->eDir);
1839             OMX_PRDSP2(pComponentPrivate->dbg, "%d: Component Got buffer %p From LCML", __LINE__,msgBuffer->buffer);
1840             eError = OMX_ErrorBadParameter;
1841             goto EXIT;
1842         }
1843     }
1844     else
1845     {
1846         OMX_PRINT2(pComponentPrivate->dbg, "%d :: Entering WMADECHandleDataBuf_FromLCML Function",
1847                        __LINE__);
1848         if (msgBuffer->eDir == OMX_DirInput)
1849         {
1850             OMX_PRBUFFER2(pComponentPrivate->dbg, "%d: Component Sending Empty Input buffer%p to App",
1851                           __LINE__,msgBuffer->buffer);
1852             OMX_PRCOMM2(pComponentPrivate->dbg, "Sending Empty INPUT BUFFER to App = %p",
1853                            msgBuffer->buffer->pBuffer);
1854
1855 #ifdef __PERF_INSTRUMENTATION__
1856             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1857                               PREF(msgBuffer->buffer,pBuffer),
1858                               0, PERF_ModuleHLMM);
1859 #endif
1860             msgBuffer->buffer->nFilledLen = 0;
1861             pComponentPrivate->cbInfo.EmptyBufferDone (pHandle,
1862                                                        pHandle->pApplicationPrivate,
1863                                                        msgBuffer->buffer);
1864             pComponentPrivate->nEmptyBufferDoneCount++;
1865         }
1866         else if (msgBuffer->eDir == OMX_DirOutput)
1867         {
1868             OMX_PRBUFFER2(pComponentPrivate->dbg, "%d: Component Sending Filled Output buffer%p to App",
1869                           __LINE__,msgBuffer->buffer);
1870             OMX_PRBUFFER2(pComponentPrivate->dbg, "Sending Filled OUTPUT BUFFER to App = %p",
1871                            msgBuffer->buffer->pBuffer);
1872
1873 #ifdef __PERF_INSTRUMENTATION__
1874             PERF_SendingBuffer(pComponentPrivate->pPERFcomp,
1875                                msgBuffer->buffer->pBuffer,
1876                                msgBuffer->buffer->nFilledLen,
1877                                PERF_ModuleHLMM);
1878 #endif
1879             pComponentPrivate->cbInfo.FillBufferDone (pHandle,
1880                                                       pHandle->pApplicationPrivate,
1881                                                       msgBuffer->buffer);
1882             pComponentPrivate->nOutStandingFillDones--;
1883             OMX_PRCOMM2(pComponentPrivate->dbg, "nOutstandingFillDones = %ld\n", pComponentPrivate->nOutStandingFillDones);
1884         }
1885     }
1886  EXIT:
1887     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting WMADECHandleDataBuf_FromLCML Function",
1888                    __LINE__);
1889     return eError;
1890 }
1891
1892 /* -------------------------------------------------------------------*/
1893 /**
1894  *  Callback() function will be called LCML component to write the msg
1895  *
1896  * @param msgBuffer                 This buffer will be returned by the LCML
1897  *
1898  * @retval OMX_NoError              Success, ready to roll
1899  *         OMX_Error_BadParameter   The input parameter pointer is null
1900  **/
1901 /*-------------------------------------------------------------------*/
1902
1903 OMX_ERRORTYPE WMADECLCML_Callback (TUsnCodecEvent event,void * args [10])
1904 {
1905     OMX_ERRORTYPE eError                                                   = OMX_ErrorNone;
1906     OMX_U8 *pBuffer                                                        = args[1];
1907     LCML_WMADEC_BUFHEADERTYPE *pLcmlHdr;
1908     WMADEC_COMPONENT_PRIVATE *pComponentPrivate_CC = NULL;
1909     OMX_COMPONENTTYPE *pHandle                                     = NULL;
1910 #ifdef WMADEC_DEBUG
1911     LCML_DSP_INTERFACE *phandle;
1912 #endif
1913     LCML_DSP_INTERFACE *pLcmlHandle;
1914     OMX_U16 i=0;
1915 #ifdef UNDER_CE
1916     int numCalls;
1917 #endif
1918
1919     pComponentPrivate_CC =
1920         (WMADEC_COMPONENT_PRIVATE*)((LCML_DSP_INTERFACE*)args[6])->pComponentPrivate;
1921     pHandle = pComponentPrivate_CC->pHandle;
1922
1923 #ifdef WMADEC_DEBUG
1924     phandle = (LCML_DSP_INTERFACE *)args[6];
1925 #endif
1926     pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate_CC->pLcmlHandle;
1927
1928     switch(event)
1929     {
1930     case EMMCodecDspError:
1931         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecDspError");
1932         break;
1933
1934     case EMMCodecInternalError:
1935         OMX_ERROR4(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecInternalError");
1936         break;
1937
1938     case EMMCodecInitError:
1939         OMX_ERROR4(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecInitError");
1940         break;
1941
1942     case EMMCodecDspMessageRecieved:
1943         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecDspMessageRecieved");
1944         break;
1945
1946     case EMMCodecBufferProcessed:
1947         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecBufferProcessed");
1948         break;
1949
1950     case EMMCodecProcessingStarted:
1951         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingStarted");
1952         break;
1953
1954     case EMMCodecProcessingPaused:
1955         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingPaused");
1956         break;
1957
1958     case EMMCodecProcessingStoped:
1959         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingStoped");
1960         break;
1961
1962     case EMMCodecProcessingEof:
1963         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingEof");
1964         break;
1965
1966     case EMMCodecBufferNotProcessed:
1967         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecBufferNotProcessed");
1968         break;
1969
1970     case EMMCodecAlgCtrlAck:
1971         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecAlgCtrlAck");
1972         break;
1973
1974     case EMMCodecStrmCtrlAck:
1975         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecStrmCtrlAck");
1976         break;
1977
1978     default:
1979         OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  Got event = %d",event);
1980         break;
1981     }
1982     OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Entering the WMADECLCML_Callback Function",__LINE__);
1983     OMX_PRINT2(pComponentPrivate_CC->dbg, "args = %p ",args[0]);
1984     OMX_PRINT2(pComponentPrivate_CC->dbg, "event = %d ",event);
1985
1986     if(event == EMMCodecBufferProcessed) {
1987         if( (OMX_U32)args [0] == EMMCodecInputBuffer) {
1988             OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: Input: pBuffer = %p",__LINE__, pBuffer);
1989             eError = WMADECGetCorresponding_LCMLHeader(pComponentPrivate_CC,
1990                                                        pBuffer,
1991                                                        OMX_DirInput,
1992                                                        &pLcmlHdr);
1993 #ifdef __PERF_INSTRUMENTATION__
1994             PERF_ReceivedFrame(pComponentPrivate_CC->pPERFcomp,
1995                                PREF(pLcmlHdr->buffer,pBuffer),
1996                                0, PERF_ModuleCommonLayer);
1997 #endif
1998             WMADEC_ClearPending(pComponentPrivate_CC,pLcmlHdr->buffer, OMX_DirInput);
1999
2000             if (eError != OMX_ErrorNone)
2001             {
2002                 OMX_ERROR4(pComponentPrivate_CC->dbg, "%d :: Error: Invalid Buffer Came ...",__LINE__);
2003                 goto EXIT;
2004             }
2005
2006 #ifdef UNDER_CE
2007             ((OMXBufferStatus*)pLcmlHdr->buffer->pAppPrivate)->EmptyBufferDone = 1;
2008 #endif
2009             WMADECHandleDataBuf_FromLCML(pComponentPrivate_CC, pLcmlHdr);
2010         }
2011         else if ((OMX_U32)args [0] == EMMCodecOuputBuffer)
2012         {
2013             OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: Output: pBuffer = %p",__LINE__, pBuffer);
2014             if (!WMADEC_IsValid(pComponentPrivate_CC,pBuffer,OMX_DirOutput))
2015             {
2016                 /* If the buffer we get back from the DSP is not valid call FillBufferDone
2017                    on a valid buffer */
2018 #ifdef __PERF_INSTRUMENTATION__
2019                 PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2020                                   pComponentPrivate_CC->pOutputBufferList->pBufHdr[pComponentPrivate_CC->nInvalidFrameCount++]->pBuffer,
2021                                   pComponentPrivate_CC->pOutputBufferList->pBufHdr[pComponentPrivate_CC->nInvalidFrameCount++]->nFilledLen,
2022                                   PERF_ModuleHLMM);
2023 #endif
2024                 pComponentPrivate_CC->cbInfo.FillBufferDone (pComponentPrivate_CC->pHandle,
2025                                                              pComponentPrivate_CC->pHandle->pApplicationPrivate,
2026                                                              pComponentPrivate_CC->pOutputBufferList->pBufHdr[pComponentPrivate_CC->nInvalidFrameCount++]
2027                                                              );
2028                 pComponentPrivate_CC->nOutStandingFillDones--;
2029             }
2030             else
2031             {
2032                 eError = WMADECGetCorresponding_LCMLHeader(pComponentPrivate_CC,
2033                                                            pBuffer,
2034                                                            OMX_DirOutput,
2035                                                            &pLcmlHdr);
2036                 WMADEC_ClearPending(pComponentPrivate_CC,pLcmlHdr->buffer, OMX_DirOutput);
2037                 if (eError != OMX_ErrorNone)
2038                 {
2039                     OMX_ERROR4(pComponentPrivate_CC->dbg, "%d :: Error: Invalid Buffer Came ...",
2040                                   __LINE__);
2041                     goto EXIT;
2042                 }
2043
2044
2045                 if(pComponentPrivate_CC->InputEosSet || pComponentPrivate_CC->pOutputBufferList->EosFlagSent)
2046                 {
2047                    OMX_PRDSP2(pComponentPrivate_CC->dbg, " EOS Flag OR INPUT EOS ");
2048                    pComponentPrivate_CC->InputEosSet = 0;
2049                    pComponentPrivate_CC->pOutputBufferList->EosFlagSent = 0;
2050                    pLcmlHdr->buffer->nFlags |= OMX_BUFFERFLAG_EOS;
2051                 }
2052
2053                 pLcmlHdr->buffer->nFilledLen = (OMX_U32)args[8];
2054
2055                 OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "pLcmlHdr->buffer->nFilledLen = %ld", pLcmlHdr->buffer->nFilledLen);
2056
2057 #ifdef __PERF_INSTRUMENTATION__
2058                 PERF_ReceivedFrame(pComponentPrivate_CC->pPERFcomp,
2059                                    PREF(pLcmlHdr->buffer,pBuffer),
2060                                    PREF(pLcmlHdr->buffer,nFilledLen),
2061                                    PERF_ModuleCommonLayer);
2062
2063                 pComponentPrivate_CC->lcml_nCntOpReceived++;
2064                 OMX_PRDSP2(pComponentPrivate_CC->dbg, "pComponentPrivate_CC->lcml_nCntOpReceived = %ld\n", pComponentPrivate_CC->lcml_nCntOpReceived);
2065
2066                 if ((pComponentPrivate_CC->nLcml_nCntIp >= 1) &&
2067                     (pComponentPrivate_CC->nLcml_nCntOpReceived == 1))
2068                 {
2069                     PERF_Boundary(pComponentPrivate_CC->pPERFcomp,
2070                                   PERF_BoundaryStart | PERF_BoundarySteadyState);
2071                 }
2072 #endif
2073
2074 #ifdef UNDER_CE
2075                 ((OMXBufferStatus*)pLcmlHdr->buffer->pAppPrivate)->FillBufferDone = 1;
2076 #endif
2077                 OMX_PRBUFFER2(pComponentPrivate_CC->dbg, " OUTPUT RETURNING pBuffer->nFilledLen =%ld",pLcmlHdr->buffer->nFilledLen);
2078                 WMADECHandleDataBuf_FromLCML(pComponentPrivate_CC, pLcmlHdr);
2079             }
2080         }
2081     }
2082     else if (event == EMMCodecStrmCtrlAck)
2083     {
2084         OMX_PRDSP2(pComponentPrivate_CC->dbg, "%d :: GOT MESSAGE USN_DSPACK_STRMCTRL ----",__LINE__);
2085
2086         if (args[1] == (void *)USN_STRMCMD_FLUSH)
2087         {
2088             pHandle = pComponentPrivate_CC->pHandle;
2089             if ( args[2] == (void *)EMMCodecInputBuffer)
2090             {
2091                 if (args[0] == (void *)USN_ERR_NONE )
2092                 {
2093
2094                     for (i=0; i < pComponentPrivate_CC->nNumInputBufPending; i++) {
2095 #ifdef __PERF_INSTRUMENTATION__
2096                         PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2097                                           PREF(pComponentPrivate_CC->pInputBufHdrPending[i],pBuffer),
2098                                           0,
2099                                           PERF_ModuleHLMM);
2100 #endif
2101                         pComponentPrivate_CC->pInputBufHdrPending[i]->nFilledLen = 0;
2102                         pComponentPrivate_CC->cbInfo.EmptyBufferDone (pComponentPrivate_CC->pHandle,
2103                                                                       pComponentPrivate_CC->pHandle->pApplicationPrivate,
2104                                                                       pComponentPrivate_CC->pInputBufHdrPending[i]);
2105                         pComponentPrivate_CC->nEmptyBufferDoneCount++;
2106                         pComponentPrivate_CC->pInputBufHdrPending[i] = NULL;
2107                     }
2108                     pComponentPrivate_CC->nNumInputBufPending=0;
2109
2110                     pthread_mutex_lock(&pComponentPrivate_CC->codecFlush_mutex);
2111                     if(pComponentPrivate_CC->codecFlush_waitingsignal == 0){
2112                         pComponentPrivate_CC->codecFlush_waitingsignal = 1;
2113                         pthread_cond_signal(&pComponentPrivate_CC->codecFlush_threshold);
2114                         OMX_PRCOMM2(pComponentPrivate_CC->dbg, "flush ack. received. for input port");
2115                     }
2116                     pthread_mutex_unlock(&pComponentPrivate_CC->codecFlush_mutex);
2117                     // mutex above signals that the dsp side has finished flushing and processing can continue
2118                     pComponentPrivate_CC->cbInfo.EventHandler(pHandle,
2119                                                               pHandle->pApplicationPrivate,
2120                                                               OMX_EventCmdComplete,
2121                                                               OMX_CommandFlush,
2122                                                               INPUT_PORT,
2123                                                               NULL);
2124                 }
2125                 else
2126                 {
2127                     goto EXIT;
2128                 }
2129             }
2130             else if ( args[2] == (void *)EMMCodecOuputBuffer)
2131             {
2132                 if (args[0] == (void *)USN_ERR_NONE )
2133                 {
2134                     for (i=0; i < pComponentPrivate_CC->nNumOutputBufPending; i++) {
2135 #ifdef __PERF_INSTRUMENTATION__
2136                         PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2137                                           PREF(pComponentPrivate_CC->pOutputBufHdrPending[i],pBuffer),
2138                                           PREF(pComponentPrivate_CC->pOutputBufHdrPending[i],nFilledLen),
2139                                           PERF_ModuleHLMM);
2140 #endif
2141                         pComponentPrivate_CC->cbInfo.FillBufferDone (pComponentPrivate_CC->pHandle,
2142                                                                      pComponentPrivate_CC->pHandle->pApplicationPrivate,
2143                                                                      pComponentPrivate_CC->pOutputBufHdrPending[i]
2144                                                                      );
2145                         pComponentPrivate_CC->nOutStandingFillDones--;
2146                         pComponentPrivate_CC->pOutputBufHdrPending[i] = NULL;
2147                     }
2148                     pComponentPrivate_CC->nNumOutputBufPending=0;
2149
2150                     pthread_mutex_lock(&pComponentPrivate_CC->codecFlush_mutex);
2151                     if(pComponentPrivate_CC->codecFlush_waitingsignal == 0){
2152                         pComponentPrivate_CC->codecFlush_waitingsignal = 1;
2153                         pthread_cond_signal(&pComponentPrivate_CC->codecFlush_threshold);
2154                         OMX_PRCOMM2(pComponentPrivate_CC->dbg, "flush ack. received. for output port");
2155                     }
2156                     pthread_mutex_unlock(&pComponentPrivate_CC->codecFlush_mutex);
2157                     pComponentPrivate_CC->cbInfo.EventHandler(pComponentPrivate_CC->pHandle,
2158                                                               pComponentPrivate_CC->pHandle->pApplicationPrivate,
2159                                                               OMX_EventCmdComplete,
2160                                                               OMX_CommandFlush,
2161                                                               OUTPUT_PORT,
2162                                                               NULL);
2163                 }
2164                 else
2165                 {
2166                     goto EXIT;
2167                 }
2168             }
2169
2170         }
2171
2172     }
2173     else if(event == EMMCodecProcessingStoped)
2174     {
2175
2176         for (i = 0; i < pComponentPrivate_CC->nNumInputBufPending; i++) {
2177                 pComponentPrivate_CC->cbInfo.EmptyBufferDone (pComponentPrivate_CC->pHandle,
2178                                 pComponentPrivate_CC->pHandle->pApplicationPrivate,
2179                                 pComponentPrivate_CC->pInputBufHdrPending[i]);
2180                                 pComponentPrivate_CC->pInputBufHdrPending[i] = NULL;
2181         }
2182         pComponentPrivate_CC->nNumInputBufPending = 0;
2183         for (i=0; i < pComponentPrivate_CC->nNumOutputBufPending; i++) {
2184                 pComponentPrivate_CC->cbInfo.FillBufferDone (pComponentPrivate_CC->pHandle,
2185                         pComponentPrivate_CC->pHandle->pApplicationPrivate,
2186                         pComponentPrivate_CC->pOutputBufHdrPending[i]);
2187                 pComponentPrivate_CC->nOutStandingFillDones--;
2188                 pComponentPrivate_CC->pOutputBufHdrPending[i] = NULL;
2189         }
2190         pComponentPrivate_CC->nNumOutputBufPending=0;
2191         pthread_mutex_lock(&pComponentPrivate_CC->codecStop_mutex);
2192         if(pComponentPrivate_CC->codecStop_waitingsignal == 0){
2193             pComponentPrivate_CC->codecStop_waitingsignal = 1;
2194             pthread_cond_signal(&pComponentPrivate_CC->codecStop_threshold);
2195             OMX_PRCOMM2(pComponentPrivate_CC->dbg, "stop ack. received. stop waiting for sending disable command completed");
2196         }
2197           pthread_mutex_unlock(&pComponentPrivate_CC->codecStop_mutex);
2198
2199         if (!pComponentPrivate_CC->bNoIdleOnStop)
2200         {
2201             pComponentPrivate_CC->curState = OMX_StateIdle;
2202 #ifdef RESOURCE_MANAGER_ENABLED
2203             eError = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet,
2204                                             OMX_WMA_Decoder_COMPONENT,
2205                                             OMX_StateIdle, 1234, NULL);
2206 #endif
2207             if (pComponentPrivate_CC->bPreempted == 0) {
2208                 pComponentPrivate_CC->cbInfo.EventHandler(pComponentPrivate_CC->pHandle,
2209                                                           pComponentPrivate_CC->pHandle->pApplicationPrivate,
2210                                                           OMX_EventCmdComplete,
2211                                                           OMX_CommandStateSet,
2212                                                           pComponentPrivate_CC->curState,
2213                                                           NULL);
2214             }
2215         }
2216         else
2217         {
2218             pComponentPrivate_CC->bDspStoppedWhileExecuting = OMX_TRUE;
2219             pComponentPrivate_CC->bNoIdleOnStop= OMX_FALSE;
2220         }
2221
2222     }
2223     else if (event == EMMCodecProcessingPaused)
2224     {
2225
2226         pComponentPrivate_CC->curState = OMX_StatePause;
2227
2228         pComponentPrivate_CC->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
2229                                                   OMX_EventCmdComplete,
2230                                                   OMX_CommandStateSet,
2231                                                   pComponentPrivate_CC->curState,
2232                                                   NULL);
2233     }
2234     else if (event == EMMCodecDspError)
2235     {
2236
2237         switch ( (OMX_U32) args [4])
2238         {
2239             /* USN_ERR_NONE,: Indicates that no error encountered during execution of the command and the command execution completed succesfully.
2240              * USN_ERR_WARNING,: Indicates that process function returned a warning. The exact warning is returned in Arg2 of this message.
2241              * USN_ERR_PROCESS,: Indicates that process function returned a error type. The exact error type is returnd in Arg2 of this message.
2242              * USN_ERR_PAUSE,: Indicates that execution of pause resulted in error.
2243              * USN_ERR_STOP,: Indicates that execution of stop resulted in error.
2244              * USN_ERR_ALGCTRL,: Indicates that execution of alg control resulted in error.
2245              * USN_ERR_STRMCTRL,: Indiactes the execution of STRM control command, resulted in error.
2246              * USN_ERR_UNKNOWN_MSG,: Indicates that USN received an unknown command. */
2247
2248 #ifdef _ERROR_PROPAGATION__
2249             case USN_ERR_PAUSE:
2250             case USN_ERR_STOP:
2251             case USN_ERR_ALGCTRL:
2252             case USN_ERR_STRMCTRL:
2253             case USN_ERR_UNKNOWN_MSG:
2254
2255                 {
2256                     pComponentPrivate_CC->bIsInvalidState=OMX_TRUE;
2257                     pComponentPrivate_CC->curState = OMX_StateInvalid;
2258                     pHandle = pComponentPrivate_CC->pHandle;
2259                     pComponentPrivate_CC->cbInfo.EventHandler(pHandle,
2260                             pHandle->pApplicationPrivate,
2261                             OMX_EventError,
2262                             OMX_ErrorInvalidState,
2263                             OMX_TI_ErrorSevere,
2264                             NULL);
2265                 }
2266                 break;
2267 #endif
2268
2269             case USN_ERR_WARNING:
2270             case USN_ERR_PROCESS:
2271                 WMADEC_HandleUSNError (pComponentPrivate_CC, (OMX_U32)args[5]);
2272                 break;
2273             default:
2274                 break;
2275         }
2276     }
2277
2278     if(event == EMMCodecDspMessageRecieved) {
2279         OMX_PRSTATE2(pComponentPrivate_CC->dbg, "%d :: commandedState  = %p",__LINE__,args[0]);
2280         OMX_PRINT2(pComponentPrivate_CC->dbg, "%d :: arg1 = %p",__LINE__,args[1]);
2281         OMX_PRINT2(pComponentPrivate_CC->dbg, "%d :: arg2 = %p",__LINE__,args[2]);
2282     }
2283
2284 #ifdef _ERROR_PROPAGATION__
2285
2286     else if (event ==EMMCodecInitError) {
2287         /* Cheking for MMU_fault */
2288         if((args[4] == (void *)USN_ERR_UNKNOWN_MSG) && (args[5] == NULL)) {
2289
2290             pComponentPrivate_CC->bIsInvalidState=OMX_TRUE;
2291             pComponentPrivate_CC->curState = OMX_StateInvalid;
2292             pHandle = pComponentPrivate_CC->pHandle;
2293             pComponentPrivate_CC->cbInfo.EventHandler(pHandle,
2294                                                       pHandle->pApplicationPrivate,
2295                                                       OMX_EventError,
2296                                                       OMX_ErrorInvalidState,
2297                                                       OMX_TI_ErrorSevere,
2298                                                       NULL);
2299         }
2300     }
2301     else if (event ==EMMCodecInternalError) {
2302
2303         /* Cheking for MMU_fault */
2304         if((args[4] == (void *)USN_ERR_UNKNOWN_MSG) && (args[5] == NULL)) {
2305
2306             pComponentPrivate_CC->bIsInvalidState=OMX_TRUE;
2307             pComponentPrivate_CC->curState = OMX_StateInvalid;
2308             pHandle = pComponentPrivate_CC->pHandle;
2309             pComponentPrivate_CC->cbInfo.EventHandler(pHandle,
2310                                                       pHandle->pApplicationPrivate,
2311                                                       OMX_EventError,
2312                                                       OMX_ErrorInvalidState,
2313                                                       OMX_TI_ErrorSevere,
2314                                                       NULL);
2315         }
2316
2317     }
2318 #endif
2319
2320  EXIT:
2321     OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Exiting the WMADECLCML_Callback Function",__LINE__);
2322     return eError;
2323 }
2324 /* -------------------------------------------------------------------*/
2325 /**
2326  *  WMADEC_GetCorresponding_LCMLHeader() function will be called by WMADEC_LCML_Callback
2327  *                                 component to write the msg
2328  * @param *pBuffer,          Event which gives to details about USN status
2329  * @param LCML_NBAMRENC_BUFHEADERTYPE **ppLcmlHdr
2330
2331  * @retval OMX_NoError              Success, ready to roll
2332  *         OMX_Error_BadParameter   The input parameter pointer is null
2333  **/
2334 /* -------------------------------------------------------------------*/
2335
2336 OMX_ERRORTYPE WMADECGetCorresponding_LCMLHeader(WMADEC_COMPONENT_PRIVATE *pComponentPrivate,
2337                                                 OMX_U8 *pBuffer,
2338                                                 OMX_DIRTYPE eDir,
2339                                                 LCML_WMADEC_BUFHEADERTYPE **ppLcmlHdr)
2340 {
2341
2342     OMX_ERRORTYPE eError = OMX_ErrorNone;
2343     LCML_WMADEC_BUFHEADERTYPE *pLcmlBufHeader;
2344     WMADEC_COMPONENT_PRIVATE *pComponentPrivate_CC;
2345
2346     int nIpBuf;
2347     int nOpBuf;
2348     OMX_U16 i;
2349
2350     pComponentPrivate_CC = pComponentPrivate;
2351     nIpBuf = pComponentPrivate_CC->pInputBufferList->numBuffers;
2352     nOpBuf = pComponentPrivate_CC->pOutputBufferList->numBuffers;
2353
2354     while (!pComponentPrivate_CC->bInitParamsInitialized)
2355     {
2356 #ifndef UNDER_CE
2357         sched_yield();
2358 #else
2359         Sleep(0);
2360 #endif
2361     }
2362     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Inside WMADECGetCorresponding_LCMLHeader..",__LINE__);
2363     OMX_PRINT2(pComponentPrivate->dbg, "%d :: eDir = %d",__LINE__,eDir);
2364
2365     if(eDir == OMX_DirInput) {
2366
2367         OMX_PRINT1(pComponentPrivate->dbg, "%d :: pComponentPrivate_CC = %p",__LINE__,
2368                       pComponentPrivate_CC);
2369         OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: pComponentPrivate_CC->pLcmlBufHeader[INPUT_PORT] = %p",
2370                       __LINE__,pComponentPrivate_CC->pLcmlBufHeader[INPUT_PORT]);
2371
2372         pLcmlBufHeader = pComponentPrivate_CC->pLcmlBufHeader[INPUT_PORT];
2373         OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: nIpBuf = %d",__LINE__,nIpBuf);
2374         for(i=0; i<nIpBuf; i++)
2375         {
2376             OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffer = %p",pBuffer);
2377             OMX_PRBUFFER1(pComponentPrivate->dbg, "pLcmlBufHeader->buffer->pBuffer = %p",
2378                           pLcmlBufHeader->buffer->pBuffer);
2379             if(pBuffer == pLcmlBufHeader->buffer->pBuffer)
2380             {
2381                 *ppLcmlHdr = pLcmlBufHeader;
2382                 OMX_ERROR2(pComponentPrivate->dbg, "%d::Corresponding LCML Header Found",__LINE__);
2383                 goto EXIT;
2384             }
2385             pLcmlBufHeader++;
2386         }
2387     }
2388     else if (eDir == OMX_DirOutput)
2389     {
2390
2391         pLcmlBufHeader = pComponentPrivate_CC->pLcmlBufHeader[OUTPUT_PORT];
2392         OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffer = %p",pBuffer);
2393         OMX_PRBUFFER2(pComponentPrivate->dbg, "pLcmlBufHeader->buffer- = %p",pLcmlBufHeader->buffer);
2394         OMX_PRBUFFER2(pComponentPrivate->dbg, "pLcmlBufHeader->buffer->pBuffer = %p",
2395                       pLcmlBufHeader->buffer->pBuffer);
2396         OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: nOpBuf = %d",__LINE__,nOpBuf);
2397
2398         for(i=0; i<nOpBuf; i++)
2399         {
2400             if(pBuffer == pLcmlBufHeader->buffer->pBuffer)
2401             {
2402                 OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffer = %p",pBuffer);
2403                 OMX_PRBUFFER2(pComponentPrivate->dbg, "pLcmlBufHeader->buffer->pBuffer = %p",
2404                               pLcmlBufHeader->buffer->pBuffer);
2405                 *ppLcmlHdr = pLcmlBufHeader;
2406                 OMX_ERROR2(pComponentPrivate->dbg, "%d::Corresponding LCML Header Found",__LINE__);
2407                 goto EXIT;
2408             }
2409             pLcmlBufHeader++;
2410         }
2411     }
2412     else
2413     {
2414         OMX_PRINT1(pComponentPrivate->dbg, "%d:: Invalid Buffer Type :: exiting...",__LINE__);
2415     }
2416
2417  EXIT:
2418     return eError;
2419 }
2420
2421
2422 /* -------------------------------------------------------------------*/
2423 /**
2424  *  WMADEC_GetLCMLHandle()
2425  *
2426  * @retval OMX_HANDLETYPE
2427  *
2428  -------------------------------------------------------------------*/
2429
2430 #ifndef UNDER_CE
2431 OMX_HANDLETYPE WMADECGetLCMLHandle(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
2432 {
2433
2434     void *handle;
2435     OMX_ERRORTYPE (*fpGetHandle)(OMX_HANDLETYPE);
2436     OMX_HANDLETYPE pHandle = NULL;
2437     char *error;
2438     OMX_ERRORTYPE eError;
2439
2440     handle = dlopen("libLCML.so", RTLD_LAZY);
2441     if (!handle)
2442     {
2443         fputs(dlerror(), stderr);
2444         goto EXIT;
2445     }
2446
2447     fpGetHandle = dlsym (handle, "GetHandle");
2448     if ((error = dlerror()) != NULL)
2449     {
2450         fputs(error, stderr);
2451         goto EXIT;
2452     }
2453
2454     eError = (*fpGetHandle)(&pHandle);
2455     if(eError != OMX_ErrorNone)
2456     {
2457         eError = OMX_ErrorUndefined;
2458         OMX_ERROR4(pComponentPrivate->dbg, "eError != OMX_ErrorNone...");
2459         pHandle = NULL;
2460         goto EXIT;
2461     }
2462
2463     ((LCML_DSP_INTERFACE*)pHandle)->pComponentPrivate = pComponentPrivate;
2464
2465  EXIT:
2466
2467     return pHandle;
2468 }
2469 #else
2470 /*=================================================================*/
2471 /*WINDOWS Explicit dll load procedure
2472   ===================================================================*/
2473 OMX_HANDLETYPE WMADECGetLCMLHandle(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
2474 {
2475
2476     typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE);
2477     OMX_HANDLETYPE pHandle = NULL;
2478     OMX_ERRORTYPE eError;
2479     HINSTANCE hDLL;               // Handle to DLL
2480     LPFNDLLFUNC1 fpGetHandle1;
2481     hDLL = LoadLibraryEx(TEXT("OAF_BML.dll"), NULL,0);
2482     if (hDLL == NULL)
2483     {
2484         OMX_ERROR4(pComponentPrivate->dbg, "BML Load Failed!!!");
2485         return pHandle;
2486     }
2487
2488     fpGetHandle1 = (LPFNDLLFUNC1)GetProcAddress(hDLL,TEXT("GetHandle"));
2489     if (!fpGetHandle1)
2490     {
2491         // handle the error
2492         FreeLibrary(hDLL);
2493         return pHandle;
2494     }
2495
2496     // call the function
2497     eError = fpGetHandle1(&pHandle);
2498     if(eError != OMX_ErrorNone) {
2499         eError = OMX_ErrorUndefined;
2500         OMX_ERROR4(pComponentPrivate->dbg, "eError != OMX_ErrorNone...");
2501         pHandle = NULL;
2502         return pHandle;
2503     }
2504
2505     ((LCML_DSP_INTERFACE*)pHandle)->pComponentPrivate = pComponentPrivate;
2506
2507     return pHandle;
2508 }
2509
2510
2511 #endif
2512
2513
2514 #ifndef UNDER_CE
2515 /*=================================================================*/
2516 /**@FreeLCMLHandle                                                                      */
2517 /*==================================================================*/
2518 OMX_ERRORTYPE WMADECFreeLCMLHandle(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
2519 {
2520
2521     int retValue;
2522     OMX_ERRORTYPE eError = OMX_ErrorNone;
2523
2524     if (pComponentPrivate->bLcmlHandleOpened)
2525     {
2526         retValue = dlclose(pComponentPrivate->pLcmlHandle);
2527
2528         if (retValue != 0)
2529         {
2530             eError = OMX_ErrorUndefined;
2531         }
2532         pComponentPrivate->bLcmlHandleOpened = 0;
2533     }
2534
2535     return eError;
2536 }
2537 #else
2538 /*=================================================================*/
2539 /**    @   FreeLCMLHandle                                                                       */
2540 /*==================================================================*/
2541 OMX_ERRORTYPE WMADECFreeLCMLHandle(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
2542 {
2543
2544     int retValue;
2545     OMX_ERRORTYPE eError = OMX_ErrorNone;
2546
2547     if (pComponentPrivate->bLcmlHandleOpened)
2548     {
2549
2550         retValue = FreeLibrary(pComponentPrivate->pLcmlHandle);
2551         if (retValue == 0) /* Zero Indicates failure */
2552         {
2553             eError = OMX_ErrorUndefined;
2554         }
2555         pComponentPrivate->bLcmlHandleOpened = 0;
2556     }
2557     return eError;
2558 }
2559 #endif
2560 /* ================================================================================= */
2561 /**
2562  * @fn WMADEC_CommandToIdle() description for WMADEC_CommandToIdle
2563  WMADEC_CommandToIdle().
2564  This component is called by HandleCommand() when the component is commanded to Idle
2565  * @param pComponent  handle for this instance of the component
2566  *
2567  * @pre
2568  *
2569  * @post
2570  *
2571  * @return OMX_ERRORTYPE
2572  */
2573 /* ================================================================================ */
2574 OMX_ERRORTYPE WMADEC_CommandToIdle(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
2575 {
2576     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
2577     OMX_HANDLETYPE pLcmlHandle = pComponentPrivate->pLcmlHandle;
2578
2579 #ifdef RESOURCE_MANAGER_ENABLED
2580     OMX_ERRORTYPE rm_error = OMX_ErrorNone;
2581 #endif
2582     OMX_ERRORTYPE eError = OMX_ErrorNone;
2583
2584     OMX_U16 arr[50];
2585     int inputPortFlag = 0;
2586     int outputPortFlag = 0;
2587
2588     char *p = "hello";
2589     LCML_CALLBACKTYPE cb;
2590     LCML_DSP *pLcmlDsp;
2591
2592
2593     OMX_PRINT1(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd Idle ",__LINE__);
2594     OMX_PRINT2(pComponentPrivate->dbg, "curstate = %d",pComponentPrivate->curState);
2595     if (pComponentPrivate->curState == OMX_StateIdle)
2596     {
2597         pComponentPrivate->cbInfo.EventHandler (pHandle, pHandle->pApplicationPrivate,
2598                                                 OMX_EventError, OMX_ErrorSameState,
2599                                                 OMX_TI_ErrorMinor, NULL);
2600         OMX_ERROR2(pComponentPrivate->dbg, "%d :: Error: Same State Given by Application",__LINE__);
2601     }
2602     else if (pComponentPrivate->curState == OMX_StateLoaded)
2603     {
2604 #ifdef __PERF_INSTRUMENTATION__
2605         PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart | PERF_BoundarySetup);
2606 #endif
2607         if (pComponentPrivate->dasfmode == 1)
2608         {
2609             pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled= FALSE;
2610             pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated= FALSE;
2611
2612             if(pComponentPrivate->streamID == 0)
2613             {
2614                 OMX_ERROR4(pComponentPrivate->dbg, "**************************************");
2615                 OMX_ERROR4(pComponentPrivate->dbg, ":: Error = OMX_ErrorInsufficientResources");
2616                 OMX_ERROR4(pComponentPrivate->dbg, "**************************************");
2617                 eError = OMX_ErrorInsufficientResources;
2618                 pComponentPrivate->curState = OMX_StateInvalid;
2619
2620                 pComponentPrivate->cbInfo.EventHandler(pHandle,
2621                                                        pHandle->pApplicationPrivate,
2622                                                        OMX_EventError,
2623                                                        OMX_ErrorInvalidState,
2624                                                        OMX_TI_ErrorSevere,
2625                                                        NULL);
2626                 goto EXIT;
2627             }
2628         }
2629         while (1)
2630         {
2631             OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: In while loop OMX_StateLoaded [INPUT_PORT]->bPopulated  %d ",
2632                           __LINE__,pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated);
2633             OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: In while loop OMX_StateLoaded [INPUT_PORT]->bEnabled    %d ",
2634                           __LINE__,pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled);
2635             OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: In while loop OMX_StateLoaded [OUTPUT_PORT]->bPopulated %d ",
2636                           __LINE__,pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated);
2637             OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: In while loop OMX_StateLoaded [OUTPUT_PORT]->bEnabled   %d ",
2638                           __LINE__,pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled);
2639
2640             if (pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated &&
2641                 pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled)
2642             {
2643                 inputPortFlag = 1;
2644             }
2645
2646             if (!pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated &&
2647                 !pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled)
2648             {
2649                 inputPortFlag = 1;
2650             }
2651
2652             if (pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated &&
2653                 pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled)
2654             {
2655                 outputPortFlag = 1;
2656             }
2657
2658             if (!pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated &&
2659                 !pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled)
2660             {
2661                 outputPortFlag = 1;
2662             }
2663
2664             if (inputPortFlag && outputPortFlag)
2665             {
2666                 break;
2667             }
2668             /* From Loaded to Idle. All enable ports are populated. */
2669             pComponentPrivate->InLoaded_readytoidle = 1;
2670 #ifndef UNDER_CE
2671             pthread_mutex_lock(&pComponentPrivate->InLoaded_mutex);
2672             pthread_cond_wait(&pComponentPrivate->InLoaded_threshold,
2673                               &pComponentPrivate->InLoaded_mutex);
2674             /*---------------------*/
2675             pthread_mutex_unlock(&pComponentPrivate->InLoaded_mutex);
2676 #else
2677             OMX_WaitForEvent(&(pComponentPrivate->InLoaded_event));
2678 #endif
2679             break;
2680         }
2681         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Inside WMADECHandleCommand",__LINE__);
2682         cb.LCML_Callback = (void *) WMADECLCML_Callback;
2683         pLcmlHandle = (OMX_HANDLETYPE) WMADECGetLCMLHandle(pComponentPrivate);
2684         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Inside WMADECHandleCommand",__LINE__);
2685         if (pLcmlHandle == NULL)
2686         {
2687             OMX_ERROR4(pComponentPrivate->dbg, "%d :: LCML Handle is NULL........exiting..",__LINE__);
2688             goto EXIT;
2689         }
2690
2691         /* Got handle of dsp via phandle filling information about DSP   specific things */
2692         pLcmlDsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
2693         eError = WMADECFill_LCMLInitParams(pHandle, pLcmlDsp, arr);
2694         if(eError != OMX_ErrorNone)
2695         {
2696             OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error returned from WMADECFill_LCMLInitParams()",
2697                           __LINE__);
2698             goto EXIT;
2699         }
2700
2701         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
2702         pComponentPrivate->pLcmlHandle = (LCML_DSP_INTERFACE *)pLcmlHandle;
2703
2704         /*filling create phase params */
2705         cb.LCML_Callback = (void *) WMADECLCML_Callback;
2706         OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Calling LCML_InitMMCodec...",__LINE__);
2707
2708 #ifndef UNDER_CE
2709         /* TeeDN will be default for decoder component */
2710         OMX_PRSTATE2(pComponentPrivate->dbg, "WMA decoder support TeeDN");
2711         OMX_PRDSP2(pComponentPrivate->dbg, "pComponentPrivate Before calling InitMMCodec = %p",
2712                       pComponentPrivate);
2713
2714         OMX_PRINT1(pComponentPrivate->dbg, "&pComponentPrivate = %p",&pComponentPrivate);
2715         OMX_PRDSP2(pComponentPrivate->dbg, "pLcmlHandle = %p",pLcmlHandle);
2716         OMX_PRINT2(pComponentPrivate->dbg, "p = %p",p);
2717         OMX_PRDSP1(pComponentPrivate->dbg, "pLcmlHandle->pCodecinterfacehandle = %p",
2718                       ((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle);
2719
2720         eError = LCML_InitMMCodecEx(((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle,
2721                                     p,&pLcmlHandle,(void *)p,&cb,(OMX_STRING)pComponentPrivate->sDeviceString);
2722         OMX_PRDSP2(pComponentPrivate->dbg, "pComponentPrivate After calling InitMMCodec = %p",
2723                       pComponentPrivate);
2724
2725         if(eError != OMX_ErrorNone)
2726         {
2727             OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error returned from LCML_Init() error = %d",__LINE__, eError);
2728             /* send an event to client */
2729             /* client should unload the component if the codec is not able to load */
2730             pComponentPrivate->cbInfo.EventHandler (pHandle,
2731                                                 pHandle->pApplicationPrivate,
2732                                                 OMX_EventError,
2733                                                 eError,
2734                                                 OMX_TI_ErrorSevere,
2735                                                 NULL);
2736             goto EXIT;
2737         }
2738 #else
2739         eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle,
2740                                   p,&pLcmlHandle,(void *)p,&cb);
2741         if (eError != OMX_ErrorNone)
2742         {
2743             OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error : InitMMCodec failed...>>>>>> ",__LINE__);
2744             goto EXIT;
2745         }
2746
2747 #endif
2748
2749 #ifdef HASHINGENABLE
2750         /* Enable the Hashing Code */
2751         eError = LCML_SetHashingState(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, OMX_TRUE);
2752         if (eError != OMX_ErrorNone) {
2753             OMX_ERROR4(pComponentPrivate->dbg, "Failed to set Mapping State");
2754             goto EXIT;
2755         }
2756 #endif
2757
2758 #ifdef RESOURCE_MANAGER_ENABLED
2759         OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: WMADEC: About to call RMProxy_SendCommand", __LINE__);
2760         pComponentPrivate->rmproxyCallback.RMPROXY_Callback =
2761             (void *) WMAD_ResourceManagerCallback;
2762
2763         if (pComponentPrivate->curState != OMX_StateWaitForResources){
2764             rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_RequestResource,
2765                                               OMX_WMA_Decoder_COMPONENT,
2766                                               WMA_CPU, 1234, NULL);
2767
2768             OMX_PRDSP2(pComponentPrivate->dbg, "%d :: WMADEC: RMProxy_SendCommand returned %d",
2769                           __LINE__,rm_error);
2770             if(rm_error == OMX_ErrorNone)
2771             {
2772                 /* resource is available */
2773                 pComponentPrivate->curState = OMX_StateIdle;
2774                 pComponentPrivate->cbInfo.EventHandler( pHandle,
2775                                                         pHandle->pApplicationPrivate,
2776                                                         OMX_EventCmdComplete,
2777                                                         OMX_CommandStateSet,
2778                                                         pComponentPrivate->curState,
2779                                                         NULL);
2780 #ifdef __PERF_INSTRUMENTATION__
2781                 PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete |
2782                               PERF_BoundarySetup);
2783 #endif
2784                 rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet,
2785                                                   OMX_WMA_Decoder_COMPONENT,
2786                                                   OMX_StateIdle,0,NULL);
2787             }
2788         }
2789         else if(rm_error == OMX_ErrorInsufficientResources){
2790             /* resource is not available, need set state to OMX_StateWaitForResources */
2791             pComponentPrivate->curState = OMX_StateWaitForResources;
2792             pComponentPrivate->cbInfo.EventHandler(pHandle,
2793                                                    pHandle->pApplicationPrivate,
2794                                                    OMX_EventCmdComplete,
2795                                                    OMX_CommandStateSet,
2796                                                    pComponentPrivate->curState,
2797                                                    NULL);
2798             OMX_ERROR2(pComponentPrivate->dbg, "%d :: WMADEC: Error - insufficient resources", __LINE__);
2799         }
2800 #else
2801         OMX_PRSTATE2(pComponentPrivate->dbg, "Setting to OMX_StateIdle - Line %d",__LINE__);
2802         pComponentPrivate->curState = OMX_StateIdle;
2803         pComponentPrivate->cbInfo.EventHandler( pHandle,
2804                                                 pHandle->pApplicationPrivate,
2805                                                 OMX_EventCmdComplete,
2806                                                 OMX_CommandStateSet,
2807                                                 pComponentPrivate->curState,
2808                                                 NULL);
2809 #endif
2810
2811         OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: WMADEC: State has been Set to Idle",__LINE__);
2812
2813 #ifdef __PERF_INSTRUMENTATION__
2814         PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete |
2815                       PERF_BoundarySetup);
2816 #endif
2817
2818     }
2819     else if (pComponentPrivate->curState == OMX_StateExecuting)
2820     {
2821         char *pArgs = "damedesuStr";
2822 #ifdef HASHINGENABLE
2823         /*Hashing Change*/
2824         pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLcmlHandle;
2825         eError = LCML_FlushHashes(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle);
2826         if (eError != OMX_ErrorNone) {
2827             OMX_ERROR2(pComponentPrivate->dbg, "Error occurred in Codec mapping flush!");
2828         }
2829 #endif
2830         /*Set the bIsStopping bit */
2831 #ifdef __PERF_INSTRUMENTATION__
2832         PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete |
2833                       PERF_BoundarySteadyState);
2834 #endif
2835
2836         OMX_PRINT2(pComponentPrivate->dbg, "%d :: WMADEC: About to set bIsStopping bit", __LINE__);
2837         if (pComponentPrivate->codecStop_waitingsignal == 0){
2838             pthread_mutex_lock(&pComponentPrivate->codecStop_mutex);
2839         }
2840         eError = LCML_ControlCodec(
2841                                    ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
2842                                    MMCodecControlStop,(void *)pArgs);
2843         if (pComponentPrivate->codecStop_waitingsignal == 0){
2844             pthread_cond_wait(&pComponentPrivate->codecStop_threshold, &pComponentPrivate->codecStop_mutex);
2845             pComponentPrivate->codecStop_waitingsignal = 0; // reset the wait condition for next time
2846             pthread_mutex_unlock(&pComponentPrivate->codecStop_mutex);
2847         }
2848         if(eError != OMX_ErrorNone)
2849         {
2850             OMX_ERROR4(pComponentPrivate->dbg, "%d: Error Occurred in Codec Stop..", __LINE__);
2851             goto EXIT;
2852         }
2853         else{
2854             OMX_PRSTATE2(pComponentPrivate->dbg, "%d: Codec has been stopped", __LINE__);
2855         }
2856     }
2857     else if(pComponentPrivate->curState == OMX_StatePause)
2858     {
2859         char *pArgs = "damedesuStr";
2860         OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Comp: Stop Command Received",__LINE__);
2861 #ifdef HASHINGENABLE
2862         /*Hashing Change*/
2863         pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLcmlHandle;
2864         eError = LCML_FlushHashes(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle);
2865         if (eError != OMX_ErrorNone) {
2866             OMX_ERROR2(pComponentPrivate->dbg, "Error occurred in Codec mapping flush!");
2867         }
2868 #endif
2869
2870 #ifdef __PERF_INSTRUMENTATION__
2871         PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete |
2872                       PERF_BoundarySteadyState);
2873 #endif
2874
2875         if (pComponentPrivate->codecStop_waitingsignal == 0){
2876             pthread_mutex_lock(&pComponentPrivate->codecStop_mutex);
2877         }
2878         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
2879                                    MMCodecControlStop,
2880                                    (void *)pArgs);
2881         if (pComponentPrivate->codecStop_waitingsignal == 0){
2882             pthread_cond_wait(&pComponentPrivate->codecStop_threshold, &pComponentPrivate->codecStop_mutex);
2883             pComponentPrivate->codecStop_waitingsignal = 0;
2884             pthread_mutex_unlock(&pComponentPrivate->codecStop_mutex);
2885         }
2886         pComponentPrivate->curState = OMX_StateIdle;
2887 #ifdef RESOURCE_MANAGER_ENABLED
2888
2889         rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet,
2890                                           OMX_WMA_Decoder_COMPONENT,
2891                                           OMX_StateIdle, 1234, NULL);
2892         if(rm_error != OMX_ErrorNone)
2893         {
2894             OMX_ERROR4(pComponentPrivate->dbg, "%d :: ERROR: Send Comman Failed", __LINE__);
2895             goto EXIT;
2896         }
2897 #endif
2898
2899         OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: The component is stopped",__LINE__);
2900         pComponentPrivate->cbInfo.EventHandler (pHandle,
2901                                                 pHandle->pApplicationPrivate,
2902                                                 OMX_EventCmdComplete,OMX_CommandStateSet,
2903                                                 pComponentPrivate->curState,
2904                                                 NULL);
2905     }
2906     else
2907     {
2908         /* This means, it is invalid state from application */
2909         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
2910         pComponentPrivate->cbInfo.EventHandler(pHandle,
2911                                                pHandle->pApplicationPrivate,
2912                                                OMX_EventError,
2913                                                OMX_ErrorIncorrectStateTransition,
2914                                                OMX_TI_ErrorMinor,
2915                                                NULL);
2916     }
2917
2918  EXIT:
2919     if (eError != OMX_ErrorNone ) {
2920         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2921                                                pComponentPrivate->pHandle->pApplicationPrivate,
2922                                                OMX_EventError,
2923                                                eError,
2924                                                OMX_TI_ErrorSevere,
2925                                                NULL);
2926     }
2927     return eError;
2928 }
2929 /* ================================================================================= */
2930 /**
2931  * @fn WMADEC_CommandToLoaded() description for WMADEC_CommandToLoaded
2932  WMADEC_CommandToLoaded().
2933  This component is called by HandleCommand() when the component is commanded to Loaded
2934  * @param pComponent  handle for this instance of the component
2935  *
2936  * @pre
2937  *
2938  * @post
2939  *
2940  * @return OMX_ERRORTYPE
2941  */
2942 /* ================================================================================ */
2943 OMX_ERRORTYPE WMADEC_CommandToLoaded(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
2944 {
2945
2946     OMX_COMPONENTTYPE *pHandle =
2947         (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
2948     OMX_HANDLETYPE pLcmlHandle = pComponentPrivate->pLcmlHandle;
2949     OMX_ERRORTYPE eError = OMX_ErrorNone;
2950     char *p = "hello";
2951     OMX_PRINT1(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd Loaded - curState = %d",
2952                   __LINE__,pComponentPrivate->curState);
2953     if (pComponentPrivate->curState == OMX_StateLoaded)
2954     {
2955         pComponentPrivate->cbInfo.EventHandler (pHandle,
2956                                                 pHandle->pApplicationPrivate,
2957                                                 OMX_EventError,
2958                                                 OMX_ErrorSameState,
2959                                                 OMX_TI_ErrorMinor,
2960                                                 NULL);
2961         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Same State Given by Application",__LINE__);
2962         goto EXIT;
2963     }
2964     OMX_PRBUFFER1(pComponentPrivate->dbg, "%d: pComponentPrivate->pInputBufferList->numBuffers = %d",
2965                   __LINE__,pComponentPrivate->pInputBufferList->numBuffers);
2966     OMX_PRBUFFER1(pComponentPrivate->dbg, "%d: pComponentPrivate->pOutputBufferList->numBuffers = %d",
2967                   __LINE__,pComponentPrivate->pOutputBufferList->numBuffers);
2968
2969     if (pComponentPrivate->curState == OMX_StateWaitForResources)
2970     {
2971         OMX_PRDSP2(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd Loaded",__LINE__);
2972
2973 #ifdef __PERF_INSTRUMENTATION__
2974         PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart | PERF_BoundaryCleanup);
2975 #endif
2976         pComponentPrivate->curState = OMX_StateLoaded;
2977
2978 #ifdef __PERF_INSTRUMENTATION__
2979         PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundaryCleanup);
2980 #endif
2981         pComponentPrivate->cbInfo.EventHandler (pHandle,
2982                                                 pHandle->pApplicationPrivate,
2983                                                 OMX_EventCmdComplete,
2984                                                 OMX_CommandStateSet,
2985                                                 pComponentPrivate->curState,
2986                                                 NULL);
2987         goto EXIT;
2988     }
2989     OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: In side OMX_StateLoaded State: ",__LINE__);
2990     if (pComponentPrivate->curState != OMX_StateIdle &&
2991         pComponentPrivate->curState != OMX_StateWaitForResources)
2992     {
2993         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
2994         pComponentPrivate->cbInfo.EventHandler (pHandle,
2995                                                 pHandle->pApplicationPrivate,
2996                                                 OMX_EventError,
2997                                                 OMX_ErrorIncorrectStateTransition,
2998                                                 OMX_TI_ErrorMinor,
2999                                                 NULL);
3000         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Invalid State Given by Application",__LINE__);
3001         goto EXIT;
3002     }
3003 #ifdef __PERF_INSTRUMENTATION__
3004     PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart | PERF_BoundaryCleanup);
3005 #endif
3006     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pInputBufferList->numBuffers = %d",
3007                   pComponentPrivate->pInputBufferList->numBuffers);
3008     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pOutputBufferList->numBuffers = %d",
3009                   pComponentPrivate->pOutputBufferList->numBuffers);
3010     while (1)
3011     {
3012         OMX_PRDSP2(pComponentPrivate->dbg, "HandleCommand - in while(1) loop");
3013         if (!pComponentPrivate->pInputBufferList->numBuffers &&
3014             !pComponentPrivate->pOutputBufferList->numBuffers)
3015         {
3016             break;
3017         }
3018         pComponentPrivate->InIdle_goingtoloaded = 1;
3019 #ifndef UNDER_CE
3020         pthread_mutex_lock(&pComponentPrivate->InIdle_mutex);
3021         pthread_cond_wait(&pComponentPrivate->InIdle_threshold,
3022                           &pComponentPrivate->InIdle_mutex);
3023         pthread_mutex_unlock(&pComponentPrivate->InIdle_mutex);
3024 #else
3025         OMX_WaitForEvent(&(pComponentPrivate->InIdle_event));
3026 #endif
3027         break;
3028     }
3029
3030     /* Now Deinitialize the component No error should be returned from
3031      * this function. It should clean the system as much as possible */
3032     OMX_PRSTATE1(pComponentPrivate->dbg, "%d :: In side OMX_StateLoaded State: ",__LINE__);
3033     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3034                                EMMCodecControlDestroy, (void *)p);
3035     OMX_PRSTATE1(pComponentPrivate->dbg, "%d :: In side OMX_StateLoaded State: ",__LINE__);
3036     if (eError != OMX_ErrorNone)
3037     {
3038         OMX_ERROR4(pComponentPrivate->dbg, "%d : Error: in Destroying the codec: no.  %x",__LINE__, eError);
3039         goto EXIT;
3040     }
3041     OMX_PRDSP1(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd Loaded",__LINE__);
3042 #ifdef __PERF_INSTRUMENTATION__
3043     PERF_SendingCommand(pComponentPrivate->pPERF, -1, 0, PERF_ModuleComponent);
3044 #endif
3045     eError = EXIT_COMPONENT_THRD;
3046     pComponentPrivate->bInitParamsInitialized = 0;
3047     /* Send StateChangeNotification to application */
3048     pComponentPrivate->bLoadedCommandPending = OMX_FALSE;
3049
3050
3051  EXIT:
3052     if (eError != OMX_ErrorNone && eError != EXIT_COMPONENT_THRD ) {
3053         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3054                                                pComponentPrivate->pHandle->pApplicationPrivate,
3055                                                OMX_EventError,
3056                                                eError,
3057                                                OMX_TI_ErrorSevere,
3058                                                NULL);
3059     }
3060     return eError;
3061 }
3062
3063 /* ================================================================================= */
3064 /**
3065  * @fn WMADEC_CommandToExecuting() description for WMADEC_CommandToExecuting
3066  WMADEC_CommandToExecuting().
3067  This component is called by HandleCommand() when the component is commanded to Executing
3068  * @param pComponent  handle for this instance of the component
3069  *
3070  * @pre
3071  *
3072  * @post
3073  *
3074  * @return OMX_ERRORTYPE
3075  */
3076 /* ================================================================================ */
3077 OMX_ERRORTYPE WMADEC_CommandToExecuting(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
3078 {
3079
3080     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
3081     OMX_HANDLETYPE pLcmlHandle = pComponentPrivate->pLcmlHandle;
3082     OMX_U16 i;
3083     OMX_ERRORTYPE eError = OMX_ErrorNone;
3084     char *p = "hello";
3085
3086     LCML_WMADEC_BUFHEADERTYPE *pLcmlHdr = NULL;
3087     OMX_U32 cmdValues[3];
3088     char *pArgs = "damedesuStr";
3089
3090 #ifdef RESOURCE_MANAGER_ENABLED
3091     int rm_error;
3092 #endif
3093     OMX_PRINT1(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd Executing ",__LINE__);
3094     if (pComponentPrivate->curState == OMX_StateExecuting)
3095     {
3096         pComponentPrivate->cbInfo.EventHandler (pHandle,
3097                                                 pHandle->pApplicationPrivate,
3098                                                 OMX_EventError,
3099                                                 OMX_ErrorSameState,
3100                                                 OMX_TI_ErrorMinor,
3101                                                 NULL);
3102         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Same State Given by Application",__LINE__);
3103         goto EXIT;
3104     }
3105     else if (pComponentPrivate->curState == OMX_StateIdle)
3106     {
3107         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3108         /* Sending commands to DSP via LCML_ControlCodec third argument
3109            is not used for time being */
3110
3111         pComponentPrivate->nNumInputBufPending = 0;
3112         pComponentPrivate->nNumOutputBufPending = 0;
3113         if(pComponentPrivate->dasfmode == 1)
3114         {
3115             OMX_U32 pValues[4];
3116             OMX_PRDSP2(pComponentPrivate->dbg, "%d :: ---- Comp: DASF Functionality is ON ---",__LINE__);
3117             if (pComponentPrivate->pHeaderInfo->iChannel == 1)
3118             {
3119                 pComponentPrivate->pParams->iAudioFormat = WMA_MONO_CHANNEL;
3120             }
3121             else
3122             {
3123                 pComponentPrivate->pParams->iAudioFormat = WMA_STEREO_NON_INTERLEAVED;
3124             }
3125             OMX_PRINT1(pComponentPrivate->dbg, "pParams->iAudioFormat = %d", pComponentPrivate->pParams->iAudioFormat);
3126             pComponentPrivate->pParams->iStrmId = pComponentPrivate->streamID;
3127             pComponentPrivate->pParams->iSamplingRate =
3128                 pComponentPrivate->pHeaderInfo->iSamplePerSec;
3129
3130             OMX_PRINT1(pComponentPrivate->dbg, "pParams->iSamplingRate = %ld",
3131                           pComponentPrivate->pParams->iSamplingRate);
3132             OMX_PRINT1(pComponentPrivate->dbg, "pParams->iStrmId = %ld",
3133                           pComponentPrivate->pParams->iStrmId);
3134             OMX_PRINT1(pComponentPrivate->dbg, "pParams->iAudioFormat = %d",
3135                           pComponentPrivate->pParams->iAudioFormat);
3136
3137             pValues[0] = USN_STRMCMD_SETCODECPARAMS;
3138             pValues[1] = (OMX_U32)pComponentPrivate->pParams;
3139             pValues[2] = sizeof(WMADEC_AudioCodecParams);
3140             pValues[3] = OUTPUT_PORT;
3141             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3142                                        EMMCodecControlStrmCtrl,(void *)pValues);
3143             if(eError != OMX_ErrorNone)
3144             {
3145                 OMX_ERROR4(pComponentPrivate->dbg, "%d: Error Occurred in Codec StreamControl..",
3146                               __LINE__);
3147                 goto EXIT;
3148             }
3149         }
3150         if( pComponentPrivate->dasfmode )
3151         {
3152             OMX_PRDSP2(pComponentPrivate->dbg, "Setting WMA_IAUDIO_BLOCK");
3153             pComponentPrivate->pDynParams->iOutputFormat = WMA_IAUDIO_BLOCK; /* EAUDIO_BLOCKED */
3154         }
3155         else
3156         {
3157             OMX_PRDSP1(pComponentPrivate->dbg, "Setting WMA_IAUDIO_INTERLEAVED");
3158             pComponentPrivate->pDynParams->iOutputFormat = WMA_IAUDIO_INTERLEAVED; /* EAUDIO_INTERLEAVED */
3159         }
3160         pComponentPrivate->pDynParams->size = sizeof( WMADEC_UALGParams );
3161
3162         cmdValues[0] = WMA_IUALG_CMD_SETSTATUS;
3163         cmdValues[1] = (OMX_U32)( pComponentPrivate->pDynParams );
3164         cmdValues[2] = sizeof( WMADEC_UALGParams );
3165
3166         p = (void *)&cmdValues;
3167         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3168                                    EMMCodecControlAlgCtrl, (void *)p);
3169
3170         if(eError != OMX_ErrorNone)
3171         {
3172             OMX_ERROR4(pComponentPrivate->dbg, "%d: Error Occurred in Codec algctrl..", __LINE__);
3173             goto EXIT;
3174         }
3175         pComponentPrivate->bBypassDSP = 0;
3176
3177         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)(pComponentPrivate->pLcmlHandle))->pCodecinterfacehandle,
3178                                    EMMCodecControlStart, (void *)pArgs);
3179
3180         if(eError != OMX_ErrorNone)
3181         {
3182             OMX_ERROR4(pComponentPrivate->dbg, "%d: Error Occurred in Codec Start..", __LINE__);
3183             goto EXIT;
3184         }
3185         OMX_PRSTATE2(pComponentPrivate->dbg, ": Codec Has Been Started ");
3186
3187         pComponentPrivate->SendAfterEOS = 1; /*Enrique Zertuche, added because it wasnt set compared with the mp3*/
3188     }
3189     else if (pComponentPrivate->curState == OMX_StatePause)
3190     {
3191         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3192         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3193                                    EMMCodecControlStart, (void *)pArgs);
3194         if (eError != OMX_ErrorNone)
3195         {
3196             OMX_ERROR4(pComponentPrivate->dbg, "Error While Resuming the codec");
3197             goto EXIT;
3198         }
3199         if (pComponentPrivate->nNumInputBufPending <
3200             pComponentPrivate->pInputBufferList->numBuffers)
3201         {
3202             pComponentPrivate->nNumInputBufPending = pComponentPrivate->pInputBufferList->numBuffers;
3203         }
3204
3205         for (i=0; i < pComponentPrivate->nNumInputBufPending; i++)
3206         {
3207             if (pComponentPrivate->pInputBufHdrPending[i])
3208             {
3209                 if (!WMADEC_IsPending(pComponentPrivate,
3210                                       pComponentPrivate->pInputBufHdrPending[i],
3211                                       OMX_DirInput) )
3212                 {
3213                     WMADECGetCorresponding_LCMLHeader(
3214                                                       pComponentPrivate,
3215                                                       pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
3216                                                       OMX_DirInput, &pLcmlHdr);
3217
3218                     WMADEC_SetPending(pComponentPrivate,
3219                                       pComponentPrivate->pInputBufHdrPending[i],
3220                                       OMX_DirInput);
3221
3222                     eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3223                                               EMMCodecInputBuffer,
3224                                               pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
3225                                               pComponentPrivate->pInputBufHdrPending[i]->nAllocLen,
3226                                               pComponentPrivate->pInputBufHdrPending[i]->nFilledLen,
3227                                               (OMX_U8 *) pLcmlHdr->pIpParam,
3228                                               sizeof(WMADEC_UAlgInBufParamStruct),
3229                                               NULL);
3230                 }
3231             }
3232         }
3233         pComponentPrivate->nNumInputBufPending = 0;
3234         if (pComponentPrivate->nNumOutputBufPending <
3235             pComponentPrivate->pOutputBufferList->numBuffers)
3236         {
3237             pComponentPrivate->nNumOutputBufPending =
3238                 pComponentPrivate->pOutputBufferList->numBuffers;
3239         }
3240         for (i=0; i < pComponentPrivate->nNumOutputBufPending; i++)
3241         {
3242             if (pComponentPrivate->pOutputBufHdrPending[i])
3243             {
3244                 if (!WMADEC_IsPending(pComponentPrivate,
3245                                       pComponentPrivate->pOutputBufHdrPending[i],
3246                                       OMX_DirOutput) )
3247                 {
3248                     WMADECGetCorresponding_LCMLHeader(
3249                                                       pComponentPrivate,
3250                                                       pComponentPrivate->pOutputBufHdrPending[i]->pBuffer,
3251                                                       OMX_DirOutput, &pLcmlHdr);
3252
3253                     WMADEC_SetPending(pComponentPrivate,
3254                                       pComponentPrivate->pOutputBufHdrPending[i],
3255                                       OMX_DirOutput);
3256
3257                     pComponentPrivate->LastOutputBufferHdrQueued =
3258                         pComponentPrivate->pOutputBufHdrPending[i];
3259
3260                     eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3261                                               EMMCodecOuputBuffer,
3262                                               pComponentPrivate->pOutputBufHdrPending[i]->pBuffer,
3263                                               pComponentPrivate->pOutputBufHdrPending[i]->nAllocLen,
3264                                               pComponentPrivate->pOutputBufHdrPending[i]->nFilledLen,
3265                                               NULL,
3266                                               sizeof(WMADEC_UAlgInBufParamStruct),
3267                                               NULL);
3268                 }
3269             }
3270         }
3271         pComponentPrivate->nNumOutputBufPending = 0;
3272     }
3273     else
3274     {
3275         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3276         pComponentPrivate->cbInfo.EventHandler (pHandle,
3277                                                 pHandle->pApplicationPrivate,
3278                                                 OMX_EventError,
3279                                                 OMX_ErrorIncorrectStateTransition,
3280                                                 OMX_TI_ErrorMinor,
3281                                                 NULL);
3282         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Invalid State Given by Application",__LINE__);
3283         goto EXIT;
3284     }
3285 #ifdef RESOURCE_MANAGER_ENABLED
3286     rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet,
3287                                       OMX_WMA_Decoder_COMPONENT,
3288                                       OMX_StateExecuting, 1234, NULL);
3289 #endif
3290
3291
3292     pComponentPrivate->curState = OMX_StateExecuting;
3293 #ifdef __PERF_INSTRUMENTATION__
3294     PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart |
3295                   PERF_BoundarySteadyState);
3296 #endif
3297     /*Send state change notificaiton to Application */
3298     OMX_PRINT1(pComponentPrivate->dbg, "About to call EventHandler");
3299     pComponentPrivate->cbInfo.EventHandler( pHandle, pHandle->pApplicationPrivate,
3300                                             OMX_EventCmdComplete, OMX_CommandStateSet,
3301                                             pComponentPrivate->curState, NULL);
3302  EXIT:
3303     if (eError != OMX_ErrorNone ) {
3304         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3305                                                pComponentPrivate->pHandle->pApplicationPrivate,
3306                                                OMX_EventError,
3307                                                eError,
3308                                                OMX_TI_ErrorSevere,
3309                                                NULL);
3310     }
3311     return eError;
3312 }
3313
3314 /* ================================================================================= */
3315 /**
3316  * @fn WMADEC_CommandToPause() description for WMADEC_CommandToPause
3317  WMADEC_CommandToPause().
3318  This component is called by HandleCommand() when the component is commanded to Paused
3319  * @param pComponent  handle for this instance of the component
3320  *
3321  * @pre
3322  *
3323  * @post
3324  *
3325  * @return OMX_ERRORTYPE
3326  */
3327 /* ================================================================================ */
3328 OMX_ERRORTYPE WMADEC_CommandToPause(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
3329 {
3330
3331     OMX_COMPONENTTYPE *pHandle =
3332         (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
3333     OMX_HANDLETYPE pLcmlHandle = pComponentPrivate->pLcmlHandle;
3334
3335     OMX_ERRORTYPE eError = OMX_ErrorNone;
3336
3337     char *p = "hello";
3338
3339     OMX_PRINT1(pComponentPrivate->dbg, "%d: WMADECHandleCommand: Cmd Pause",__LINE__);
3340     if (pComponentPrivate->curState == OMX_StatePause)
3341     {
3342         pComponentPrivate->cbInfo.EventHandler (pHandle, pHandle->pApplicationPrivate,
3343                                                 OMX_EventError, OMX_ErrorSameState,
3344                                                 OMX_TI_ErrorMinor, NULL);
3345
3346         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Same State Given by Application",__LINE__);
3347         goto EXIT;
3348     }
3349     if (pComponentPrivate->curState != OMX_StateExecuting &&
3350         pComponentPrivate->curState != OMX_StateIdle)
3351     {
3352         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3353
3354         pComponentPrivate->cbInfo.EventHandler (pHandle,
3355                                                 pHandle->pApplicationPrivate,
3356                                                 OMX_EventError,
3357                                                 OMX_ErrorIncorrectStateTransition,
3358                                                 OMX_TI_ErrorMajor,
3359                                                 NULL);
3360
3361         OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Invalid State Given by Application",__LINE__);
3362         goto EXIT;
3363     }
3364 #ifdef __PERF_INSTRUMENTATION__
3365     PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundarySteadyState);
3366 #endif
3367     OMX_PRSTATE1(pComponentPrivate->dbg, "About to command to pause");
3368     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3369                                EMMCodecControlPause, (void *)p);
3370
3371     if (eError != OMX_ErrorNone)
3372     {
3373         OMX_ERROR4(pComponentPrivate->dbg, "%d : Error: in Pausing the codec",__LINE__);
3374         goto EXIT;
3375     }
3376
3377 #ifdef RESOURCE_MANAGER_ENABLED
3378 /* notify RM that codec is paused, resources can be redistributed if needed */
3379     eError = RMProxy_NewSendCommand(pHandle,
3380                                       RMProxy_StateSet,
3381                                       OMX_WMA_Decoder_COMPONENT,
3382                                       OMX_StatePause,
3383                                       1234,
3384                                       NULL);
3385 #endif
3386
3387     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c\n",__LINE__);
3388  EXIT:
3389     if (eError != OMX_ErrorNone ) {
3390         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3391                                                pComponentPrivate->pHandle->pApplicationPrivate,
3392                                                OMX_EventError,
3393                                                eError,
3394                                                OMX_TI_ErrorSevere,
3395                                                NULL);
3396     }
3397     return eError;
3398 }
3399 /* ================================================================================= */
3400 /**
3401  * @fn WMADEC_CommandToWaitForResources() description for WMADEC_CommandToWaitForResources
3402  WMADEC_CommandToWaitForResources().
3403  This component is called by HandleCommand() when the component is commanded
3404  to WaitForResources
3405  * @param pComponent  handle for this instance of the component
3406  *
3407  * @pre
3408  *
3409  * @post
3410  *
3411  * @return OMX_ERRORTYPE
3412  */
3413 /* ================================================================================ */
3414 OMX_ERRORTYPE WMADEC_CommandToWaitForResources(WMADEC_COMPONENT_PRIVATE *pComponentPrivate)
3415 {
3416
3417     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
3418
3419     OMX_ERRORTYPE eError = OMX_ErrorNone;
3420
3421     if (pComponentPrivate->curState == OMX_StateWaitForResources)
3422     {
3423         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3424
3425         pComponentPrivate->cbInfo.EventHandler (pHandle,
3426                                                 pHandle->pApplicationPrivate,
3427                                                 OMX_EventError,
3428                                                 OMX_ErrorSameState,
3429                                                 OMX_TI_ErrorMinor,
3430                                                 NULL);
3431
3432         OMX_ERROR2(pComponentPrivate->dbg, "%d :: Error: Same State Given by Application",__LINE__);
3433     }
3434     else if (pComponentPrivate->curState == OMX_StateLoaded)
3435     {
3436         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3437         pComponentPrivate->curState = OMX_StateWaitForResources;
3438
3439         pComponentPrivate->cbInfo.EventHandler(pHandle,
3440                                                pHandle->pApplicationPrivate,
3441                                                OMX_EventCmdComplete,
3442                                                OMX_CommandStateSet,
3443                                                pComponentPrivate->curState,
3444                                                NULL);
3445     }
3446     else
3447     {
3448         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3449
3450         pComponentPrivate->cbInfo.EventHandler(pHandle,
3451                                                pHandle->pApplicationPrivate,
3452                                                OMX_EventError,
3453                                                OMX_ErrorIncorrectStateTransition,
3454                                                OMX_TI_ErrorMinor,
3455                                                "NULL");
3456     }
3457
3458     return eError;
3459 }
3460
3461 /* ================================================================================= */
3462 /**
3463  * @fn WMADEC_SetPending() description for WMADEC_SetPending
3464  WMADEC_SetPending().
3465  This component is called when a buffer is queued to the LCML
3466  * @param pComponent  handle for this instance of the component
3467  *
3468  * @pre
3469  *
3470  * @post
3471  *
3472  * @return OMX_ERRORTYPE
3473  */
3474 /* ================================================================================ */
3475 void WMADEC_SetPending(WMADEC_COMPONENT_PRIVATE *pComponentPrivate,
3476                        OMX_BUFFERHEADERTYPE *pBufHdr,
3477                        OMX_DIRTYPE eDir)
3478 {
3479
3480     OMX_U16 i;
3481
3482     if (eDir == OMX_DirInput)
3483     {
3484         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++)
3485         {
3486             if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i])
3487             {
3488                 pComponentPrivate->pInputBufferList->bBufferPending[i] = 1;
3489                 OMX_PRBUFFER2(pComponentPrivate->dbg, "*******************INPUT BUFFER %d IS PENDING \
3490                               ******************************",i);
3491             }
3492         }
3493     }
3494     else
3495     {
3496         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++)
3497         {
3498             if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i])
3499             {
3500                 pComponentPrivate->pOutputBufferList->bBufferPending[i] = 1;
3501                 OMX_PRBUFFER2(pComponentPrivate->dbg, "*******************OUTPUT BUFFER %d IS PENDING \
3502                               ******************************",i);
3503             }
3504         }
3505     }
3506 }
3507 /* ================================================================================= */
3508 /**
3509  * @fn WMADEC_ClearPending() description for WMADEC_ClearPending
3510  WMADEC_ClearPending().
3511  This component is called when a buffer is returned from the LCML
3512  * @param pComponent  handle for this instance of the component
3513  *
3514  * @pre
3515  *
3516  * @post
3517  *
3518  * @return OMX_ERRORTYPE
3519  */
3520 /* ================================================================================ */
3521
3522 void WMADEC_ClearPending(WMADEC_COMPONENT_PRIVATE *pComponentPrivate,
3523                          OMX_BUFFERHEADERTYPE *pBufHdr,
3524                          OMX_DIRTYPE eDir)
3525 {
3526
3527     OMX_U16 i;
3528
3529     if (eDir == OMX_DirInput)
3530     {
3531         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++)
3532         {
3533             if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i])
3534             {
3535                 pComponentPrivate->pInputBufferList->bBufferPending[i] = 0;
3536                 OMX_PRBUFFER1(pComponentPrivate->dbg, "*******************INPUT BUFFER %d IS RECLAIMED\
3537                               ******************************",i);
3538             }
3539         }
3540     }
3541     else
3542     {
3543         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++)
3544         {
3545             if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i])
3546             {
3547                 pComponentPrivate->pOutputBufferList->bBufferPending[i] = 0;
3548                 OMX_PRBUFFER1(pComponentPrivate->dbg, "*******************OUTPUT BUFFER %d IS RECLAIMED******************************",i);
3549             }
3550         }
3551     }
3552 }
3553
3554 /* ================================================================================= */
3555 /**
3556  * @fn WMADEC_IsPending() description for WMADEC_IsPending
3557  WMADEC_IsPending().
3558  This method returns the pending status to the buffer
3559  * @param pComponent  handle for this instance of the component
3560  *
3561  * @pre
3562  *
3563  * @post
3564  *
3565  * @return OMX_ERRORTYPE
3566  */
3567 /* ================================================================================ */
3568 OMX_U32 WMADEC_IsPending(WMADEC_COMPONENT_PRIVATE *pComponentPrivate,
3569                          OMX_BUFFERHEADERTYPE *pBufHdr,
3570                          OMX_DIRTYPE eDir)
3571 {
3572
3573     OMX_U16 i;
3574
3575     if (eDir == OMX_DirInput)
3576     {
3577         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++)
3578         {
3579             if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i])
3580             {
3581                 return pComponentPrivate->pInputBufferList->bBufferPending[i];
3582             }
3583         }
3584     }
3585     else
3586     {
3587         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++)
3588         {
3589             if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i])
3590             {
3591                 return pComponentPrivate->pOutputBufferList->bBufferPending[i];
3592             }
3593         }
3594     }
3595     return -1;
3596 }
3597
3598 /* ================================================================================= */
3599 /**
3600  * @fn WMADEC_IsValid() description for WMADEC_Fill_LCMLInitParamsEx
3601  WMADEC_IsValid().
3602  This method checks to see if a buffer returned from the LCML is valid.
3603  * @param pComponent  handle for this instance of the component
3604  *
3605  * @pre
3606  *
3607  * @post
3608  *
3609  * @return OMX_ERRORTYPE
3610  */
3611 /* ================================================================================ */
3612 OMX_U32 WMADEC_IsValid(WMADEC_COMPONENT_PRIVATE *pComponentPrivate,
3613                        OMX_U8 *pBuffer,
3614                        OMX_DIRTYPE eDir)
3615 {
3616     OMX_U16 i;
3617     int found=0;
3618
3619     if (eDir == OMX_DirInput)
3620     {
3621         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++)
3622         {
3623             if (pBuffer == pComponentPrivate->pInputBufferList->pBufHdr[i]->pBuffer)
3624             {
3625                 found = 1;
3626             }
3627         }
3628     }
3629     else
3630     {
3631         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++)
3632         {
3633             if (pBuffer == pComponentPrivate->pOutputBufferList->pBufHdr[i]->pBuffer)
3634             {
3635                 found = 1;
3636             }
3637         }
3638     }
3639     return found;
3640 }
3641
3642
3643 /* ================================================================================= */
3644 /**
3645  * @fn WMADEC_Fill_LCMLInitParamsEx() description for WMADEC_Fill_LCMLInitParamsEx
3646  WMADEC_Fill_LCMLInitParamsEx().
3647  This method fills the LCML init parameters.
3648  * @param pComponent  handle for this instance of the component
3649  *
3650  * @pre
3651  *
3652  * @post
3653  *
3654  * @return OMX_ERRORTYPE
3655  */
3656 /* ================================================================================ */
3657
3658 OMX_ERRORTYPE WMADECFill_LCMLInitParamsEx(OMX_HANDLETYPE pComponent,OMX_U32 indexport)
3659 {
3660     OMX_ERRORTYPE eError = OMX_ErrorNone;
3661     OMX_U32 nIpBuf,nIpBufSize,nOpBuf,nOpBufSize;
3662     OMX_U16 i;
3663     OMX_BUFFERHEADERTYPE *pTemp;
3664     int size_lcml;
3665     LCML_WMADEC_BUFHEADERTYPE *pTemp_lcml = NULL;
3666     LCML_DSP_INTERFACE *pHandle = (LCML_DSP_INTERFACE *)pComponent;
3667     WMADEC_COMPONENT_PRIVATE *pComponentPrivate = pHandle->pComponentPrivate;
3668
3669     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entered WMADECFill_LCMLInitParams",__LINE__);
3670     OMX_PRDSP1(pComponentPrivate->dbg, "%d :: WMADECFill_LCMLInitParams - pComponentPrivate = %p",
3671                   __LINE__,pComponentPrivate);
3672     OMX_PRDSP1(pComponentPrivate->dbg, "%d :: WMADECFill_LCMLInitParams - pHandle = %p",
3673                   __LINE__,pHandle);
3674
3675     nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
3676     nIpBufSize = INPUT_WMADEC_BUFFER_SIZE;
3677
3678     nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
3679     nOpBufSize = pComponentPrivate->pPortDef[OUTPUT_BUFFER]->nBufferSize;
3680
3681
3682     OMX_PRBUFFER1(pComponentPrivate->dbg, "nIpBuf = %ld",nIpBuf);
3683     OMX_PRBUFFER1(pComponentPrivate->dbg, "nOpBuf = %ld",nOpBuf);
3684     if(indexport == 0 || indexport == -1){
3685         OMX_PRINT1(pComponentPrivate->dbg, "%d :: Comp: OMX_WmaDecUtils.c",__LINE__);
3686         size_lcml = nIpBuf * sizeof(LCML_WMADEC_BUFHEADERTYPE);
3687         OMX_MALLOC_SIZE(pTemp_lcml, size_lcml, LCML_WMADEC_BUFHEADERTYPE);
3688         OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[ALLOC] %p",__LINE__,pTemp_lcml);
3689         OMX_PRDSP1(pComponentPrivate->dbg, "Line %d::pTemp_lcml = %p",__LINE__,pTemp_lcml);
3690
3691         if(pTemp_lcml == NULL)
3692         {
3693             OMX_ERROR4(pComponentPrivate->dbg, "%d :: Memory Allocation Failed",__LINE__);
3694             eError = OMX_ErrorInsufficientResources;
3695             goto EXIT;
3696         }
3697
3698         pComponentPrivate->pLcmlBufHeader[INPUT_PORT] = pTemp_lcml;
3699
3700         OMX_PRBUFFER1(pComponentPrivate->dbg, "nIpBuf = %ld",nIpBuf);
3701
3702         for (i=0; i<nIpBuf; i++)
3703         {
3704             pTemp = pComponentPrivate->pInputBufferList->pBufHdr[i];
3705             pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
3706             pTemp->nAllocLen = nIpBufSize;
3707             pTemp->nFilledLen = nIpBufSize;
3708             pTemp->nVersion.s.nVersionMajor = WMADEC_MAJOR_VER;
3709             pTemp->nVersion.s.nVersionMinor = WMADEC_MINOR_VER;
3710             pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
3711             pTemp->nTickCount = NOT_USED;
3712             pTemp_lcml->buffer = pTemp;
3713             pTemp_lcml->eDir = OMX_DirInput;
3714
3715             OMX_MALLOC_SIZE_DSPALIGN(pTemp_lcml->pIpParam,
3716                                  sizeof(WMADEC_UAlgInBufParamStruct),
3717                                  WMADEC_UAlgInBufParamStruct);
3718
3719             if (pTemp_lcml->pIpParam == NULL)
3720             {
3721                 /* Free previously allocated memory before bailing */
3722                 if (pTemp_lcml != NULL) {
3723                     OMX_MEMFREE_STRUCT(pTemp_lcml);
3724                 }
3725
3726                 OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Malloc Failed...Exiting..",__LINE__);
3727                 goto EXIT;
3728             }
3729             pTemp_lcml->pIpParam->bLastBuffer = 0;
3730
3731             /* This means, it is not a last buffer. This flag is to be modified by
3732              * the application to indicate the last buffer */
3733             pTemp->nFlags = NORMAL_BUFFER;
3734             pTemp_lcml++;
3735         }
3736     }
3737     if(indexport == 1 || indexport == -1){
3738         /* Allocate memory for all output buffer headers..
3739          * This memory pointer will be sent to LCML */
3740         size_lcml = nOpBuf * sizeof(LCML_WMADEC_BUFHEADERTYPE);
3741         OMX_MALLOC_SIZE(pTemp_lcml, size_lcml, LCML_WMADEC_BUFHEADERTYPE);
3742         OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[ALLOC] %p",__LINE__,pTemp_lcml);
3743
3744         if(pTemp_lcml == NULL)
3745         {
3746             OMX_ERROR4(pComponentPrivate->dbg, "%d :: Memory Allocation Failed",__LINE__);
3747             eError = OMX_ErrorInsufficientResources;
3748             goto EXIT;
3749         }
3750
3751         pComponentPrivate->pLcmlBufHeader[OUTPUT_PORT] = pTemp_lcml;
3752
3753         pComponentPrivate->pOutputBufferList->EosFlagSent = 0;
3754         pComponentPrivate->InputEosSet = 0;
3755
3756         for (i=0; i<nOpBuf; i++)
3757         {
3758             pTemp = pComponentPrivate->pOutputBufferList->pBufHdr[i];
3759             pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
3760             pTemp->nAllocLen = nOpBufSize;
3761             pTemp->nFilledLen = nOpBufSize;
3762             pTemp->nVersion.s.nVersionMajor = WMADEC_MAJOR_VER;
3763             pTemp->nVersion.s.nVersionMinor = WMADEC_MINOR_VER;
3764             pComponentPrivate->nVersion = pTemp->nVersion.nVersion;
3765             pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
3766             pTemp->nTickCount = NOT_USED;
3767             /* This means, it is not a last buffer. This flag is to be modified by
3768              * the application to indicate the last buffer */
3769
3770             pTemp_lcml->buffer = pTemp;
3771             pTemp_lcml->eDir = OMX_DirOutput;
3772             pTemp->nFlags = NORMAL_BUFFER;
3773             pTemp++;
3774             pTemp_lcml++;
3775         }
3776     }
3777     pComponentPrivate->bPortDefsAllocated = 1;
3778
3779     OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting WMADECFill_LCMLInitParams",__LINE__);
3780
3781     pComponentPrivate->bInitParamsInitialized = 1;
3782  EXIT:
3783     return eError;
3784 }
3785 /*  =========================================================================*/
3786 /*  func    GetBits                                                          */
3787 /*                                                                           */
3788 /*  desc    Gets aBits number of bits from position aPosition of one buffer  */
3789 /*            and returns the value in a TUint value.                        */
3790 /*  =========================================================================*/
3791 OMX_U32 WMADEC_GetBits(OMX_U32* nPosition, OMX_U8 nBits, OMX_U8* pBuffer, OMX_BOOL bIcreasePosition)
3792 {
3793     OMXDBG_PRINT(stderr, PRINT, 1, 0, "%d :: Entering WMADEC_GetBits",__LINE__);
3794     OMX_U32 nOutput;
3795     OMX_U32 nNumBitsRead = 0;
3796     OMX_U32 nBytePosition = 0;
3797     OMX_U8  nBitPosition =  0;
3798     nBytePosition = *nPosition / 8;
3799     nBitPosition =  *nPosition % 8;
3800
3801     if (bIcreasePosition)
3802     *nPosition += nBits;
3803     nOutput = ((OMX_U32)pBuffer[nBytePosition] << (24+nBitPosition) );
3804     nNumBitsRead = nNumBitsRead + (8 - nBitPosition);
3805     if (nNumBitsRead < nBits)
3806     {
3807         nOutput = nOutput | ( pBuffer[nBytePosition + 1] << (16+nBitPosition));
3808         nNumBitsRead = nNumBitsRead + 8;
3809     }
3810     if (nNumBitsRead < nBits)
3811     {
3812         nOutput = nOutput | ( pBuffer[nBytePosition + 2] << (8+nBitPosition));
3813         nNumBitsRead = nNumBitsRead + 8;
3814     }
3815     if (nNumBitsRead < nBits)
3816     {
3817         nOutput = nOutput | ( pBuffer[nBytePosition + 3] << (nBitPosition));
3818         nNumBitsRead = nNumBitsRead + 8;
3819     }
3820     nOutput = nOutput >> (32 - nBits) ;
3821     return nOutput;
3822 }
3823 /*  ==========================================================================*/
3824 /*  func    WMADEC_Parser                                                     */
3825 /*                                                                            */
3826 /*  desc      Parses the WAVEFORMATEX data structure that is sent in the 1st  */
3827 /*            buffer and the it creates the RCA header and the block align    */
3828 /*  ==========================================================================*/
3829 OMX_ERRORTYPE WMADEC_Parser(OMX_U8* pBuffer, RCA_HEADER *pStreamData, struct OMX_TI_Debug dbg)
3830 {
3831     OMX_ERRORTYPE eError=0;
3832     OMX_PRINT1 (dbg, "Entering WMADEC_Parser function");
3833
3834     //These are the important fields that the socket node needs
3835     pStreamData->iTypeSpecific=0x1c;
3836     pStreamData->iFormatTag= *((OMX_U16*)(pBuffer));
3837     pStreamData->iChannel=*((OMX_U16 *)(pBuffer+2));
3838     pStreamData->iSamplePerSec=*((OMX_U32 *)(pBuffer+4));
3839     pStreamData->iAvgBytesPerSec=*((OMX_U32 *)(pBuffer+8)); //check
3840     pStreamData->iBlockAlign=*((OMX_U16 *)(pBuffer+2+4+4+2));
3841     pStreamData->iValidBitsPerSample=*((OMX_U16 *)(pBuffer+2+4+4+2+2));
3842     pStreamData->iEncodeOptV=*((OMX_U16 *)(pBuffer+2+4+4+2+2+2+2+2+2));
3843     pStreamData->iMaxPacketSize=pStreamData->iBlockAlign+31;
3844
3845     /*After this, the buffer has extra info, the Codc Specific Data Size which has 16 bites of length (2 bytes), and the Codec Specific Data of vari*/
3846     //Parsing information ended.
3847
3848     switch (pStreamData->iFormatTag)
3849     {
3850
3851     case WAVE_FORMAT_MSAUDIO :
3852         {
3853             OMX_PRINT2 (dbg, "WAVE_FORMAT_MSAUDIO");
3854             break;
3855             /*Make Necessary validations for supported parameter for specific format here */
3856         }
3857     case WAVE_FORMAT_MSAUDIO_9 :
3858         {
3859             OMX_PRINT2 (dbg, "WAVE_FORMAT_MSAUDIO_9");
3860             break;
3861             /*Make Necessary validations for supported parameter for specific format here */
3862         }
3863     case WAVE_FORMAT_MSAUDIO_9_LOOSELESS :
3864         {
3865             OMX_PRINT2 (dbg, "WAVE_FORMAT_MSAUDIO_9_LOOSELESS");
3866             break;
3867             /*Make Necessary validations for supported parameter for specific format here */
3868         }
3869     default:
3870         {
3871             break;
3872         }
3873     }
3874
3875     OMX_PRINT1 (dbg, "Exiting WMADEC_Parser function");
3876     return eError;
3877 }
3878
3879 /*  =========================================================================*/
3880 /*  func    WMADEC_HandleUSNError                                                                                    */
3881 /*                                                                                                                                              */
3882 /*  desc    Handles error messages returned by the dsp                                                        */
3883 /*                                                                                                                                              */
3884 /*@return n/a                                                                                                                           */
3885 /*                                                                                                                                              */
3886 /*  =========================================================================*/
3887 void WMADEC_HandleUSNError (WMADEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 arg)
3888 {
3889     OMX_COMPONENTTYPE *pHandle = NULL;
3890     OMX_U8 pending_buffers = OMX_FALSE;
3891     OMX_U32 i;
3892     switch (arg)
3893     {
3894         case IUALG_WARN_CONCEALED:
3895         case IUALG_WARN_UNDERFLOW:
3896         case IUALG_WARN_OVERFLOW:
3897         case IUALG_WARN_ENDOFDATA:
3898             OMX_ERROR4(pComponentPrivate->dbg,  "Algorithm Error" );
3899             /* all of these are informative messages, Algo can recover, no need to notify the
3900              * IL Client at this stage of the implementation */
3901             break;
3902
3903         case IUALG_WARN_PLAYCOMPLETED:
3904             {
3905                 OMX_PRDSP2(pComponentPrivate->dbg, "%d :: GOT MESSAGE IUALG_WARN_PLAYCOMPLETED\n", __LINE__);
3906                 pComponentPrivate->pOutputBufferList->EosFlagSent = 1;
3907                 pComponentPrivate->cbInfo.EventHandler(
3908                         pComponentPrivate->pHandle,
3909                         pComponentPrivate->pHandle->pApplicationPrivate,
3910                         OMX_EventBufferFlag,
3911                         (OMX_U32) NULL,
3912                         OMX_BUFFERFLAG_EOS, (OMX_PTR)OMX_BUFFERFLAG_EOS);
3913             }
3914             break;
3915
3916 #ifdef _ERROR_PROPAGATION__
3917         case IUALG_ERR_BAD_HANDLE:
3918         case IUALG_ERR_DATA_CORRUPT:
3919         case IUALG_ERR_NOT_SUPPORTED:
3920         case IUALG_ERR_ARGUMENT:
3921         case IUALG_ERR_NOT_READY:
3922         case IUALG_ERR_GENERAL:
3923
3924             {
3925                 /* all of these are fatal messages, Algo can not recover
3926                  * hence return an error */
3927                 OMX_ERROR4(pComponentPrivate->dbg,  "Algorithm Error, cannot recover" );
3928                 pComponentPrivate->bIsInvalidState=OMX_TRUE;
3929                 pComponentPrivate->curState = OMX_StateInvalid;
3930                 pHandle = pComponentPrivate->pHandle;
3931                 pComponentPrivate->cbInfo.EventHandler(pHandle,
3932                         pHandle->pApplicationPrivate,
3933                         OMX_EventError,
3934                         OMX_ErrorInvalidState,
3935                         OMX_TI_ErrorSevere,
3936                         NULL);
3937             }
3938             break;
3939 #endif
3940         default:
3941             break;
3942     }
3943 }
3944
3945
3946 #ifdef RESOURCE_MANAGER_ENABLED
3947 void WMAD_ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData)
3948 {
3949     OMX_COMMANDTYPE Cmd = OMX_CommandStateSet;
3950     OMX_STATETYPE state = OMX_StateIdle;
3951     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)cbData.hComponent;
3952     WMADEC_COMPONENT_PRIVATE *pCompPrivate = NULL;
3953
3954     pCompPrivate = (WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
3955
3956     if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesPreempted) {
3957         if (pCompPrivate->curState == OMX_StateExecuting ||
3958             pCompPrivate->curState == OMX_StatePause) {
3959             write (pCompPrivate->cmdPipe[1], &Cmd, sizeof(Cmd));
3960             write (pCompPrivate->cmdDataPipe[1], &state ,sizeof(OMX_U32));
3961
3962             pCompPrivate->bPreempted = 1;
3963         }
3964     }
3965     else if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesAcquired){
3966         pCompPrivate->cbInfo.EventHandler (
3967                             pHandle, pHandle->pApplicationPrivate,
3968                             OMX_EventResourcesAcquired, 0,0,
3969                             NULL);
3970
3971
3972     }
3973
3974 }
3975 #endif
3976