hardware/ti/omap3/omx/audio/src/openmax_il/g729_dec/src/OMX_G729Dec_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_G729Dec_Utils.c
  30  *
  31  * This file implements OMX Component for G729 decoder that
  32  * is fully compliant with the OMX Audio specification .
  33  *
  34  * @path  $(OMAPSW_MPU)\linux\audio\src\openmax_il\g729_dec\src
  35  *
  36  * @rev  0.5
  37  */
  38 /* -----------------------------------------------------------------------------
  39  *!
  40  *! Revision History
  41  *! ===================================
  42  *! Date         Author(s)            Version  Description
  43  *! ---------    -------------------  -------  ---------------------------------
  44  *! 03-Jan-2007  A.Donjon                         0.1      Code update for G729 DECODER
  45  *! 16-Feb-2007  A.Donjon                         0.2      Frame Lost
  46  *!                                                                                        Input buffer size used for buffer check in SN
  47  *! 01-Mar-2007  A.Donjon                         0.3      RM, DVFS changes
  48  *! 08-Jun-2007  A.Donjon                         0.4      Variable input buffer size
  49  *! 04-Jul-2007  A.Donjon                         0.5      Last output frame reset for repeated play wo deleting component
  50  *!
  51  *!
  52  * ================================================================================= */
  53
  54 /* ------compilation control switches -------------------------*/
  55
  56 /****************************************************************
  57  *  INCLUDE FILES
  58  ****************************************************************/
  59 /* ----- system and platform files ----------------------------*/
  60 #ifdef UNDER_CE
  61 #include <windows.h>
  62 #include <oaf_osal.h>
  63 #include <omx_core.h>
  64 #include <stdlib.h>
  65 #else
  66 #include <unistd.h>
  67 #include <sys/types.h>
  68 #include <sys/types.h>
  69 #include <sys/stat.h>
  70 #include <dlfcn.h>
  71 #include <malloc.h>
  72 #include <memory.h>
  73 #include <fcntl.h>
  74 #include <errno.h>
  75 #include <dlfcn.h>
  76 #endif
  77 #include <dbapi.h>
  78 #include <string.h>
  79 #include <stdio.h>
  80 /*-------program files ----------------------------------------*/
  81 #include "OMX_G729Decoder.h"
  82 #include "OMX_G729Dec_Utils.h"
  83 #include "g729decsocket_ti.h"
  84 #include "decode_common_ti.h"
  85 #include "OMX_G729Dec_ComponentThread.h"
  86 #include "usn.h"
  87 #ifdef __PERF_INSTRUMENTATION__
  88 #include "perf.h"
  89 #endif
  90
  91 /* ======================================================================= */
  92 /**
  93  * @def    DASF    Defines the value for identify DASF ON
  94  */
  95 /* ======================================================================= */
  96 #define DASF 1
  97
  98 #ifdef UNDER_CE
  99 #define HASHINGENABLE 1
 100 HINSTANCE g_hLcmlDllHandle = NULL;
 101
 102 #endif
 103
 104 static G729DEC_COMPONENT_PRIVATE *pComponentPrivate_CC;
 105 /* ========================================================================== */
 106 /**
 107  * @G729DECFill_LCMLInitParams () This function is used by the component thread to
 108  * fill the all of its initialization parameters, buffer deatils  etc
 109  * to LCML structure,
 110  *
 111  * @param pComponent  handle for this instance of the component
 112  * @param plcml_Init  pointer to LCML structure to be filled
 113  *
 114  * @pre
 115  *
 116  * @post
 117  *
 118  * @return none
 119  */
 120 /* ========================================================================== */
 121
 122 OMX_ERRORTYPE G729DECFill_LCMLInitParams(OMX_HANDLETYPE pComponent,
 123                                          LCML_DSP *plcml_Init, OMX_U16 arr[])
 124 {
 125
 126     OMX_ERRORTYPE eError = OMX_ErrorNone;
 127     OMX_U32 nIpBuf=0,nIpBufSize=0,nOpBuf=0,nOpBufSize=0;
 128     OMX_U32 i=0;
 129     OMX_BUFFERHEADERTYPE *pTemp = NULL;
 130     OMX_S16 size_lcml=0;
 131     LCML_STRMATTR *strmAttr = NULL;
 132
 133     LCML_DSP_INTERFACE *pHandle = (LCML_DSP_INTERFACE *)pComponent;
 134     G729DEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
 135     LCML_G729DEC_BUFHEADERTYPE *pTemp_lcml = NULL;
 136
 137     G729DEC_DPRINT("%d :: G729DECFill_LCMLInitParams\n ",__LINE__);
 138     G729DEC_DPRINT("%d :: pHandle = %p\n",__LINE__,pHandle);
 139     G729DEC_DPRINT("%d :: pHandle->pComponentPrivate = %p\n",__LINE__,pHandle->pComponentPrivate);
 140     pComponentPrivate = pHandle->pComponentPrivate;
 141
 142     pComponentPrivate->bufParamsArray = malloc((10 * sizeof(unsigned long int)) + 256);
 143     pComponentPrivate->bufParamsArray += 128;
 144     memset(pComponentPrivate->bufParamsArray, 0, 9 * sizeof(unsigned long int));
 145     nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
 146     pComponentPrivate->nRuntimeInputBuffers = nIpBuf;
 147     nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
 148     pComponentPrivate->nRuntimeOutputBuffers = nOpBuf;
 149     nIpBufSize = pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->nBufferSize;
 150     nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
 151     nOpBufSize = pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->nBufferSize;
 152
 153     G729DEC_DPRINT("------ Buffer Details -----------\n");
 154     G729DEC_DPRINT("Input  Buffer Count = %ld\n", nIpBuf);
 155     G729DEC_DPRINT("Input  Buffer Size = %ld\n", nIpBufSize);
 156     G729DEC_DPRINT("Output Buffer Count = %ld\n", nOpBuf);
 157     G729DEC_DPRINT("Output Buffer Size = %ld\n", nOpBufSize);
 158     G729DEC_DPRINT("------ Buffer Details ------------\n");
 159
 160     /* Fill Input Buffers Info for LCML */
 161     plcml_Init->In_BufInfo.nBuffers = nIpBuf;
 162     plcml_Init->In_BufInfo.nSize = nIpBufSize;
 163     plcml_Init->In_BufInfo.DataTrMethod = DMM_METHOD;
 164
 165
 166     /* Fill Output Buffers Info for LCML */
 167     plcml_Init->Out_BufInfo.nBuffers = nOpBuf;
 168     plcml_Init->Out_BufInfo.nSize = nOpBufSize;
 169     plcml_Init->Out_BufInfo.DataTrMethod = DMM_METHOD;
 170
 171     /*Copy the node information */
 172     plcml_Init->NodeInfo.nNumOfDLLs = 3;
 173
 174     plcml_Init->NodeInfo.AllUUIDs[0].uuid = &G729DECSOCKET_TI_UUID;
 175     strcpy ((char *)plcml_Init->NodeInfo.AllUUIDs[0].DllName,G729DEC_DLL_NAME);
 176     plcml_Init->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
 177
 178     plcml_Init->NodeInfo.AllUUIDs[1].uuid = &G729DECSOCKET_TI_UUID;
 179     strcpy ((char *)plcml_Init->NodeInfo.AllUUIDs[1].DllName,G729DEC_DLL_NAME);
 180     plcml_Init->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
 181
 182     plcml_Init->NodeInfo.AllUUIDs[2].uuid = &DECODE_COMMON_TI_UUID;
 183     strcpy ((char *)plcml_Init->NodeInfo.AllUUIDs[2].DllName,G729DEC_USN_DLL_NAME);
 184     plcml_Init->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
 185
 186
 187     if(pComponentPrivate->dasfmode == 1) {
 188         G729DEC_DPRINT("pComponentPrivate->dasfmode = %d\n",pComponentPrivate->dasfmode);
 189         OMX_G729MALLOC_STRUCT(strmAttr, LCML_STRMATTR);
 190
 191         pComponentPrivate->strmAttr = strmAttr;
 192         G729DEC_MEMPRINT("%d:[ALLOC] %p\n",__LINE__,strmAttr);
 193
 194         strmAttr->uSegid = 0;
 195         strmAttr->uAlignment = 0;
 196         strmAttr->uTimeout = G729D_TIMEOUT;
 197         strmAttr->uBufsize = nOpBufSize;
 198         strmAttr->uNumBufs = 2;
 199         strmAttr->lMode = STRMMODE_PROCCOPY;
 200         plcml_Init->DeviceInfo.TypeofDevice =1;
 201         plcml_Init->DeviceInfo.TypeofRender =0;
 202         if(pComponentPrivate->acdnmode == 1)
 203         {
 204             /* DASF/TeeDN mode */
 205             plcml_Init->DeviceInfo.AllUUIDs[0].uuid = &ACDN_TI_UUID;
 206         }
 207         else
 208         {
 209             /* ACDN mode */
 210             plcml_Init->DeviceInfo.AllUUIDs[0].uuid = &DCTN_TI_UUID;
 211         }
 212         plcml_Init->DeviceInfo.DspStream = strmAttr;
 213     }
 214     else {
 215         pComponentPrivate->strmAttr = NULL;
 216     }
 217
 218
 219     /*copy the other information */
 220     plcml_Init->SegID = OMX_G729DEC_DEFAULT_SEGMENT;
 221     plcml_Init->Timeout = OMX_G729DEC_SN_TIMEOUT;
 222     plcml_Init->Alignment = 0;
 223     plcml_Init->Priority = OMX_G729DEC_SN_PRIORITY;
 224     plcml_Init->ProfileID = -1;
 225
 226
 227     /* TODO: Set this using SetParameter() */
 228     pComponentPrivate->iG729SamplingFrequeny = G729DEC_SAMPLING_FREQUENCY;
 229
 230     /*Accessing these 2 has the problem/creates problem in state transition tests*/
 231     pComponentPrivate->iG729Channels =
 232         (OMX_U16)pComponentPrivate->pcmParams->nChannels;
 233
 234     /* Set G729 SN create phase arguments */
 235
 236     arr[0] = STREAM_COUNT;
 237     arr[1] = G729DEC_INPUT_PORT;
 238     arr[2] = G729DEC_DMM;
 239     if (pComponentPrivate->pInputBufferList->numBuffers) {
 240         arr[3] = (OMX_U16)pComponentPrivate->pInputBufferList->numBuffers;
 241
 242     }
 243     else {
 244         arr[3] = 1;
 245     }
 246
 247     arr[4] = G729DEC_OUTPUT_PORT;
 248
 249     if(pComponentPrivate->dasfmode == 1) {
 250         G729DEC_DPRINT("Setting up create phase params for DASF mode\n");
 251         arr[5] = G729DEC_OUTSTRM;
 252         arr[6] = NUM_G729DEC_OUTPUT_BUFFERS_DASF;
 253     }
 254     else {
 255
 256         G729DEC_DPRINT("Setting up create phase params for FILE mode\n");
 257         arr[5] = G729DEC_DMM;
 258         if (pComponentPrivate->pOutputBufferList->numBuffers) {
 259             arr[6] = (OMX_U16)pComponentPrivate->pOutputBufferList->numBuffers;
 260         }
 261         else {
 262             arr[6] = 1;
 263         }
 264
 265     }
 266
 267     arr[7] = END_OF_CR_PHASE_ARGS;
 268     plcml_Init->pCrPhArgs = arr;
 269     size_lcml = (OMX_U16)(nIpBuf * sizeof(LCML_G729DEC_BUFHEADERTYPE));
 270     pTemp_lcml = (LCML_G729DEC_BUFHEADERTYPE *)malloc(size_lcml);
 271     G729DEC_MEMPRINT("%d:[ALLOC] %p\n",__LINE__,pTemp_lcml);
 272     if(pTemp_lcml == NULL) {
 273         G729DEC_DPRINT("%d :: Memory Allocation Failed\n",__LINE__);
 274         /* Free previously allocated memory before bailing */
 275         if (strmAttr) {
 276             free(strmAttr);
 277             strmAttr = NULL;
 278         }
 279         eError = OMX_ErrorInsufficientResources;
 280         goto EXIT;
 281     }
 282     pComponentPrivate->pLcmlBufHeader[G729DEC_INPUT_PORT] = pTemp_lcml;
 283
 284     for (i=0; i<nIpBuf; i++) {
 285         pTemp = pComponentPrivate->pInputBufferList->pBufHdr[i];
 286         pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
 287         pTemp->nAllocLen = nIpBufSize;
 288         pTemp->nFilledLen = nIpBufSize;
 289         pTemp->nVersion.s.nVersionMajor = G729DEC_MAJOR_VER;
 290         pTemp->nVersion.s.nVersionMinor = G729DEC_MINOR_VER;
 291         pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
 292         pTemp_lcml->buffer = pTemp;
 293         pTemp_lcml->eDir = OMX_DirInput;
 294         OMX_G729MALLOC_STRUCT(pTemp_lcml->pIpParam, G729DEC_UAlgBufParamStruct);
 295         pTemp_lcml->pIpParam->usFrameLost = 0;
 296         pTemp_lcml->pIpParam->usLastFrame = 0;
 297         /* This means, it is not a last buffer. This flag is to be modified by
 298          * the application to indicate the last buffer */
 299         pTemp->nFlags = NORMAL_BUFFER;
 300         pTemp++;
 301         pTemp_lcml++;
 302     }
 303
 304     /* Allocate memory for all output buffer headers..
 305      * This memory pointer will be sent to LCML */
 306     size_lcml = (OMX_U16)(nOpBuf * sizeof(LCML_G729DEC_BUFHEADERTYPE));
 307     pTemp_lcml = (LCML_G729DEC_BUFHEADERTYPE *)malloc(size_lcml);
 308     G729DEC_MEMPRINT("%d:[ALLOC] %p\n",__LINE__,pTemp_lcml);
 309     if(pTemp_lcml == NULL) {
 310         /* Free previously allocated memory before bailing */
 311         if (strmAttr) {
 312             free(strmAttr);
 313             strmAttr = NULL;
 314         }
 315         eError = OMX_ErrorInsufficientResources;
 316         goto EXIT;
 317     }
 318     memset(pTemp_lcml, 0x0, size_lcml);
 319     pComponentPrivate->pLcmlBufHeader[G729DEC_OUTPUT_PORT] = pTemp_lcml;
 320
 321     for (i=0; i<nOpBuf; i++) {
 322         pTemp = pComponentPrivate->pOutputBufferList->pBufHdr[i];
 323         pTemp->nSize = (OMX_U16)sizeof(OMX_BUFFERHEADERTYPE);
 324         pTemp->nAllocLen = nOpBufSize;
 325         pTemp->nFilledLen = nOpBufSize;
 326         pTemp->nVersion.s.nVersionMajor = G729DEC_MAJOR_VER;
 327         pTemp->nVersion.s.nVersionMinor = G729DEC_MINOR_VER;
 328         pComponentPrivate->nVersion = pTemp->nVersion.nVersion;
 329         pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
 330         pTemp->nTickCount = 0;
 331         pTemp->nTimeStamp = 0;
 332         /* This means, it is not a last buffer. This flag is to be modified by
 333          * the application to indicate the last buffer */
 334         pTemp_lcml->buffer = pTemp;
 335         pTemp_lcml->eDir = OMX_DirOutput;
 336         OMX_G729MALLOC_STRUCT(pTemp_lcml->pIpParam, G729DEC_UAlgBufParamStruct);
 337         pTemp_lcml->pIpParam->usFrameLost = 0;
 338         pTemp_lcml->pIpParam->usLastFrame = 0;
 339         pTemp->nFlags = NORMAL_BUFFER;
 340         pTemp++;
 341         pTemp_lcml++;
 342     }
 343 #ifdef __PERF_INSTRUMENTATION__
 344     pComponentPrivate->nLcml_nCntIp = 0;
 345     pComponentPrivate->nLcml_nCntOpReceived = 0;
 346 #endif
 347     pComponentPrivate->bPortDefsAllocated = 1;
 348     pComponentPrivate->bInitParamsInitialized = 1;
 349
 350
 351  EXIT:
 352     G729DEC_DPRINT("%d :: Exiting G729DECFill_LCMLInitParams",__LINE__);
 353     return eError;
 354 }
 355
 356
 357 /* ========================================================================== */
 358 /**
 359  * @G729DEC_StartComponentThread() This function is called by the component to create
 360  * the component thread, command pipe and data pipe.
 361  *
 362  * @param pComponent  handle for this instance of the component
 363  *
 364  * @pre
 365  *
 366  * @post
 367  *
 368  * @return none
 369  */
 370 /* ========================================================================== */
 371
 372
 373
 374 OMX_ERRORTYPE G729DEC_StartComponentThread(OMX_HANDLETYPE pComponent)
 375 {
 376     OMX_ERRORTYPE eError = OMX_ErrorNone;
 377     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 378     G729DEC_COMPONENT_PRIVATE *pComponentPrivate =
 379         (G729DEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
 380 #ifdef UNDER_CE
 381     pthread_attr_t attr;
 382     memset(&attr, 0, sizeof(attr));
 383     attr.__inheritsched = PTHREAD_EXPLICIT_SCHED;
 384     attr.__schedparam.__sched_priority = OMX_AUDIO_DECODER_THREAD_PRIORITY;
 385 #endif
 386     G729DEC_DPRINT ("%d :: Inside  G729DEC_StartComponentThread\n", __LINE__);
 387
 388     /* Initialize all the variables*/
 389     pComponentPrivate->bIsStopping = 0;
 390     pComponentPrivate->bCompThreadStop = 0;
 391     pComponentPrivate->lcml_nOpBuf = 0;
 392     pComponentPrivate->lcml_nIpBuf = 0;
 393     pComponentPrivate->app_nBuf = 0;
 394     pComponentPrivate->num_Op_Issued = 0;
 395     pComponentPrivate->num_Sent_Ip_Buff = 0;
 396     pComponentPrivate->num_Reclaimed_Op_Buff = 0;
 397     pComponentPrivate->bIsEOFSent = 0;
 398
 399     /* create the pipe used to send buffers to the thread */
 400     eError = pipe (pComponentPrivate->cmdDataPipe);
 401     if (eError) {
 402         eError = OMX_ErrorInsufficientResources;
 403         goto EXIT;
 404     }
 405
 406     /* create the pipe used to send buffers to the thread */
 407     eError = pipe (pComponentPrivate->dataPipe);
 408     if (eError) {
 409         eError = OMX_ErrorInsufficientResources;
 410         goto EXIT;
 411     }
 412
 413     /* create the pipe used to send commands to the thread */
 414     eError = pipe (pComponentPrivate->cmdPipe);
 415     if (eError) {
 416         eError = OMX_ErrorInsufficientResources;
 417         goto EXIT;
 418     }
 419
 420     /* Create the Component Thread */
 421 #ifdef UNDER_CE
 422     eError = pthread_create (&(pComponentPrivate->ComponentThread), &attr,
 423                              G729DEC_ComponentThread, pComponentPrivate);
 424 #else
 425     eError = pthread_create (&(pComponentPrivate->ComponentThread), NULL,
 426                              G729DEC_ComponentThread, pComponentPrivate);
 427 #endif
 428     if (eError || !pComponentPrivate->ComponentThread) {
 429         eError = OMX_ErrorInsufficientResources;
 430         goto EXIT;
 431     }
 432     pComponentPrivate_CC = pComponentPrivate;
 433
 434     pComponentPrivate->bCompThreadStarted = 1;
 435  EXIT:
 436     return eError;
 437 }
 438
 439 /* ========================================================================== */
 440 /**
 441  * @G729DEC_FreeCompResources() This function is called by the component during
 442  * de-init to close component thread, Command pipe, data pipe & LCML pipe.
 443  *
 444  * @param pComponent  handle for this instance of the component
 445  *
 446  * @pre
 447  *
 448  * @post
 449  *
 450  * @return none
 451  */
 452 /* ========================================================================== */
 453
 454 OMX_ERRORTYPE G729DEC_FreeCompResources(OMX_HANDLETYPE pComponent)
 455 {
 456     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 457     G729DEC_COMPONENT_PRIVATE *pComponentPrivate = (G729DEC_COMPONENT_PRIVATE *)
 458         pHandle->pComponentPrivate;
 459
 460     OMX_ERRORTYPE eError = OMX_ErrorNone;
 461     OMX_ERRORTYPE err = OMX_ErrorNone;
 462     OMX_U32 nIpBuf = 0;
 463     OMX_U32 nOpBuf = 0;
 464
 465     G729DEC_DPRINT ("%d :: G729DEC_FreeCompResources\n", __LINE__);
 466
 467     if (pComponentPrivate->bPortDefsAllocated) {
 468         nIpBuf = pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->nBufferCountActual;
 469         nOpBuf = pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->nBufferCountActual;
 470     }
 471
 472     if (pComponentPrivate->bCompThreadStarted) {
 473         err = close (pComponentPrivate->dataPipe[0]);
 474
 475         if (0 != err && OMX_ErrorNone == eError) {
 476             eError = OMX_ErrorHardware;
 477         }
 478
 479         err = close (pComponentPrivate->dataPipe[1]);
 480         if (0 != err && OMX_ErrorNone == eError) {
 481             eError = OMX_ErrorHardware;
 482         }
 483
 484         err = close (pComponentPrivate->cmdPipe[0]);
 485         if (0 != err && OMX_ErrorNone == eError) {
 486             eError = OMX_ErrorHardware;
 487         }
 488
 489         err = close (pComponentPrivate->cmdPipe[1]);
 490         if (0 != err && OMX_ErrorNone == eError) {
 491             eError = OMX_ErrorHardware;
 492         }
 493
 494         err = close (pComponentPrivate->cmdDataPipe[0]);
 495         if (0 != err && OMX_ErrorNone == eError) {
 496             eError = OMX_ErrorHardware;
 497         }
 498
 499         err = close (pComponentPrivate->cmdDataPipe[1]);
 500         if (0 != err && OMX_ErrorNone == eError) {
 501             eError = OMX_ErrorHardware;
 502         }
 503
 504     }
 505
 506     if (pComponentPrivate->bPortDefsAllocated) {
 507         if (pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]) {
 508             G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]);
 509             free(pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]);
 510             pComponentPrivate->pPortDef[G729DEC_INPUT_PORT] = NULL;
 511         }
 512         pComponentPrivate->pPortDef[G729DEC_INPUT_PORT] = NULL;
 513
 514         if (pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]) {
 515             G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]);
 516             free (pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]);
 517             pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT] = NULL;
 518         }
 519         pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT] = NULL;
 520
 521         if (pComponentPrivate->g729Params) {
 522             G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pComponentPrivate->g729Params);
 523             free(pComponentPrivate->g729Params);
 524             pComponentPrivate->g729Params = NULL;
 525         }
 526
 527         if (pComponentPrivate->pcmParams) {
 528             G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pComponentPrivate->pcmParams);
 529             free (pComponentPrivate->pcmParams);
 530             pComponentPrivate->pcmParams = NULL;
 531         }
 532     }
 533     pComponentPrivate->bPortDefsAllocated = 0;
 534     return eError;
 535 }
 536
 537
 538
 539 OMX_ERRORTYPE G729DEC_CleanupInitParams(OMX_HANDLETYPE pComponent)
 540 {
 541     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 542     G729DEC_COMPONENT_PRIVATE *pComponentPrivate = (G729DEC_COMPONENT_PRIVATE *)
 543         pHandle->pComponentPrivate;
 544
 545     LCML_G729DEC_BUFHEADERTYPE *pTemp_lcml = NULL;
 546
 547     OMX_ERRORTYPE eError = OMX_ErrorNone;
 548     OMX_U32 nIpBuf = 0;
 549     OMX_U32 nOpBuf = 0;
 550     OMX_U32 i=0;
 551
 552     G729DEC_DPRINT ("%d :: G729DEC_CleanupInitParams()\n", __LINE__);
 553
 554     if (pComponentPrivate->strmAttr) {
 555         free(pComponentPrivate->strmAttr);
 556         pComponentPrivate->strmAttr = NULL;
 557     }
 558     if(pComponentPrivate->pParams!=NULL){
 559         free(pComponentPrivate->pParams);
 560         pComponentPrivate->pParams = NULL;
 561     }
 562
 563     nIpBuf = pComponentPrivate->nRuntimeInputBuffers;
 564     pTemp_lcml = pComponentPrivate->pLcmlBufHeader[G729DEC_INPUT_PORT];
 565
 566     for(i=0; i<nIpBuf; i++) {
 567         G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pTemp_lcml->pIpParam);
 568         free(pTemp_lcml->pIpParam);
 569         pTemp_lcml->pIpParam = NULL;
 570         pTemp_lcml++;
 571     }
 572
 573
 574     nOpBuf = pComponentPrivate->nRuntimeOutputBuffers;
 575     pTemp_lcml = pComponentPrivate->pLcmlBufHeader[G729DEC_OUTPUT_PORT];
 576     for(i=0; i<nOpBuf; i++) {
 577         G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pTemp_lcml->pIpParam);
 578         free(pTemp_lcml->pIpParam);
 579         pTemp_lcml->pIpParam = NULL;
 580         pTemp_lcml++;
 581     }
 582
 583     if(pComponentPrivate->bufParamsArray != NULL){
 584         pComponentPrivate->bufParamsArray -= 128;
 585         free(pComponentPrivate->bufParamsArray);
 586         pComponentPrivate->bufParamsArray = NULL;
 587     }
 588     G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pComponentPrivate->pLcmlBufHeader[G729DEC_INPUT_PORT]);
 589     free(pComponentPrivate->pLcmlBufHeader[G729DEC_INPUT_PORT]);
 590     pComponentPrivate->pLcmlBufHeader[G729DEC_INPUT_PORT] = NULL;
 591
 592     G729DEC_MEMPRINT("%d:[FREE] %p\n",__LINE__,pComponentPrivate->pLcmlBufHeader[G729DEC_OUTPUT_PORT]);
 593     free(pComponentPrivate->pLcmlBufHeader[G729DEC_OUTPUT_PORT]);
 594     pComponentPrivate->pLcmlBufHeader[G729DEC_OUTPUT_PORT] = NULL;
 595     return eError;
 596 }
 597
 598 /* ========================================================================== */
 599 /**
 600  * @G729DEC_StopComponentThread() This function is called by the component during
 601  * de-init to close component thread, Command pipe, data pipe & LCML pipe.
 602  *
 603  * @param pComponent  handle for this instance of the component
 604  *
 605  * @pre
 606  *
 607  * @post
 608  *
 609  * @return none
 610  */
 611 /* ========================================================================== */
 612
 613 OMX_ERRORTYPE G729DEC_StopComponentThread(OMX_HANDLETYPE pComponent)
 614 {
 615     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
 616     G729DEC_COMPONENT_PRIVATE *pComponentPrivate = (G729DEC_COMPONENT_PRIVATE *)
 617         pHandle->pComponentPrivate;
 618
 619     OMX_ERRORTYPE eError = OMX_ErrorNone;
 620     OMX_ERRORTYPE threadError = OMX_ErrorNone;
 621     OMX_S16 pthreadError = 0;
 622
 623     /*Join the component thread */
 624     pComponentPrivate->bIsStopping = 1;
 625     pComponentPrivate->bCompThreadStop = 1;
 626     pthreadError = pthread_join (pComponentPrivate->ComponentThread,
 627                                  (void*)&threadError);
 628     if (0 != pthreadError) {
 629         eError = OMX_ErrorHardware;
 630     }
 631
 632     /*Check for the errors */
 633     if (OMX_ErrorNone != threadError && OMX_ErrorNone != eError) {
 634         eError = OMX_ErrorInsufficientResources;
 635         G729DEC_DPRINT ("%d :: Error while closing Component Thread\n",__LINE__);
 636     }
 637     return eError;
 638 }
 639
 640
 641 /* ========================================================================== */
 642 /**
 643  * @G729DECHandleCommand() This function is called by the component when ever it
 644  * receives the command from the application
 645  *
 646  * @param pComponentPrivate  Component private data
 647  *
 648  * @pre
 649  *
 650  * @post
 651  *
 652  * @return none
 653  */
 654 /* ========================================================================== */
 655
 656 OMX_U32 G729DECHandleCommand (G729DEC_COMPONENT_PRIVATE *pComponentPrivate)
 657 {
 658
 659     OMX_COMPONENTTYPE *pHandle = NULL;
 660     OMX_COMMANDTYPE command;
 661     OMX_STATETYPE commandedState = OMX_StateInvalid;
 662     OMX_U32 commandData  = 0;
 663     OMX_HANDLETYPE pLcmlHandle = pComponentPrivate->pLcmlHandle;
 664     OMX_ERRORTYPE rm_error = OMX_ErrorNone;
 665     OMX_U16 i = 0;
 666     OMX_ERRORTYPE eError = OMX_ErrorNone;
 667     OMX_U32 nBuf = 0;
 668     OMX_U16 arr[100] = {0};
 669     OMX_S8 *p = (OMX_S8 *)"hello";
 670     LCML_CALLBACKTYPE cb;
 671     LCML_DSP *pLcmlDsp = NULL;
 672     G729DEC_AudioCodecParams *pParams = NULL;
 673     OMX_S16 ret = 0;
 674     LCML_G729DEC_BUFHEADERTYPE *pLcmlHdr = NULL;
 675     int inputPortFlag=0,outputPortFlag=0;
 676     OMX_U8 frameType = 0;
 677     OMX_U32 nOpBuf = 0;
 678
 679     G729DEC_DPRINT ("%d :: Entering G729DECHandleCommand Function\n", __LINE__);
 680
 681     pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
 682     G729DEC_DPRINT("pComponentPrivate->pHandle = %p at HandleCommand\n", pComponentPrivate->pHandle);
 683
 684     ret = (OMX_U16)(read (pComponentPrivate->cmdPipe[0], &command, sizeof (command)));
 685     if (ret == -1) {
 686         G729DEC_EPRINT ("%d :: Error While reading from the Pipe\n",__LINE__);
 687         eError = OMX_ErrorHardware;
 688         goto EXIT;
 689     }
 690
 691     ret = (OMX_U16)(read (pComponentPrivate->cmdDataPipe[0], &commandData, sizeof (commandData)));
 692     if (ret == -1) {
 693         G729DEC_EPRINT ("%d :: Error While reading from the Pipe\n",__LINE__);
 694         eError = OMX_ErrorHardware;
 695         goto EXIT;
 696     }
 697
 698 #ifdef __PERF_INSTRUMENTATION__
 699     PERF_ReceivedCommand(pComponentPrivate->pPERFcomp, command, commandData,
 700                          PERF_ModuleLLMM);
 701 #endif
 702
 703     if (command == OMX_CommandStateSet) {
 704         commandedState = (OMX_STATETYPE)commandData;
 705         if (pComponentPrivate->curState == commandedState){
 706             pComponentPrivate->cbInfo.EventHandler (
 707                                                     pHandle, pHandle->pApplicationPrivate,
 708                                                     OMX_EventError, OMX_ErrorSameState,0,
 709                                                     NULL);
 710             goto EXIT;
 711         }
 712
 713         switch(commandedState) {
 714         case OMX_StateIdle:
 715
 716 #ifdef __PERF_INSTRUMENTATION__
 717             PERF_Boundary(pComponentPrivate->pPERFcomp,
 718                           PERF_BoundaryStart | PERF_BoundarySetup);
 719 #endif
 720             if (pComponentPrivate->curState == OMX_StateLoaded || pComponentPrivate->curState == OMX_StateWaitForResources) {
 721
 722                 if (pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bPopulated &&
 723                     pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bEnabled)  {
 724                     inputPortFlag = 1;
 725                 }
 726                 if (!pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bPopulated &&
 727                     !pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bEnabled) {
 728                     inputPortFlag = 1;
 729                 }
 730                 if (pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bPopulated &&
 731                     pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bEnabled) {
 732                     outputPortFlag = 1;
 733                 }
 734                 if (!pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bPopulated &&
 735                     !pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bEnabled) {
 736                     outputPortFlag = 1;
 737                 }
 738                 if (!(inputPortFlag && outputPortFlag)) {
 739                     pComponentPrivate->InLoaded_readytoidle = 1;
 740
 741 #ifndef UNDER_CE
 742                     pthread_mutex_lock(&pComponentPrivate->InLoaded_mutex);
 743                     pthread_cond_wait(&pComponentPrivate->InLoaded_threshold, &pComponentPrivate->InLoaded_mutex);
 744                     pthread_mutex_unlock(&pComponentPrivate->InLoaded_mutex);
 745 #else
 746                     OMX_WaitForEvent(&(pComponentPrivate->InLoaded_event));
 747 #endif
 748                 }
 749
 750                 G729DEC_DPRINT ("%d :: Inside G729DECHandleCommand\n",__LINE__);
 751                 cb.LCML_Callback = (void *) G729DECLCML_Callback;
 752                 pLcmlHandle = (OMX_HANDLETYPE) G729DECGetLCMLHandle(pComponentPrivate);
 753                 if (pLcmlHandle == NULL) {
 754                     G729DEC_DPRINT("%d :: LCML Handle is NULL........exiting..\n",__LINE__);
 755                     goto EXIT;
 756                 }
 757                 G729DEC_DPRINT("G729DECHandleCommand %d\n",__LINE__);
 758                 G729DEC_DPRINT("pLcmlHandle = %p\n",pLcmlHandle);
 759
 760                 /* Got handle of dsp via phandle filling information about DSP
 761                    specific things */
 762                 pLcmlDsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
 763                 G729DEC_DPRINT("pLcmlDsp = %p\n",pLcmlDsp);
 764                 eError = G729DECFill_LCMLInitParams(pHandle, pLcmlDsp, arr);
 765                 if(eError != OMX_ErrorNone) {
 766                     G729DEC_DPRINT("%d :: Error returned from\
 767                                                             G729DECFill_LCMLInitParams()\n",__LINE__);
 768                     goto EXIT;
 769                 }
 770                 G729DEC_DPRINT("%d :: Comp: OMX_G729DecUtils.c\n",__LINE__);
 771                 pComponentPrivate->pLcmlHandle = (LCML_DSP_INTERFACE *)pLcmlHandle;
 772                 /*filling create phase params */
 773                 /*         cb.LCML_Callback = (void *) G729DECLCML_Callback;
 774                            G729DEC_DPRINT("%d :: Calling LCML_InitMMCodec...\n",__LINE__); */
 775
 776 #ifndef UNDER_CE
 777                 /* TeeDN will be default for decoder component */
 778                 G729DEC_DPRINT("G729 decoder support TeeDN\n");
 779                 eError = LCML_InitMMCodecEx(((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle,
 780                                             (void *)p,&pLcmlHandle,(void *)p,&cb, (OMX_STRING)pComponentPrivate->sDeviceString);
 781 #else
 782                 eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle,
 783                                           (void *)p,&pLcmlHandle,(void *)p,&cb);
 784 #endif
 785                 if(eError != OMX_ErrorNone) {
 786                     G729DEC_EPRINT("%d :: Error returned from LCML_Init()\n",__LINE__);
 787                     goto EXIT;
 788                 }
 789 #ifdef HASHINGENABLE
 790                 /* Enable the Hashing Code */
 791                 eError = LCML_SetHashingState(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, OMX_TRUE);
 792                 if (eError != OMX_ErrorNone) {
 793                     G729DEC_DPRINT("Failed to set Mapping State\n");
 794                     goto EXIT;
 795                 }
 796 #endif
 797
 798
 799
 800 #ifdef RESOURCE_MANAGER_ENABLED
 801                 /* need check the resource with RM */
 802                 pComponentPrivate->rmproxyCallback.RMPROXY_Callback = (void *) G729DEC_ResourceManagerCallback;
 803                 rm_error = RMProxy_NewSendCommand(pHandle,
 804                                                   RMProxy_RequestResource,
 805                                                   OMX_G729_Decoder_COMPONENT,
 806                                                   G729DEC_CPU,
 807                                                   3456,
 808                                                   &(pComponentPrivate->rmproxyCallback));
 809                 if(rm_error == OMX_ErrorNone) {
 810                     /* resource is available */
 811                     rm_error = RMProxy_NewSendCommand(pHandle,
 812                                                       RMProxy_StateSet,
 813                                                       OMX_G729_Decoder_COMPONENT,
 814                                                       OMX_StateIdle,
 815                                                       3456,NULL);
 816                     pComponentPrivate->curState = OMX_StateIdle;
 817                     pComponentPrivate->cbInfo.EventHandler(pHandle,
 818                                                            pHandle->pApplicationPrivate,
 819                                                            OMX_EventCmdComplete,
 820                                                            OMX_CommandStateSet,
 821                                                            pComponentPrivate->curState,
 822                                                            NULL);
 823                 }
 824                 else if(rm_error == OMX_ErrorInsufficientResources) {
 825                     /* resource is not available, need set state to OMX_StateWaitForResources */
 826                     pComponentPrivate->curState = OMX_StateWaitForResources;
 827                     pComponentPrivate->cbInfo.EventHandler(pHandle,
 828                                                            pHandle->pApplicationPrivate,
 829                                                            OMX_EventCmdComplete,
 830                                                            OMX_CommandStateSet,
 831                                                            pComponentPrivate->curState,
 832                                                            NULL);
 833                     G729DEC_DPRINT("%d :: OMX_G729Dec_Utils.c ::  Error - insufficient resources\n", __LINE__);
 834                 }
 835 #else
 836                 pComponentPrivate->curState = OMX_StateIdle;
 837                 pComponentPrivate->cbInfo.EventHandler(pHandle,
 838                                                        pHandle->pApplicationPrivate,
 839                                                        OMX_EventCmdComplete,
 840                                                        OMX_CommandStateSet,
 841                                                        pComponentPrivate->curState,
 842                                                        NULL);
 843 #endif
 844
 845 #ifdef __PERF_INSTRUMENTATION__
 846                 PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundarySetup);
 847 #endif
 848                 G729DEC_DPRINT("%d :: G729DEC: State has been Set to Idle\n",
 849                                __LINE__);
 850
 851                 if(pComponentPrivate->dasfmode == 1) {
 852                     OMX_U32 pValues[4];
 853                     G729DEC_DPRINT("%d :: ---- Comp: DASF Functionality is ON ---\n",__LINE__);
 854                     OMX_G729MALLOC_STRUCT(pParams, G729DEC_AudioCodecParams);
 855                     G729DEC_DPRINT("Line %d:::pParams  = 0x%x\n",__LINE__,pParams );
 856                     pComponentPrivate->pParams = pParams;
 857                     /* TODO: Configure from test app */
 858                     pParams->iAudioFormat = 1;
 859                     pParams->iSamplingRate = 8000;
 860
 861                     /*TODO: get this value from the audio manager */
 862                     pParams->iStrmId = pComponentPrivate->streamID;
 863
 864                     pValues[0] = USN_STRMCMD_SETCODECPARAMS;
 865                     pValues[1] = (OMX_U32)pParams;
 866                     pValues[2] = sizeof(G729DEC_AudioCodecParams);
 867                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
 868                                                EMMCodecControlStrmCtrl,(void *)pValues);
 869
 870                     if(eError != OMX_ErrorNone) {
 871                         G729DEC_EPRINT("%d: Error Occurred in Codec StreamControl..\n",__LINE__);
 872                         goto EXIT;
 873                     }
 874                 }
 875             }
 876             else if (pComponentPrivate->curState == OMX_StateExecuting) {
 877                 OMX_S8 *pArgs = (OMX_S8*)"damedesuStr";
 878                 /*Set the bIsStopping bit */
 879                 G729DEC_DPRINT("%d :: G729DEC: About to set bIsStopping bit\n", __LINE__);
 880
 881 #ifdef __PERF_INSTRUMENTATION__
 882                 PERF_Boundary(pComponentPrivate->pPERFcomp,
 883                               PERF_BoundaryComplete | PERF_BoundarySteadyState);
 884 #endif
 885                 G729DEC_DPRINT("About to call LCML_ControlCodec(STOP)\n");
 886                 eError = LCML_ControlCodec(
 887                                            ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
 888                                            MMCodecControlStop,(void *)pArgs);
 889                 if(eError != OMX_ErrorNone) {
 890                     G729DEC_EPRINT("%d: Error Occurred in Codec Stop..\n", __LINE__);
 891                     goto EXIT;
 892                 }
 893
 894 #ifdef HASHINGENABLE
 895                 /*Hashing Change*/
 896                 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLcmlHandle;
 897                 eError = LCML_FlushHashes(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle);
 898                 if (eError != OMX_ErrorNone) {
 899                     G729DEC_EPRINT("Error occurred in Codec mapping flush!\n");
 900                     break;
 901                 }
 902 #endif
 903
 904                 pComponentPrivate->bStopSent=1;
 905                 if (pComponentPrivate->pHoldBuffer) {
 906                     free(pComponentPrivate->pHoldBuffer);
 907                     pComponentPrivate->pHoldBuffer = NULL;
 908                 }
 909                 pComponentPrivate->nHoldLength = 0;
 910             }
 911             else if(pComponentPrivate->curState == OMX_StatePause) {
 912                 G729DEC_DPRINT("%d :: Comp: Stop Command Received\n",__LINE__);
 913
 914 #ifdef HASHINGENABLE
 915                 /*Hashing Change*/
 916                 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLcmlHandle;
 917                 eError = LCML_FlushHashes(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle);
 918                 if (eError != OMX_ErrorNone) {
 919                     G729DEC_EPRINT("Error occurred in Codec mapping flush!\n");
 920                     break;
 921                 }
 922 #endif
 923                 G729DEC_DPRINT("Setting to OMX_StateIdle - Line %d\n",__LINE__);
 924                 pComponentPrivate->curState = OMX_StateIdle;
 925
 926 #ifdef RESOURCE_MANAGER_ENABLED
 927                 rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_G729_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
 928 #endif
 929                 G729DEC_DPRINT ("%d :: The component is stopped\n",__LINE__);
 930                 pComponentPrivate->cbInfo.EventHandler (
 931                                                         pHandle,pHandle->pApplicationPrivate,
 932                                                         OMX_EventCmdComplete,OMX_CommandStateSet,pComponentPrivate->curState,
 933                                                         NULL);
 934             }
 935             else {
 936                 /* This means, it is invalid state from application */
 937                 G729DEC_DPRINT("%d :: Comp: OMX_G729DecUtils.c\n",__LINE__);
 938                 pComponentPrivate->cbInfo.EventHandler(
 939                                                        pHandle,
 940                                                        pHandle->pApplicationPrivate,
 941                                                        OMX_EventError,
 942                                                        OMX_ErrorIncorrectStateTransition,0,
 943                                                        NULL);
 944             }
 945             break;
 946
 947         case OMX_StateExecuting:
 948             G729DEC_DPRINT("%d: G729DECHandleCommand: Cmd Executing \n",__LINE__);
 949
 950             if (pComponentPrivate->curState == OMX_StateIdle) {
 951                 G729DEC_DPRINT("%d :: Comp: OMX_G729DecUtils.c\n",__LINE__);
 952                 /* Sending commands to DSP via LCML_ControlCodec third argument
 953                    is not used for time being */
 954                 pComponentPrivate->nFillBufferDoneCount = 0;
 955                 pComponentPrivate->bStopSent=0;
 956                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
 957                                            EMMCodecControlStart, NULL);
 958                 if(eError != OMX_ErrorNone) {
 959                     G729DEC_EPRINT("%d: Error Occurred in Codec Start..\n",__LINE__);
 960                     goto EXIT;
 961                 }
 962                 /* Send input buffers to application */
 963                 nBuf = pComponentPrivate->pInputBufferList->numBuffers;
 964
 965
 966                 G729DEC_DPRINT ("nBuf =  %d\n",nBuf);
 967                 /* Send output buffers to codec */
 968             }
 969             else if (pComponentPrivate->curState == OMX_StatePause) {
 970                 G729DEC_DPRINT("%d :: Comp: OMX_G729DecUtils.c\n",__LINE__);
 971                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
 972                                            EMMCodecControlStart, (void *)p);
 973                 if (eError != OMX_ErrorNone) {
 974                     G729DEC_EPRINT ("Error While Resuming the codec\n");
 975                     goto EXIT;
 976                 }
 977
 978                 for (i=0; i < pComponentPrivate->nNumInputBufPending; i++) {
 979                     if (pComponentPrivate->pInputBufHdrPending[i]) {
 980                         frameType = *(pComponentPrivate->pInputBufHdrPending[i]->pBuffer);
 981                         G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pComponentPrivate->pInputBufHdrPending[i]->pBuffer, OMX_DirInput, &pLcmlHdr);
 982                         G729DEC_SetPending(pComponentPrivate,pComponentPrivate->pInputBufHdrPending[i],OMX_DirInput);
 983                         eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
 984                                                   EMMCodecInputBuffer,
 985                                                   pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
 986                                                   pComponentPrivate->pInputBufHdrPending[i]->nAllocLen,
 987                                                   pComponentPrivate->pInputBufHdrPending[i]->nFilledLen,
 988                                                   (OMX_U8 *) pLcmlHdr->pIpParam,
 989                                                   sizeof(G729DEC_UAlgBufParamStruct),
 990                                                   NULL);
 991
 992                     }
 993                 }
 994                 pComponentPrivate->nNumInputBufPending = 0;
 995
 996                 for (i=0; i < pComponentPrivate->nNumOutputBufPending; i++) {
 997                     if (pComponentPrivate->pOutputBufHdrPending[i]) {
 998                         G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pComponentPrivate->pOutputBufHdrPending[i]->pBuffer, OMX_DirOutput, &pLcmlHdr);
 999                         G729DEC_SetPending(pComponentPrivate,pComponentPrivate->pOutputBufHdrPending[i],OMX_DirOutput);
1000                         eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1001                                                   EMMCodecOuputBuffer,
1002                                                   pComponentPrivate->pOutputBufHdrPending[i]->pBuffer,
1003                                                   pComponentPrivate->pOutputBufHdrPending[i]->nAllocLen,
1004                                                   pComponentPrivate->pOutputBufHdrPending[i]->nFilledLen,
1005                                                   (OMX_U8 *) pLcmlHdr->pIpParam,
1006                                                   sizeof(G729DEC_UAlgBufParamStruct),
1007                                                   NULL);
1008                     }
1009                 }
1010                 pComponentPrivate->nNumOutputBufPending = 0;
1011
1012             }
1013             else {
1014                 pComponentPrivate->cbInfo.EventHandler (
1015                                                         pHandle,
1016                                                         pHandle->pApplicationPrivate,
1017                                                         OMX_EventError, OMX_ErrorIncorrectStateTransition,0,
1018                                                         NULL);
1019                 G729DEC_EPRINT("%d :: Error: Invalid State Given by Application\n",__LINE__);
1020                 goto EXIT;
1021
1022             }
1023
1024 #ifdef __PERF_INSTRUMENTATION__
1025             PERF_Boundary(pComponentPrivate->pPERFcomp,
1026                           PERF_BoundaryStart | PERF_BoundarySteadyState);
1027 #endif
1028             pComponentPrivate->curState = OMX_StateExecuting;
1029             /*Send state change notificaiton to Application */
1030             pComponentPrivate->cbInfo.EventHandler(
1031                                                    pHandle,
1032                                                    pHandle->pApplicationPrivate,
1033                                                    OMX_EventCmdComplete, OMX_CommandStateSet,pComponentPrivate->curState, NULL);
1034
1035 #ifdef RESOURCE_MANAGER_ENABLED
1036             rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_G729_Decoder_COMPONENT, OMX_StateExecuting, 3456,NULL);
1037 #endif
1038
1039             break;
1040
1041         case OMX_StateLoaded:
1042
1043             G729DEC_DPRINT("%d: G729DECHandleCommand: Cmd Loaded - curState = %d\n",__LINE__,pComponentPrivate->curState);
1044             if (pComponentPrivate->curState == OMX_StateWaitForResources){
1045                 G729DEC_DPRINT("%d: G729DECHandleCommand: Cmd Loaded\n",__LINE__);
1046
1047 #ifdef __PERF_INSTRUMENTATION__
1048                 PERF_Boundary(pComponentPrivate->pPERFcomp,
1049                               PERF_BoundaryStart | PERF_BoundaryCleanup);
1050 #endif
1051
1052                 pComponentPrivate->curState = OMX_StateLoaded;
1053
1054 #ifdef __PERF_INSTRUMENTATION__
1055                 PERF_Boundary(pComponentPrivate->pPERFcomp,
1056                               PERF_BoundaryComplete | PERF_BoundaryCleanup);
1057 #endif
1058
1059                 pComponentPrivate->cbInfo.EventHandler (
1060                                                         pHandle, pHandle->pApplicationPrivate,
1061                                                         OMX_EventCmdComplete, OMX_CommandStateSet,pComponentPrivate->curState,
1062                                                         NULL);
1063                 break;
1064
1065             }
1066
1067             if (pComponentPrivate->curState != OMX_StateIdle &&
1068                 pComponentPrivate->curState != OMX_StateWaitForResources)
1069             {
1070                 pComponentPrivate->cbInfo.EventHandler (pHandle,
1071                                                         pHandle->pApplicationPrivate,
1072                                                         OMX_EventError,
1073                                                         OMX_ErrorIncorrectStateTransition,0,
1074                                                         NULL);
1075                 G729DEC_EPRINT("%d :: Error: Invalid State Given by Application\n",__LINE__);
1076                 goto EXIT;
1077             }
1078
1079 #ifdef __PERF_INSTRUMENTATION__
1080             PERF_Boundary(pComponentPrivate->pPERFcomp,
1081                           PERF_BoundaryStart | PERF_BoundaryCleanup);
1082 #endif
1083
1084             G729DEC_DPRINT("pComponentPrivate->pInputBufferList->numBuffers = %d\n",pComponentPrivate->pInputBufferList->numBuffers);
1085             G729DEC_DPRINT("pComponentPrivate->pOutputBufferList->numBuffers = %d\n",pComponentPrivate->pOutputBufferList->numBuffers);
1086             nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
1087             if (pComponentPrivate->pInputBufferList->numBuffers &&
1088                 pComponentPrivate->pOutputBufferList->numBuffers)
1089             {
1090                 pComponentPrivate->InIdle_goingtoloaded = 1;
1091 #ifndef UNDER_CE
1092
1093                 pthread_mutex_lock(&pComponentPrivate->InIdle_mutex);
1094                 pthread_cond_wait(&pComponentPrivate->InIdle_threshold,
1095                                   &pComponentPrivate->InIdle_mutex);
1096                 pthread_mutex_unlock(&pComponentPrivate->InIdle_mutex);
1097 #else
1098                 OMX_WaitForEvent(&(pComponentPrivate->InIdle_event));
1099 #endif
1100
1101             }
1102
1103             /* Now Deinitialize the component No error should be returned from
1104              * this function. It should clean the system as much as possible */
1105             G729DEC_DPRINT("%d :: In side OMX_StateLoaded State: \n",__LINE__);
1106             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1107                                        EMMCodecControlDestroy, (void *)p);
1108
1109             if (eError != OMX_ErrorNone) {
1110                 G729DEC_EPRINT("%d : Error: in Destroying the codec: no.  %x\n",__LINE__, eError);
1111                 goto EXIT;
1112             }
1113
1114 #ifdef __PERF_INSTRUMENTATION__
1115             PERF_SendingCommand(pComponentPrivate->pPERF, -1, 0,
1116                                 PERF_ModuleComponent);
1117 #endif
1118
1119             eError = EXIT_COMPONENT_THRD;
1120             pComponentPrivate->bInitParamsInitialized = 0;
1121             /* Send StateChangeNotification to application */
1122             pComponentPrivate->bLoadedCommandPending = OMX_FALSE;
1123             break;
1124
1125         case OMX_StatePause:
1126             G729DEC_DPRINT("%d: G729DECHandleCommand: Cmd Pause\n",__LINE__);
1127
1128             if (pComponentPrivate->curState != OMX_StateExecuting &&
1129                 pComponentPrivate->curState != OMX_StateIdle) {
1130                 pComponentPrivate->cbInfo.EventHandler (
1131                                                         pHandle,
1132                                                         pHandle->pApplicationPrivate,
1133                                                         OMX_EventError, OMX_ErrorIncorrectStateTransition,0,
1134                                                         NULL);
1135                 G729DEC_EPRINT("%d :: Error: Invalid State Given by \
1136                        Application\n",__LINE__);
1137                 goto EXIT;
1138             }
1139             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1140                                        EMMCodecControlPause, (void *)p);
1141
1142             if (eError != OMX_ErrorNone) {
1143                 G729DEC_EPRINT("%d : Error: in Pausing the codec\n",__LINE__);
1144                 goto EXIT;
1145             }
1146             break;
1147
1148         case OMX_StateWaitForResources:
1149
1150             if (pComponentPrivate->curState == OMX_StateLoaded) {
1151 #ifdef RESOURCE_MANAGER_ENABLED
1152                 rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_G729_Decoder_COMPONENT, OMX_StateWaitForResources, 3456,NULL);
1153 #endif
1154                 pComponentPrivate->curState = OMX_StateWaitForResources;
1155                 pComponentPrivate->cbInfo.EventHandler(
1156                                                        pHandle, pHandle->pApplicationPrivate,
1157                                                        OMX_EventCmdComplete, OMX_CommandStateSet,pComponentPrivate->curState,NULL);
1158             }
1159             else{
1160                 pComponentPrivate->cbInfo.EventHandler(
1161                                                        pHandle, pHandle->pApplicationPrivate,
1162                                                        OMX_EventError, OMX_ErrorIncorrectStateTransition,0, "NULL");
1163             }
1164             break;
1165
1166
1167         case OMX_StateInvalid:
1168             G729DEC_DPRINT("%d: G729DECHandleCommand: Cmd OMX_StateInvalid:\n",__LINE__);
1169
1170             pComponentPrivate->curState = OMX_StateInvalid;
1171
1172             pComponentPrivate->cbInfo.EventHandler(
1173                                                    pHandle, pHandle->pApplicationPrivate,
1174                                                    OMX_EventError, OMX_ErrorInvalidState,0, NULL);
1175             break;
1176
1177         case OMX_StateMax:
1178             G729DEC_DPRINT("%d: G729DECHandleCommand: Cmd OMX_StateMax::\n",__LINE__);
1179             break;
1180         } /* End of Switch */
1181     }
1182     else if (command == OMX_CommandMarkBuffer) {
1183         G729DEC_DPRINT("command OMX_CommandMarkBuffer received %d\n",__LINE__);
1184         if(!pComponentPrivate->pMarkBuf){
1185             /* TODO Need to handle multiple marks */
1186             pComponentPrivate->pMarkBuf = (OMX_MARKTYPE *)(commandData);
1187         }
1188     }
1189     else if (command == OMX_CommandPortDisable) {
1190         if (!pComponentPrivate->bDisableCommandPending) {
1191
1192             if(commandData == 0x0 || commandData == -1){
1193                 pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bEnabled = OMX_FALSE;
1194             }
1195
1196
1197
1198         }
1199         if(commandData == 0x1 || commandData == -1){
1200             char *pArgs = "damedesuStr";
1201             pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bEnabled = OMX_FALSE;
1202             if (pComponentPrivate->curState == OMX_StateExecuting) {
1203                 pComponentPrivate->bNoIdleOnStop = OMX_TRUE;
1204                 G729DEC_DPRINT("Calling LCML_ControlCodec() Line %d\n",__LINE__);
1205                 eError = LCML_ControlCodec(
1206                                            ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1207                                            MMCodecControlStop,(void *)pArgs);
1208             }
1209         }
1210
1211         if(commandData == 0x0) {
1212             if(!pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bPopulated){
1213                 /* return cmdcomplete event if input unpopulated */
1214                 pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1215                                                        OMX_EventCmdComplete,
1216                                                        OMX_CommandPortDisable,
1217                                                        G729DEC_INPUT_PORT, NULL);
1218
1219                 G729DEC_DPRINT("Clearing bDisableCommandPending Line %d\n",__LINE__);
1220                 pComponentPrivate->bDisableCommandPending = 0;
1221             }
1222             else{
1223                 pComponentPrivate->bDisableCommandPending = 1;
1224                 pComponentPrivate->bDisableCommandParam = commandData;
1225             }
1226         }
1227
1228         if(commandData == 0x1) {
1229             if (!pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bPopulated){
1230                 /* return cmdcomplete event if output unpopulated */
1231                 pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1232                                                        OMX_EventCmdComplete,
1233                                                        OMX_CommandPortDisable,
1234                                                        G729DEC_OUTPUT_PORT, NULL);
1235
1236                 G729DEC_DPRINT("Clearing bDisableCommandPending Line %d\n",__LINE__);
1237                 pComponentPrivate->bDisableCommandPending = 0;
1238             }
1239             else {
1240                 pComponentPrivate->bDisableCommandPending = 1;
1241                 pComponentPrivate->bDisableCommandParam = commandData;
1242             }
1243         }
1244
1245         if(commandData == -1) {
1246             if (!pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bPopulated &&
1247                 !pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bPopulated){
1248
1249                 /* return cmdcomplete event if inout & output unpopulated */
1250                 pComponentPrivate->cbInfo.EventHandler(
1251                                                        pHandle, pHandle->pApplicationPrivate,
1252                                                        OMX_EventCmdComplete, OMX_CommandPortDisable,G729DEC_INPUT_PORT, NULL);
1253
1254                 pComponentPrivate->cbInfo.EventHandler(
1255                                                        pHandle, pHandle->pApplicationPrivate,
1256                                                        OMX_EventCmdComplete, OMX_CommandPortDisable,G729DEC_OUTPUT_PORT, NULL);
1257                 G729DEC_DPRINT("Clearing bDisableCommandPending Line %d\n",__LINE__);
1258                 pComponentPrivate->bDisableCommandPending = 0;
1259             }
1260             else {
1261                 pComponentPrivate->bDisableCommandPending = 1;
1262                 pComponentPrivate->bDisableCommandParam = commandData;
1263             }
1264         }
1265     }
1266     else if (command == OMX_CommandPortEnable) {
1267         if (!pComponentPrivate->bEnableCommandPending) {
1268             if(commandData == 0x0 || commandData == -1){
1269                 /* enable in port */
1270                 G729DEC_DPRINT("setting input port to enabled\n");
1271                 pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bEnabled = OMX_TRUE;
1272                 G729DEC_DPRINT("pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bEnabled = %d\n",pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bEnabled);
1273
1274                 if(pComponentPrivate->AlloBuf_waitingsignal)
1275                 {
1276                     pComponentPrivate->AlloBuf_waitingsignal = 0;
1277                 }
1278             }
1279             if(commandData == 0x1 || commandData == -1){
1280                 /* enable out port */
1281                 G729DEC_DPRINT("setting output port to enabled\n");
1282
1283                 if(pComponentPrivate->AlloBuf_waitingsignal)
1284                 {
1285                     pComponentPrivate->AlloBuf_waitingsignal = 0;
1286 #ifndef UNDER_CE
1287                     pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1288                     pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1289                     pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1290 #else
1291                     OMX_SignalEvent(&(pComponentPrivate->AlloBuf_event));
1292 #endif
1293                 }
1294                 if (pComponentPrivate->curState == OMX_StateExecuting) {
1295                     char *pArgs = "damedesuStr";
1296                     pComponentPrivate->bDspStoppedWhileExecuting = OMX_FALSE;
1297                     eError = LCML_ControlCodec(
1298                                                ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1299                                                EMMCodecControlStart,(void *)pArgs);
1300                 }
1301
1302                 pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bEnabled = OMX_TRUE;
1303                 G729DEC_DPRINT("pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bEnabled = %d\n",
1304                                pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bEnabled);
1305             }
1306         }
1307
1308         if(commandData == 0x0){
1309             if(pComponentPrivate->curState == OMX_StateLoaded ||
1310                pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bPopulated){
1311
1312                 pComponentPrivate->cbInfo.EventHandler( pHandle,
1313                                                         pHandle->pApplicationPrivate,
1314                                                         OMX_EventCmdComplete,
1315                                                         OMX_CommandPortEnable,
1316                                                         G729DEC_INPUT_PORT,
1317                                                         NULL);
1318                 pComponentPrivate->bEnableCommandPending = 0;
1319             }
1320             else {
1321                 pComponentPrivate->bEnableCommandPending = 1;
1322                 pComponentPrivate->bEnableCommandParam = commandData;
1323             }
1324         }
1325         else if(commandData == 0x1){
1326             if(pComponentPrivate->curState == OMX_StateLoaded ||
1327                pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bPopulated){
1328
1329                 pComponentPrivate->cbInfo.EventHandler( pHandle,
1330                                                         pHandle->pApplicationPrivate,
1331                                                         OMX_EventCmdComplete, OMX_CommandPortEnable,
1332                                                         G729DEC_OUTPUT_PORT,
1333                                                         NULL);
1334                 pComponentPrivate->bEnableCommandPending = 0;
1335             }
1336             else {
1337                 pComponentPrivate->bEnableCommandPending = 1;
1338                 pComponentPrivate->bEnableCommandParam = commandData;
1339             }
1340         }
1341         else if(commandData == -1){
1342             if(pComponentPrivate->curState == OMX_StateLoaded ||
1343                (pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->bPopulated
1344                 && pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->bPopulated)){
1345
1346                 pComponentPrivate->cbInfo.EventHandler(
1347                                                        pHandle, pHandle->pApplicationPrivate,
1348                                                        OMX_EventCmdComplete, OMX_CommandPortEnable,G729DEC_INPUT_PORT, NULL);
1349
1350                 pComponentPrivate->cbInfo.EventHandler(
1351                                                        pHandle, pHandle->pApplicationPrivate,
1352                                                        OMX_EventCmdComplete, OMX_CommandPortEnable,G729DEC_OUTPUT_PORT, NULL);
1353
1354                 pComponentPrivate->bEnableCommandPending = 0;
1355                 G729DECFill_LCMLInitParamsEx(pComponentPrivate->pHandle);
1356                 pComponentPrivate->bJustReenabled = 1;
1357             }
1358             else {
1359                 pComponentPrivate->bEnableCommandPending = 1;
1360                 pComponentPrivate->bEnableCommandParam = commandData;
1361             }
1362         }
1363 #ifndef UNDER_CE
1364         pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1365         pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1366         pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1367 #else
1368         OMX_SignalEvent(&(pComponentPrivate->AlloBuf_event));
1369 #endif
1370     }
1371     else if (command == OMX_CommandFlush) {
1372         G729DEC_DPRINT("%d:: OMX_CommandFlush\n", __LINE__);
1373         OMX_U32 aParam[3] = {0};
1374         if(commandData == 0x0 || commandData == -1)
1375         {
1376             if (pComponentPrivate->nUnhandledEmptyThisBuffers == 0) {
1377                 aParam[0] = USN_STRMCMD_FLUSH;
1378                 aParam[1] = 0x0;
1379                 aParam[2] = 0x0;
1380                 G729DEC_DPRINT("Flushing input port\n");
1381                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1382                                            EMMCodecControlStrmCtrl, (void*)aParam);
1383                 if (eError != OMX_ErrorNone)
1384                 {
1385                     G729DEC_EPRINT("Error flushing input port: %d\n", eError);
1386                     goto EXIT;
1387                 }
1388             }
1389             else{
1390                 pComponentPrivate->bFlushInputPortCommandPending = OMX_TRUE;
1391             }
1392         }
1393         if(commandData == 0x1 || commandData == -1)
1394         {
1395             if (pComponentPrivate->nUnhandledFillThisBuffers == 0)  {
1396                 aParam[0] = USN_STRMCMD_FLUSH;
1397                 aParam[1] = 0x1;
1398                 aParam[2] = 0x0;
1399                 G729DEC_DPRINT("Flushing output port\n");
1400                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1401                                            EMMCodecControlStrmCtrl, (void*)aParam);
1402                 if (eError != OMX_ErrorNone)
1403                 {
1404                     G729DEC_DPRINT("Error flushing output port: %d\n", eError);
1405                     goto EXIT;
1406                 }
1407             }
1408             else{
1409                 pComponentPrivate->bFlushOutputPortCommandPending = OMX_TRUE;
1410             }
1411         }
1412     }
1413  EXIT:
1414     G729DEC_DPRINT ("%d :: Exiting G729DECHandleCommand Function\n",__LINE__);
1415     return eError;
1416 }
1417
1418
1419 /* ========================================================================== */
1420 /**
1421  * @G729DECHandleDataBuf_FromApp() This function is called by the component when ever it
1422  * receives the buffer from the application
1423  *
1424  * @param pComponentPrivate  Component private data
1425  * @param pBufHeader Buffer from the application
1426  *
1427  * @pre
1428  *
1429  * @post
1430  *
1431  * @return none
1432  */
1433 /* ========================================================================== */
1434 OMX_ERRORTYPE G729DECHandleDataBuf_FromApp(OMX_BUFFERHEADERTYPE* pBufHeader,
1435                                            G729DEC_COMPONENT_PRIVATE *pComponentPrivate)
1436 {
1437     OMX_ERRORTYPE eError = OMX_ErrorNone;
1438     OMX_DIRTYPE eDir;
1439     LCML_G729DEC_BUFHEADERTYPE *pLcmlHdr = NULL;
1440     LCML_DSP_INTERFACE *pLcmlHandle = (LCML_DSP_INTERFACE *)
1441         pComponentPrivate->pLcmlHandle;
1442     G729DEC_BufParamStruct* pInBufStruct=NULL;
1443     /*  unsigned long int* bufParamsArray = NULL;    */
1444
1445     G729DEC_DPRINT ("%d :: Entering G729DECHandleDataBuf_FromApp Function\n",__LINE__);
1446     /*Find the direction of the received buffer from buffer list */
1447     eError = G729DECGetBufferDirection(pBufHeader, &eDir);
1448     if (eError != OMX_ErrorNone) {
1449         G729DEC_DPRINT ("%d :: The PBufHeader is not found in the list\n",
1450                         __LINE__);
1451         goto EXIT;
1452     }
1453     if (eDir == OMX_DirInput) {
1454         pComponentPrivate->nUnhandledEmptyThisBuffers--;
1455         /*   bufParamsArray = malloc((10 * sizeof(unsigned long int)) + 256);
1456              bufParamsArray += 128;
1457              memset(bufParamsArray, 0, 9 * sizeof(unsigned long int)); */
1458         pInBufStruct = (G729DEC_BufParamStruct*)pBufHeader->pInputPortPrivate;
1459
1460          if (pInBufStruct == NULL) {
1461              G729DEC_EPRINT("%d :: Error: input port NULL ...\n", __LINE__);
1462              goto EXIT;
1463          }
1464         /* fill array for SN params */
1465         if(pInBufStruct->bNoUseDefaults == OMX_TRUE){ /*indicates that khronos conformance tests are NOT running */
1466             pComponentPrivate->bufParamsArray[0] = 0;
1467             pComponentPrivate->bufParamsArray[1] = pInBufStruct->frameLost;
1468             pComponentPrivate->bufParamsArray[2] = pInBufStruct->numPackets;
1469             pComponentPrivate->bufParamsArray[3] = pInBufStruct->packetLength[0];
1470             pComponentPrivate->bufParamsArray[4] = pInBufStruct->packetLength[1];
1471             pComponentPrivate->bufParamsArray[5] = pInBufStruct->packetLength[2];
1472             pComponentPrivate->bufParamsArray[6] = pInBufStruct->packetLength[3];
1473             pComponentPrivate->bufParamsArray[7] = pInBufStruct->packetLength[4];
1474             pComponentPrivate->bufParamsArray[8] = pInBufStruct->packetLength[5];
1475         }
1476         else
1477         {
1478             pComponentPrivate->bufParamsArray[0] = 0; /* last frame flag */
1479             pComponentPrivate->bufParamsArray[1] = 0; /* frame lost flag */
1480             pComponentPrivate->bufParamsArray[2] = 1; /* number of frames in this buffer */
1481             pComponentPrivate->bufParamsArray[3] = 11; /*lengths of each frame in bytes */
1482             pComponentPrivate->bufParamsArray[4] = 0;
1483             pComponentPrivate->bufParamsArray[5] = 0;
1484             pComponentPrivate->bufParamsArray[6] = 0;
1485             pComponentPrivate->bufParamsArray[7] = 0;
1486             pComponentPrivate->bufParamsArray[8] = 0;
1487         }
1488         eError = G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pBufHeader->pBuffer, OMX_DirInput, &pLcmlHdr);
1489         if (eError != OMX_ErrorNone) {
1490             G729DEC_EPRINT("%d :: Error: Invalid Buffer Came ...\n",__LINE__);
1491             goto EXIT;
1492         }
1493         if(pBufHeader->nFlags == OMX_BUFFERFLAG_EOS){ /* Last input buffer from App. */
1494             pBufHeader->nFlags = NORMAL_BUFFER;
1495             pLcmlHdr->pIpParam->usLastFrame = 1;
1496             pComponentPrivate->bufParamsArray[0] = 1;
1497             pComponentPrivate->bIsEOFSent = 1;
1498         }
1499         else{
1500             pLcmlHdr->pIpParam->usLastFrame = 0;
1501             pComponentPrivate->bufParamsArray[0] = 0;
1502         }
1503          pLcmlHdr->pIpParam->usFrameLost = pInBufStruct->frameLost;
1504          if (pInBufStruct->frameLost == 1) {
1505              G729DEC_PRINT_INFO("Frame LOST event\n");
1506         }
1507         /* Store time stamp information */
1508         pComponentPrivate->arrTimestamp[pComponentPrivate->IpBufindex] = pBufHeader->nTimeStamp;
1509         pComponentPrivate->arrTickCount[pComponentPrivate->IpBufindex] = pBufHeader->nTickCount;
1510         pComponentPrivate->IpBufindex++;
1511         pComponentPrivate->IpBufindex %= pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->nBufferCountActual;
1512         if (pComponentPrivate->curState == OMX_StateExecuting) {
1513             if (!G729DEC_IsPending(pComponentPrivate,pBufHeader,OMX_DirInput)) {
1514                 G729DEC_SetPending(pComponentPrivate,pBufHeader,OMX_DirInput);
1515                 eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
1516                                           EMMCodecInputBuffer,
1517                                           (OMX_U8 *)pBufHeader->pBuffer,
1518                                           pBufHeader->nAllocLen,
1519                                           pBufHeader->nFilledLen,
1520                                           (OMX_U8 *) pComponentPrivate->bufParamsArray,
1521                                           sizeof(pComponentPrivate->bufParamsArray),
1522                                           NULL);
1523                 if (eError != OMX_ErrorNone) {
1524                     eError = OMX_ErrorHardware;
1525                     goto EXIT;
1526                 }
1527                 pComponentPrivate->lcml_nCntIp++;
1528                 pComponentPrivate->lcml_nIpBuf++;
1529                 pComponentPrivate->num_Sent_Ip_Buff++;
1530             }
1531         }
1532         else if (pComponentPrivate->curState == OMX_StatePause)  {
1533             pComponentPrivate->pInputBufHdrPending[pComponentPrivate->nNumInputBufPending++] = pBufHeader;
1534         }
1535         if(pBufHeader->pMarkData){
1536             /* copy mark to output buffer header */
1537             pComponentPrivate->pOutputBufferList->pBufHdr[0]->pMarkData = pBufHeader->pMarkData;
1538             pComponentPrivate->pOutputBufferList->pBufHdr[0]->hMarkTargetComponent = pBufHeader->hMarkTargetComponent;
1539
1540             /* trigger event handler if we are supposed to */
1541             if(pBufHeader->hMarkTargetComponent == pComponentPrivate->pHandle && pBufHeader->pMarkData){
1542                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1543                                                        pComponentPrivate->pHandle->pApplicationPrivate,
1544                                                        OMX_EventMark,
1545                                                        0,
1546                                                        0,
1547                                                        pBufHeader->pMarkData);
1548             }
1549         }
1550         if (pComponentPrivate->bFlushInputPortCommandPending) {
1551             OMX_SendCommand(pComponentPrivate->pHandle,OMX_CommandFlush,0,NULL);
1552         }
1553     }
1554
1555     else if (eDir == OMX_DirOutput) {
1556         /* Make sure that output buffer is issued to output stream only when
1557          * there is an outstanding input buffer already issued on input stream
1558          */
1559         pComponentPrivate->nUnhandledFillThisBuffers--;
1560         if (!(pComponentPrivate->bIsStopping)) {
1561             G729DEC_DPRINT ("%d: Sending Empty OUTPUT BUFFER to Codec = %p\n",__LINE__,pBufHeader->pBuffer);
1562             if (pComponentPrivate->curState == OMX_StateExecuting)
1563             {
1564                 if (!G729DEC_IsPending(pComponentPrivate,pBufHeader,OMX_DirOutput)) {
1565                     G729DEC_SetPending(pComponentPrivate,pBufHeader,OMX_DirOutput);
1566                     eError = G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pBufHeader->pBuffer, OMX_DirOutput, &pLcmlHdr);
1567                     if (eError != OMX_ErrorNone) {
1568                         G729DEC_DPRINT("%d :: Error: Invalid Buffer Came ...\n",__LINE__);
1569                         goto EXIT;
1570                     }
1571                     G729DEC_DPRINT("%d\n", __LINE__);
1572                     pLcmlHdr->pIpParam->usLastFrame = 0;
1573                     eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
1574                                               EMMCodecOuputBuffer,
1575                                               (OMX_U8 *)pBufHeader->pBuffer,
1576                                               pBufHeader->nAllocLen,
1577                                               pBufHeader->nAllocLen,
1578                                               (OMX_U8 *) pLcmlHdr->pIpParam,
1579                                               sizeof(G729DEC_UAlgBufParamStruct),
1580                                               NULL);
1581                     if (eError != OMX_ErrorNone ) {
1582                         G729DEC_EPRINT ("%d :: IssuingDSP OP: Error Occurred\n",__LINE__);
1583                         eError = OMX_ErrorHardware;
1584                         goto EXIT;
1585                     }
1586                     G729DEC_DPRINT("%d\n", __LINE__);
1587                     pComponentPrivate->lcml_nOpBuf++;
1588                     pComponentPrivate->num_Op_Issued++;
1589                     G729DEC_DPRINT("%d\n", __LINE__);
1590                 }
1591             }
1592             else if (pComponentPrivate->curState == OMX_StatePause)
1593             {
1594                 pComponentPrivate->pOutputBufHdrPending[pComponentPrivate->nNumOutputBufPending++] = pBufHeader;
1595             }
1596         }
1597         else {
1598             if (pComponentPrivate->curState == OMX_StateExecuting) {
1599                 if (!G729DEC_IsPending(pComponentPrivate,pBufHeader,OMX_DirOutput)) {
1600                     G729DEC_SetPending(pComponentPrivate,pBufHeader,OMX_DirOutput);
1601                     eError = G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pBufHeader->pBuffer, OMX_DirOutput, &pLcmlHdr);
1602                     if (eError != OMX_ErrorNone) {
1603                         G729DEC_EPRINT("%d :: Error: Invalid Buffer Came ...\n",__LINE__);
1604                         goto EXIT;
1605                     }
1606                     pLcmlHdr->pIpParam->usLastFrame = 0;
1607                     eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
1608                                               EMMCodecOuputBuffer,
1609                                               (OMX_U8 *)pBufHeader->pBuffer,
1610                                               pBufHeader->nAllocLen,
1611                                               pBufHeader->nAllocLen,
1612                                               (OMX_U8 *) pLcmlHdr->pIpParam,
1613                                               sizeof(G729DEC_UAlgBufParamStruct),
1614                                               NULL);
1615                     if (eError != OMX_ErrorNone ) {
1616                         G729DEC_EPRINT ("%d :: IssuingDSP OP: Error Occurred\n",__LINE__);
1617                         eError = OMX_ErrorHardware;
1618                         goto EXIT;
1619                     }
1620                     pComponentPrivate->lcml_nOpBuf++;
1621                     pComponentPrivate->num_Op_Issued++;
1622                 }
1623             }
1624             else if (pComponentPrivate->curState == OMX_StatePause){
1625                 pComponentPrivate->pOutputBufHdrPending[pComponentPrivate->nNumOutputBufPending++] = pBufHeader;
1626             }
1627         }
1628         if (pComponentPrivate->bFlushOutputPortCommandPending)
1629         {
1630             OMX_SendCommand( pComponentPrivate->pHandle,
1631                              OMX_CommandFlush,
1632                              1,NULL);
1633         }
1634     }
1635     else {
1636         eError = OMX_ErrorBadParameter;
1637     }
1638
1639  EXIT:
1640
1641     G729DEC_DPRINT("%d : Exiting from  G729DECHandleDataBuf_FromApp \n",__LINE__);
1642     return eError;
1643 }
1644
1645 /*-------------------------------------------------------------------*/
1646 /**
1647  * G729DECGetBufferDirection () This function is used by the component thread to
1648  * request a buffer from the application.  Since it was called from 2 places,
1649  * it made sense to turn this into a small function.
1650  *
1651  * @param pData pointer to G729 Decoder Context Structure
1652  * @param pCur pointer to the buffer to be requested to be filled
1653  *
1654  * @retval none
1655  **/
1656 /*-------------------------------------------------------------------*/
1657
1658 OMX_ERRORTYPE G729DECGetBufferDirection(OMX_BUFFERHEADERTYPE *pBufHeader,
1659                                         OMX_DIRTYPE *eDir)
1660 {
1661     OMX_ERRORTYPE eError = OMX_ErrorNone;
1662     G729DEC_COMPONENT_PRIVATE *pComponentPrivate = pBufHeader->pPlatformPrivate;
1663     OMX_U32 nBuf = 0;
1664     OMX_U32 i = 0;
1665     OMX_BUFFERHEADERTYPE *pBuf = NULL;
1666     OMX_S16 flag = 1;
1667
1668     G729DEC_DPRINT ("%d :: Entering G729DECGetBufferDirection Function\n",__LINE__);
1669
1670     /*Search this buffer in input buffers list */
1671     nBuf = pComponentPrivate->pInputBufferList->numBuffers;
1672     for(i=0; i<nBuf; i++) {
1673         pBuf = pComponentPrivate->pInputBufferList->pBufHdr[i];
1674         if(pBufHeader == pBuf) {
1675             *eDir = OMX_DirInput;
1676             G729DEC_DPRINT ("%d :: Buffer %p is INPUT BUFFER\n",__LINE__, pBufHeader);
1677             flag = 0;
1678             goto EXIT;
1679         }
1680     }
1681
1682     /*Search this buffer in input buffers list */
1683     nBuf = pComponentPrivate->pOutputBufferList->numBuffers;
1684     for(i=0; i<nBuf; i++) {
1685         pBuf = pComponentPrivate->pOutputBufferList->pBufHdr[i];
1686         if(pBufHeader == pBuf) {
1687             *eDir = OMX_DirOutput;
1688             G729DEC_DPRINT ("%d :: Buffer %p is OUTPUT BUFFER\n",__LINE__, pBufHeader);
1689             flag = 0;
1690             goto EXIT;
1691         }
1692     }
1693
1694     if (flag == 1) {
1695         G729DEC_DPRINT ("%d :: Buffer %p is Not Found in the List\n",__LINE__,pBufHeader);
1696         eError = OMX_ErrorUndefined;
1697         goto EXIT;
1698     }
1699  EXIT:
1700     G729DEC_DPRINT ("%d :: Exiting G729DECGetBufferDirection Function\n",__LINE__);
1701     return eError;
1702 }
1703
1704 /* -------------------------------------------------------------------*/
1705 /**
1706  *  Callback() function will be called LCML component to write the msg
1707  *
1708  * @param msgBuffer                 This buffer will be returned by the LCML
1709  *
1710  * @retval OMX_NoError              Success, ready to roll
1711  *         OMX_Error_BadParameter   The input parameter pointer is null
1712  **/
1713 /*-------------------------------------------------------------------*/
1714
1715
1716 OMX_ERRORTYPE G729DECLCML_Callback (TUsnCodecEvent event,void * args [10])
1717 {
1718     OMX_ERRORTYPE eError = OMX_ErrorNone;
1719     OMX_U8 *pBuffer = args[1];
1720     LCML_G729DEC_BUFHEADERTYPE *pLcmlHdr = NULL;
1721     OMX_COMPONENTTYPE *pHandle = NULL;
1722     OMX_S16 i = 0;
1723     G729DEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1724     OMX_ERRORTYPE rm_error = OMX_ErrorNone;
1725
1726
1727     G729DEC_DPRINT ("%d :: Entering the G729DECLCML_Callback Function\n",__LINE__);
1728     pComponentPrivate = pComponentPrivate_CC;
1729     G729DEC_DPRINT("event = %d\n",event);
1730
1731     pHandle =  pComponentPrivate->pHandle;
1732     G729DEC_DPRINT("pHandle = %p\n", pHandle);
1733     G729DEC_DPRINT("pComponentPrivate = %p in lcmlCallback()\n", pComponentPrivate);
1734
1735     switch(event) {
1736
1737     case EMMCodecDspError:
1738         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecDspError\n");
1739         break;
1740
1741     case EMMCodecInternalError:
1742         G729DEC_EPRINT("[LCML CALLBACK EVENT]  EMMCodecInternalError\n");
1743         break;
1744
1745     case EMMCodecInitError:
1746         G729DEC_EPRINT("[LCML CALLBACK EVENT]  EMMCodecInitError\n");
1747         break;
1748
1749     case EMMCodecDspMessageRecieved:
1750         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecDspMessageRecieved\n");
1751         break;
1752
1753     case EMMCodecBufferProcessed:
1754         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecBufferProcessed\n");
1755         break;
1756
1757     case EMMCodecProcessingStarted:
1758         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingStarted\n");
1759         break;
1760
1761     case EMMCodecProcessingPaused:
1762         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingPaused\n");
1763         break;
1764
1765     case EMMCodecProcessingStoped:
1766         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingStoped\n");
1767         break;
1768
1769     case EMMCodecProcessingEof:
1770         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingEof\n");
1771         break;
1772
1773     case EMMCodecBufferNotProcessed:
1774         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecBufferNotProcessed\n");
1775         break;
1776
1777     case EMMCodecAlgCtrlAck:
1778         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecAlgCtrlAck\n");
1779         break;
1780
1781     case EMMCodecStrmCtrlAck:
1782         G729DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecStrmCtrlAck\n");
1783         break;
1784     }
1785
1786     if(event == EMMCodecBufferProcessed)
1787     {
1788         if( (OMX_U32)args [0] == EMMCodecInputBuffer) {
1789
1790             G729DEC_DPRINT("%d :: Input: pBufferr = %p\n",__LINE__, pBuffer);
1791             eError = G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pBuffer, OMX_DirInput, &pLcmlHdr);
1792             if (eError != OMX_ErrorNone) {
1793                 G729DEC_DPRINT("%d :: Error: Invalid Buffer Came ...\n",__LINE__);
1794                 goto EXIT;
1795             }
1796
1797 #ifdef __PERF_INSTRUMENTATION__
1798             PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
1799                                PREF(pLcmlHdr->buffer, pBuffer), 0,
1800                                PERF_ModuleCommonLayer);
1801 #endif
1802
1803             G729DEC_ClearPending(pComponentPrivate,pLcmlHdr->buffer,OMX_DirInput);
1804             pComponentPrivate->cbInfo.EmptyBufferDone (
1805                                                        pComponentPrivate->pHandle,
1806                                                        pComponentPrivate->pHandle->pApplicationPrivate,
1807                                                        pLcmlHdr->buffer);
1808             pComponentPrivate->nEmptyBufferDoneCount++;
1809             pComponentPrivate->lcml_nIpBuf--;
1810             pComponentPrivate->app_nBuf++;
1811         }
1812         else if ((OMX_U32)args [0] == EMMCodecOuputBuffer) {
1813             G729DEC_DPRINT("%d :: Output: pBufferr = %p\n",__LINE__, pBuffer);
1814             eError = G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pBuffer, OMX_DirOutput, &pLcmlHdr);
1815             if (eError != OMX_ErrorNone) {
1816                 G729DEC_DPRINT("%d :: Error: Invalid Buffer Came ...\n",__LINE__);
1817                 goto EXIT;
1818             }
1819             pLcmlHdr->buffer->nFilledLen = (OMX_U32)args[8];
1820
1821 #ifdef __PERF_INSTRUMENTATION__
1822             PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
1823                                PREF(pLcmlHdr->buffer,pBuffer),
1824                                PREF(pLcmlHdr->buffer,nFilledLen),
1825                                PERF_ModuleCommonLayer);
1826             pComponentPrivate->nLcml_nCntOpReceived++;
1827             if ((pComponentPrivate->nLcml_nCntIp >= 1) &&
1828                 (pComponentPrivate->nLcml_nCntOpReceived == 1))
1829             {
1830                 PERF_Boundary(pComponentPrivate->pPERFcomp,
1831                               PERF_BoundaryStart | PERF_BoundarySteadyState);
1832             }
1833 #endif
1834
1835             G729DEC_DPRINT("G729DECLCML_Callback::: pLcmlHdr->buffer->nFilledLen = %d\n",pLcmlHdr->buffer->nFilledLen);
1836             pComponentPrivate->lcml_nCntOpReceived++;
1837
1838             G729DEC_ClearPending(pComponentPrivate,pLcmlHdr->buffer,OMX_DirOutput);
1839             pComponentPrivate->nOutStandingFillDones++;
1840             pComponentPrivate->num_Reclaimed_Op_Buff++;
1841             eError = G729DECGetCorresponding_LCMLHeader(pComponentPrivate, pLcmlHdr->buffer->pBuffer, OMX_DirOutput, &pLcmlHdr);
1842             if(pComponentPrivate->bIsEOFSent){
1843                 pLcmlHdr->buffer->nFlags=OMX_BUFFERFLAG_EOS;
1844                 pComponentPrivate->bIsEOFSent = 0;
1845                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1846                                                        pComponentPrivate->pHandle->pApplicationPrivate,
1847                                                        OMX_EventBufferFlag,
1848                                                        pLcmlHdr->buffer->nOutputPortIndex,
1849                                                        pLcmlHdr->buffer->nFlags, NULL);
1850             }
1851             else{
1852                 pLcmlHdr->buffer->nFlags=NORMAL_BUFFER;
1853             }
1854             /* Copying time stamp information to output buffer */
1855             pLcmlHdr->buffer->nTimeStamp = pComponentPrivate->arrTimestamp[pComponentPrivate->OpBufindex];
1856             pLcmlHdr->buffer->nTickCount = pComponentPrivate->arrTickCount[pComponentPrivate->OpBufindex];
1857             pComponentPrivate->OpBufindex++;
1858             pComponentPrivate->OpBufindex %= pComponentPrivate->pPortDef[G729DEC_DIRECTION_INPUT]->nBufferCountActual;
1859             pComponentPrivate->cbInfo.FillBufferDone (
1860                                                       pComponentPrivate->pHandle,
1861                                                       pComponentPrivate->pHandle->pApplicationPrivate,
1862                                                       pLcmlHdr->buffer
1863                                                       );
1864             pComponentPrivate->lcml_nOpBuf--;
1865             pComponentPrivate->app_nBuf++;
1866             pComponentPrivate->nFillBufferDoneCount++;
1867             pComponentPrivate->nOutStandingFillDones--;
1868         }
1869     }
1870     else if (event == EMMCodecStrmCtrlAck)
1871     {
1872         G729DEC_DPRINT("%d :: GOT MESSAGE USN_DSPACK_STRMCTRL ----\n",__LINE__);
1873         if (args[1] == (void *)USN_STRMCMD_FLUSH)
1874         {
1875             G729DEC_DPRINT("revceived USN_STRMCMD_FLUSH\n");
1876             pHandle = pComponentPrivate->pHandle;
1877             if ( args[2] == (void *)EMMCodecInputBuffer)
1878             {
1879                 if (args[0] == USN_ERR_NONE ) {
1880                     G729DEC_DPRINT("Flushing input port %d\n");
1881                     for (i=0; i < MAX_NUM_OF_BUFS; i++)
1882                     {
1883                         pComponentPrivate->pInputBufHdrPending[i] = NULL;
1884                     }
1885                     pComponentPrivate->nNumInputBufPending=0;
1886                     for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++)
1887                     {
1888                         pComponentPrivate->cbInfo.EmptyBufferDone (
1889                                                                    pComponentPrivate->pHandle,
1890                                                                    pComponentPrivate->pHandle->pApplicationPrivate,
1891                                                                    pComponentPrivate->pInputBufferList->pBufHdr[i]
1892                                                                    );
1893                     }
1894                     pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1895                                                            OMX_EventCmdComplete,
1896                                                            OMX_CommandFlush,
1897                                                            G729DEC_INPUT_PORT,
1898                                                            NULL);
1899                 }
1900                 else
1901                 {
1902                     G729DEC_EPRINT("error flushing input port.\n");
1903                     goto EXIT;
1904                 }
1905             }
1906             else if ( args[2] == (void *)EMMCodecOuputBuffer)
1907             {
1908                 if (args[0] == USN_ERR_NONE )
1909                 {
1910                     G729DEC_DPRINT("Flushing output port %d\n");
1911                     for (i=0; i < MAX_NUM_OF_BUFS; i++)
1912                     {
1913                         pComponentPrivate->pOutputBufHdrPending[i] = NULL;
1914                     }
1915                     pComponentPrivate->nNumOutputBufPending=0;
1916                     for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++)
1917                     {
1918
1919 #ifdef __PERF_INSTRUMENTATION__
1920                         PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1921                                           pComponentPrivate->pOutputBufferList->pBufHdr[i]->pBuffer,
1922                                           pComponentPrivate->pOutputBufferList->pBufHdr[i]->nFilledLen,
1923                                           PERF_ModuleHLMM);
1924 #endif
1925
1926                         pComponentPrivate->cbInfo.FillBufferDone (
1927                                                                   pComponentPrivate->pHandle,
1928                                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1929                                                                   pComponentPrivate->pOutputBufferList->pBufHdr[i]
1930                                                                   );
1931                     }
1932                     pComponentPrivate->cbInfo.EventHandler(
1933                                                            pHandle, pHandle->pApplicationPrivate,
1934                                                            OMX_EventCmdComplete, OMX_CommandFlush,G729DEC_OUTPUT_PORT, NULL);
1935                 }
1936                 else
1937                 {
1938                     G729DEC_EPRINT("error flushing output port.\n");
1939                     goto EXIT;
1940                 }
1941             }
1942         }
1943
1944
1945     }
1946     else if(event == EMMCodecProcessingStoped) {
1947         G729DEC_DPRINT("pComponentPrivate->bNoIdleOnStop = %d\n",pComponentPrivate->bNoIdleOnStop);
1948         if (!pComponentPrivate->bNoIdleOnStop) {
1949             pComponentPrivate->bIdleCommandPending = OMX_TRUE;
1950             G729DEC_TransitionToIdle(pComponentPrivate);
1951         }
1952         else {
1953             pComponentPrivate->bDspStoppedWhileExecuting = OMX_TRUE;
1954             int i;
1955             for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
1956                 G729DEC_DPRINT("pComponentPrivate->pInputBufferList->bBufferPending[%d] = %d\n",i,pComponentPrivate->pInputBufferList->bBufferPending[i]);
1957                 if (pComponentPrivate->pInputBufferList->bBufferPending[i])
1958                 {
1959                     pComponentPrivate->cbInfo.EmptyBufferDone (
1960                                                                pComponentPrivate->pHandle,
1961                                                                pComponentPrivate->pHandle->pApplicationPrivate,
1962                                                                pComponentPrivate->pInputBufferList->pBufHdr[i]
1963                                                                );
1964                     G729DEC_ClearPending(pComponentPrivate, pComponentPrivate->pInputBufferList->pBufHdr[i], OMX_DirInput);
1965                 }
1966             }
1967             pComponentPrivate->bNoIdleOnStop= OMX_FALSE;
1968         }
1969     }
1970     else if (event == EMMCodecProcessingPaused) {
1971         pComponentPrivate->curState = OMX_StatePause;
1972         /* Send StateChangeNotification to application */
1973         pComponentPrivate->cbInfo.EventHandler(
1974                                                pComponentPrivate->pHandle,
1975                                                pComponentPrivate->pHandle->pApplicationPrivate,
1976                                                OMX_EventCmdComplete, OMX_CommandStateSet, pComponentPrivate->curState,NULL);
1977
1978     }
1979
1980     else if (event == EMMCodecDspError) {
1981         if(((int)args[4] == USN_ERR_WARNING) && ((int)args[5] == IUALG_WARN_PLAYCOMPLETED)) {
1982             OMX_COMPONENTTYPE *pHandle = pComponentPrivate->pHandle;
1983             G729DEC_DPRINT("%d :: GOT MESSAGE IUALG_WARN_PLAYCOMPLETED\n",__LINE__);
1984             pComponentPrivate->bPlayCompleteFlag = 1;
1985             pComponentPrivate->curState = OMX_StateIdle;
1986
1987 #ifdef RESOURCE_MANAGER_ENABLED
1988             rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_G729_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
1989 #endif
1990         }
1991         if(((int)args[4] == USN_ERR_WARNING) && ((int)args[5] == IUALG_WARN_OVERFLOW)) {
1992             OMX_COMPONENTTYPE *pHandle = pComponentPrivate->pHandle;
1993             pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1994                                                    OMX_EventError, OMX_ErrorOverflow,
1995                                                    pComponentPrivate->curState, NULL);
1996             G729DEC_DPRINT("%d :: GOT WARNING IUALG_WARN_OVERFLOW\n",__LINE__);
1997         }
1998         if(((int)args[4] == USN_ERR_PROCESS) && ((int)args[5] == IUALG_ERR_DATA_CORRUPT)){
1999             OMX_COMPONENTTYPE *pHandle = pComponentPrivate->pHandle;
2000             pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
2001                                                    OMX_EventError, OMX_ErrorStreamCorrupt,
2002                                                    pComponentPrivate->curState, NULL);
2003             G729DEC_DPRINT("%d :: GOT ERROR IUALG_ERR_DATA_CORRUPT\n",__LINE__);
2004         }
2005     }
2006
2007     if(event == EMMCodecDspMessageRecieved) {
2008         G729DEC_DPRINT("%d :: commandedState  = %d\n",__LINE__,args[0]);
2009         G729DEC_DPRINT("%d :: arg1 = %d\n",__LINE__,args[1]);
2010         G729DEC_DPRINT("%d :: arg2 = %d\n",__LINE__,args[2]);
2011     }
2012
2013  EXIT:
2014     G729DEC_DPRINT ("%d :: Exiting the G729DECLCML_Callback Function\n",__LINE__);
2015     return eError;
2016 }
2017
2018
2019 OMX_ERRORTYPE G729DECGetCorresponding_LCMLHeader(G729DEC_COMPONENT_PRIVATE* pComponentPrivate,
2020                                                  OMX_U8 *pBuffer,
2021                                                  OMX_DIRTYPE eDir,
2022                                                  LCML_G729DEC_BUFHEADERTYPE **ppLcmlHdr)
2023 {
2024     OMX_ERRORTYPE eError = OMX_ErrorNone;
2025     LCML_G729DEC_BUFHEADERTYPE *pLcmlBufHeader = NULL;
2026     OMX_S16 nIpBuf = 0;
2027     OMX_S16 nOpBuf = 0;
2028     OMX_S16 i = 0;
2029
2030     nIpBuf = (OMX_S16)pComponentPrivate->pInputBufferList->numBuffers;
2031     nOpBuf = (OMX_S16)pComponentPrivate->pOutputBufferList->numBuffers;
2032     G729DEC_DPRINT("enter get corresponding LCML header\n");
2033     G729DEC_DPRINT("pComponentPrivate = %p\n",pComponentPrivate);
2034     G729DEC_DPRINT("eDir = %d\n",eDir);
2035     if(eDir == OMX_DirInput) {
2036         G729DEC_DPRINT("pComponentPrivate = %p\n",pComponentPrivate);
2037         pLcmlBufHeader = pComponentPrivate->pLcmlBufHeader[G729DEC_INPUT_PORT];
2038         for(i=0; i<nIpBuf; i++) {
2039             if(pBuffer == pLcmlBufHeader->buffer->pBuffer) {
2040                 *ppLcmlHdr = pLcmlBufHeader;
2041                 G729DEC_DPRINT("%d::Corresponding LCML Header Found\n",__LINE__);
2042                 goto EXIT;
2043             }
2044             pLcmlBufHeader++;
2045         }
2046     }
2047     else if (eDir == OMX_DirOutput) {
2048         pLcmlBufHeader = pComponentPrivate->pLcmlBufHeader[G729DEC_OUTPUT_PORT];
2049         for(i=0; i<nOpBuf; i++) {
2050             if(pBuffer == pLcmlBufHeader->buffer->pBuffer) {
2051                 G729DEC_DPRINT("pBuffer = %p\n",pBuffer);
2052                 G729DEC_DPRINT("pLcmlBufHeader->buffer->pBuffer = %p\n",pLcmlBufHeader->buffer->pBuffer);
2053                 *ppLcmlHdr = pLcmlBufHeader;
2054                 G729DEC_DPRINT("%d::Corresponding LCML Header Found\n",__LINE__);
2055                 goto EXIT;
2056             }
2057             pLcmlBufHeader++;
2058         }
2059     }
2060     else {
2061         G729DEC_DPRINT("%d:: Invalid Buffer Type :: exiting...\n",__LINE__);
2062     }
2063
2064  EXIT:
2065     return eError;
2066 }
2067
2068
2069 #ifndef UNDER_CE
2070
2071 OMX_HANDLETYPE G729DECGetLCMLHandle(G729DEC_COMPONENT_PRIVATE* pComponentPrivate)
2072 {
2073     void *handle = NULL;
2074     OMX_ERRORTYPE (*fpGetHandle)(OMX_HANDLETYPE);
2075     OMX_HANDLETYPE pHandle = NULL;
2076     OMX_S8 *error = NULL;
2077     OMX_ERRORTYPE eError = OMX_ErrorNone;
2078
2079     G729DEC_DPRINT("G729DECGetLCMLHandle %d\n",__LINE__);
2080     handle = dlopen("libLCML.so", RTLD_LAZY);
2081     if (!handle) {
2082         fputs(dlerror(), stderr);
2083         goto EXIT;
2084     }
2085
2086     fpGetHandle = dlsym (handle, "GetHandle");
2087     if ((error = (OMX_S8 *)dlerror()) != NULL) {
2088         fputs((char *)error, stderr);
2089         goto EXIT;
2090     }
2091     eError = (*fpGetHandle)(&pHandle);
2092     if(eError != OMX_ErrorNone) {
2093         eError = OMX_ErrorUndefined;
2094         G729DEC_EPRINT("eError != OMX_ErrorNone...\n");
2095         pHandle = NULL;
2096         goto EXIT;
2097     }
2098
2099     pComponentPrivate->bLcmlHandleOpened = 1;
2100
2101  EXIT:
2102     G729DEC_DPRINT("G729GetLCMLHandle returning %p\n",pHandle);
2103
2104     return pHandle;
2105 }
2106
2107
2108 #else
2109
2110 //WINDOWS Explicit dll load procedure
2111
2112 OMX_HANDLETYPE G729DECGetLCMLHandle(G729DEC_COMPONENT_PRIVATE* pComponentPrivate)
2113 {
2114     typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE);
2115     OMX_HANDLETYPE pHandle = NULL;
2116     OMX_ERRORTYPE eError = OMX_ErrorNone;
2117     LPFNDLLFUNC1 fpGetHandle1;
2118
2119
2120     g_hLcmlDllHandle = LoadLibraryEx(TEXT("OAF_BML.dll"), NULL,0);
2121     if (g_hLcmlDllHandle == NULL)
2122     {
2123         //fputs(dlerror(), stderr);
2124         G729DEC_EPRINT("BML Load Failed!!!\n");
2125         return pHandle;
2126     }
2127
2128     fpGetHandle1 = (LPFNDLLFUNC1)GetProcAddress(g_hLcmlDllHandle,TEXT("GetHandle"));
2129     if (!fpGetHandle1)
2130     {
2131         // handle the error
2132         FreeLibrary(g_hLcmlDllHandle);
2133         g_hLcmlDllHandle = NULL;
2134         return pHandle;
2135     }
2136
2137     // call the function
2138     eError = fpGetHandle1(&pHandle);
2139     if(eError != OMX_ErrorNone) {
2140         eError = OMX_ErrorUndefined;
2141         G729DEC_EPRINT("eError != OMX_ErrorNone...\n");
2142         FreeLibrary(g_hLcmlDllHandle);
2143         g_hLcmlDllHandle = NULL;
2144         pHandle = NULL;
2145         return pHandle;
2146     }
2147     return pHandle;
2148 }
2149
2150
2151 #endif
2152
2153
2154 #ifndef UNDER_CE
2155
2156 OMX_ERRORTYPE G729DECFreeLCMLHandle(G729DEC_COMPONENT_PRIVATE* pComponentPrivate)
2157 {
2158
2159     OMX_S16 retValue = 0;
2160     OMX_ERRORTYPE eError = OMX_ErrorNone;
2161
2162     if (pComponentPrivate->bLcmlHandleOpened) {
2163         retValue = dlclose(pComponentPrivate->pLcmlHandle);
2164
2165         if (retValue != 0) {
2166             eError = OMX_ErrorUndefined;
2167         }
2168         pComponentPrivate->bLcmlHandleOpened = 0;
2169     }
2170
2171     return eError;
2172 }
2173 #else
2174
2175
2176 OMX_ERRORTYPE G729DECFreeLCMLHandle(G729DEC_COMPONENT_PRIVATE* pComponentPrivate)
2177 {
2178
2179     OMX_S16 retValue = 0;
2180     OMX_ERRORTYPE eError = OMX_ErrorNone;
2181
2182     if (pComponentPrivate->bLcmlHandleOpened) {
2183
2184         retValue = FreeLibrary(pComponentPrivate->pLcmlHandle);
2185         if (retValue == 0) {          /* Zero Indicates failure */
2186             eError = OMX_ErrorUndefined;
2187         }
2188         pComponentPrivate->bLcmlHandleOpened = 0;
2189     }
2190
2191     return eError;
2192 }
2193
2194
2195
2196 #endif
2197
2198 void G729DEC_SetPending(G729DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir)
2199 {
2200     OMX_U16 i = 0;
2201
2202     if (eDir == OMX_DirInput) {
2203         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2204             if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2205                 pComponentPrivate->pInputBufferList->bBufferPending[i] = 1;
2206                 G729DEC_DPRINT("*******************INPUT BUFFER %d IS PENDING******************************\n",i);
2207             }
2208         }
2209     }
2210     else {
2211         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2212             if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2213                 pComponentPrivate->pOutputBufferList->bBufferPending[i] = 1;
2214                 G729DEC_DPRINT("*******************OUTPUT BUFFER %d IS PENDING******************************\n",i);
2215             }
2216         }
2217     }
2218 }
2219
2220 void G729DEC_ClearPending(G729DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir)
2221 {
2222     OMX_U16 i = 0;
2223
2224     if (eDir == OMX_DirInput) {
2225         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2226             if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2227                 pComponentPrivate->pInputBufferList->bBufferPending[i] = 0;
2228                 G729DEC_DPRINT("*******************INPUT BUFFER %d IS RECLAIMED******************************\n",i);
2229             }
2230         }
2231     }
2232     else {
2233         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2234             if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2235                 pComponentPrivate->pOutputBufferList->bBufferPending[i] = 0;
2236                 G729DEC_DPRINT("*******************OUTPUT BUFFER %d IS RECLAIMED ******************************\n",i);
2237             }
2238         }
2239     }
2240 }
2241
2242 OMX_U32 G729DEC_IsPending(G729DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir)
2243 {
2244     OMX_U16 i = 0;
2245
2246     if (eDir == OMX_DirInput) {
2247         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2248             if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2249                 return pComponentPrivate->pInputBufferList->bBufferPending[i];
2250             }
2251         }
2252     }
2253     else {
2254         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2255             if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2256                 return pComponentPrivate->pOutputBufferList->bBufferPending[i];
2257             }
2258         }
2259     }
2260     return -1;
2261 }
2262
2263
2264 OMX_U32 G729DEC_IsValid(G729DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U8 *pBuffer, OMX_DIRTYPE eDir)
2265 {
2266     OMX_U16 i = 0;
2267     OMX_S16 found=0;
2268
2269     if (eDir == OMX_DirInput) {
2270         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2271             if (pBuffer == pComponentPrivate->pInputBufferList->pBufHdr[i]->pBuffer) {
2272                 found = 1;
2273             }
2274         }
2275     }
2276     else {
2277         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2278             if (pBuffer == pComponentPrivate->pOutputBufferList->pBufHdr[i]->pBuffer) {
2279                 found = 1;
2280             }
2281         }
2282     }
2283     return found;
2284 }
2285
2286
2287 OMX_ERRORTYPE G729DECFill_LCMLInitParamsEx (OMX_HANDLETYPE  pComponent )
2288 {
2289     OMX_ERRORTYPE eError = OMX_ErrorNone;
2290     OMX_U32 nIpBuf = 0,nIpBufSize = 0,nOpBuf = 0,nOpBufSize = 0;
2291     OMX_U16 i = 0;
2292     OMX_BUFFERHEADERTYPE *pTemp = NULL;
2293     OMX_S16 size_lcml = 0;
2294     LCML_STRMATTR *strmAttr = NULL;
2295     LCML_DSP_INTERFACE *pHandle = (LCML_DSP_INTERFACE *)pComponent;
2296     G729DEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
2297     LCML_G729DEC_BUFHEADERTYPE *pTemp_lcml = NULL;
2298
2299     G729DEC_DPRINT("%d :: G729DECFill_LCMLInitParams\n ",__LINE__);
2300     G729DEC_DPRINT("%d :: pHandle = %p\n",__LINE__,pHandle);
2301     G729DEC_DPRINT("%d :: pHandle->pComponentPrivate = %p\n",__LINE__,pHandle->pComponentPrivate);
2302     pComponentPrivate = pHandle->pComponentPrivate;
2303
2304     nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
2305     nIpBufSize = pComponentPrivate->pPortDef[G729DEC_INPUT_PORT]->nBufferSize;
2306
2307
2308     nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
2309     nOpBufSize = pComponentPrivate->pPortDef[G729DEC_OUTPUT_PORT]->nBufferSize;
2310
2311
2312     size_lcml = (OMX_U16)(nIpBuf * sizeof(LCML_G729DEC_BUFHEADERTYPE));
2313     pTemp_lcml = (LCML_G729DEC_BUFHEADERTYPE *)malloc(size_lcml);
2314     G729DEC_MEMPRINT("%d:[ALLOC] %p\n",__LINE__,pTemp_lcml);
2315     if(pTemp_lcml == NULL) {
2316         G729DEC_EPRINT("%d :: Memory Allocation Failed\n",__LINE__);
2317         /* Free previously allocated memory before bailing */
2318         if (strmAttr) {
2319             free(strmAttr);
2320             strmAttr = NULL;
2321         }
2322         eError = OMX_ErrorInsufficientResources;
2323         goto EXIT;
2324     }
2325     memset(pTemp_lcml, 0x0, size_lcml);
2326     pComponentPrivate->pLcmlBufHeader[G729DEC_INPUT_PORT] = pTemp_lcml;
2327
2328     for (i=0; i<nIpBuf; i++) {
2329         pTemp = pComponentPrivate->pInputBufferList->pBufHdr[i];
2330         pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2331         pTemp->nAllocLen = nIpBufSize;
2332         pTemp->nFilledLen = nIpBufSize;
2333         pTemp->nVersion.s.nVersionMajor = G729DEC_MAJOR_VER;
2334         pTemp->nVersion.s.nVersionMinor = G729DEC_MINOR_VER;
2335         pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
2336         pTemp_lcml->buffer = pTemp;
2337         pTemp_lcml->eDir = OMX_DirInput;
2338
2339         OMX_G729MALLOC_STRUCT(pTemp_lcml->pIpParam, G729DEC_UAlgBufParamStruct);
2340         pTemp_lcml->pIpParam->usFrameLost = 0;
2341         pTemp_lcml->pIpParam->usLastFrame = 0;
2342
2343         /* This means, it is not a last buffer. This flag is to be modified by
2344          * the application to indicate the last buffer */
2345         pTemp->nFlags = NORMAL_BUFFER;
2346
2347         pTemp_lcml++;
2348     }
2349
2350     /* Allocate memory for all output buffer headers..
2351      * This memory pointer will be sent to LCML */
2352     size_lcml = (OMX_U16)(nOpBuf * sizeof(LCML_G729DEC_BUFHEADERTYPE));
2353     pTemp_lcml = (LCML_G729DEC_BUFHEADERTYPE *)malloc(size_lcml);
2354     G729DEC_MEMPRINT("%d:[ALLOC] %p\n",__LINE__,pTemp_lcml);
2355     if(pTemp_lcml == NULL) {
2356         /* Free previously allocated memory before bailing */
2357         if (strmAttr) {
2358             free(strmAttr);
2359             strmAttr = NULL;
2360         }
2361         eError = OMX_ErrorInsufficientResources;
2362         goto EXIT;
2363     }
2364     memset(pTemp_lcml, 0x0, size_lcml);
2365     pComponentPrivate->pLcmlBufHeader[G729DEC_OUTPUT_PORT] = pTemp_lcml;
2366
2367     for (i=0; i<nOpBuf; i++) {
2368         pTemp = pComponentPrivate->pOutputBufferList->pBufHdr[i];
2369         pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2370         pTemp->nAllocLen = nOpBufSize;
2371         pTemp->nFilledLen = nOpBufSize;
2372         pTemp->nVersion.s.nVersionMajor = G729DEC_MAJOR_VER;
2373         pTemp->nVersion.s.nVersionMinor = G729DEC_MINOR_VER;
2374         pComponentPrivate->nVersion = pTemp->nVersion.nVersion;
2375         pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
2376         pTemp->nTickCount = 0;
2377         pTemp->nTimeStamp = 0;
2378         /* This means, it is not a last buffer. This flag is to be modified by
2379          * the application to indicate the last buffer */
2380
2381         pTemp_lcml->buffer = pTemp;
2382         pTemp_lcml->eDir = OMX_DirOutput;
2383         G729DEC_DPRINT("%d:::pTemp_lcml = %p\n",__LINE__,pTemp_lcml);
2384         G729DEC_DPRINT("%d:::pTemp_lcml->buffer = %p\n",__LINE__,pTemp_lcml->buffer);
2385
2386         OMX_G729MALLOC_STRUCT(pTemp_lcml->pIpParam, G729DEC_UAlgBufParamStruct);
2387         pTemp_lcml->pIpParam->usFrameLost = 0;
2388         pTemp_lcml->pIpParam->usLastFrame = 0;
2389
2390         pTemp->nFlags = NORMAL_BUFFER;
2391
2392         pTemp++;
2393         pTemp_lcml++;
2394     }
2395     pComponentPrivate->bPortDefsAllocated = 1;
2396     G729DEC_DPRINT("%d :: Exiting G729DECFill_LCMLInitParams",__LINE__);
2397
2398     pComponentPrivate->bInitParamsInitialized = 1;
2399  EXIT:
2400     return eError;
2401 }
2402 /* ================================================================================= */
2403 /**
2404  * @fn G729DEC_TransitionToIdle() Transition component to OMX_StateIdle
2405  G729DEC_TransitionToIdle().
2406  This method transitions the component to OMX_StateIdle
2407  * @param pComponent  handle for this instance of the component
2408  *
2409  * @pre
2410  *
2411  * @post
2412  *
2413  * @return OMX_ERRORTYPE
2414  */
2415 /* ================================================================================ */
2416 OMX_ERRORTYPE G729DEC_TransitionToIdle(G729DEC_COMPONENT_PRIVATE *pComponentPrivate)
2417 {
2418     OMX_ERRORTYPE eError = OMX_ErrorNone;
2419     OMX_ERRORTYPE rm_error = OMX_ErrorNone;
2420     OMX_U16 i = 0;
2421     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
2422
2423     G729DEC_DPRINT("Entered G729DEC_TransitionToIdle\n");
2424     G729DEC_DPRINT("pComponentPrivate->nOutStandingFillDones = %d\n",pComponentPrivate->nOutStandingFillDones);
2425
2426
2427     if (pComponentPrivate->nOutStandingFillDones <= 0) {
2428
2429         /* If there are any buffers still marked as pending they must have
2430            been queued after the socket node was stopped */
2431         for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2432             if (pComponentPrivate->pInputBufferList->bBufferPending[i])
2433             {
2434
2435 #ifdef __PERF_INSTRUMENTATION__
2436                 PERF_SendingFrame(pComponentPrivate->pPERFcomp,
2437                                   pComponentPrivate->pInputBufferList->pBufHdr[i]->pBuffer,
2438                                   0,
2439                                   PERF_ModuleHLMM);
2440 #endif
2441
2442                 pComponentPrivate->cbInfo.EmptyBufferDone (
2443                                                            pComponentPrivate->pHandle,
2444                                                            pComponentPrivate->pHandle->pApplicationPrivate,
2445                                                            pComponentPrivate->pInputBufferList->pBufHdr[i]
2446                                                            );
2447                 G729DEC_ClearPending(pComponentPrivate, pComponentPrivate->pInputBufferList->pBufHdr[i], OMX_DirInput);
2448             }
2449         }
2450         for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2451             if (pComponentPrivate->pOutputBufferList->bBufferPending[i])
2452             {
2453 #ifdef __PERF_INSTRUMENTATION__
2454                 PERF_SendingFrame(pComponentPrivate->pPERFcomp,
2455                                   pComponentPrivate->pOutputBufferList->pBufHdr[i]->pBuffer,
2456                                   pComponentPrivate->pOutputBufferList->pBufHdr[i]->nFilledLen,
2457                                   PERF_ModuleHLMM);
2458 #endif
2459                 pComponentPrivate->cbInfo.FillBufferDone (
2460                                                           pComponentPrivate->pHandle,
2461                                                           pComponentPrivate->pHandle->pApplicationPrivate,
2462                                                           pComponentPrivate->pOutputBufferList->pBufHdr[i]
2463                                                           );
2464                 pComponentPrivate->nOutStandingFillDones--;
2465                 G729DEC_ClearPending(pComponentPrivate, pComponentPrivate->pOutputBufferList->pBufHdr[i], OMX_DirOutput);
2466             }
2467         }
2468         G729DEC_DPRINT("Setting to OMX_StateIdle - Line %d\n",__LINE__);
2469         pComponentPrivate->curState = OMX_StateIdle;
2470
2471 #ifdef RESOURCE_MANAGER_ENABLED
2472         rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_G729_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
2473 #endif
2474
2475         if (pComponentPrivate->bPreempted == 0)
2476         {
2477             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2478                                                    pComponentPrivate->pHandle->pApplicationPrivate,
2479                                                    OMX_EventCmdComplete,
2480                                                    OMX_CommandStateSet,
2481                                                    pComponentPrivate->curState,
2482                                                    NULL);
2483         }
2484         else
2485         {
2486             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2487                                                    pComponentPrivate->pHandle->pApplicationPrivate,
2488                                                    OMX_EventError,
2489                                                    OMX_ErrorResourcesPreempted,
2490                                                    0,
2491                                                    NULL);
2492
2493         }
2494         pComponentPrivate->bIdleCommandPending = OMX_FALSE;
2495     }
2496     return eError;
2497 }
2498
2499
2500 #ifdef RESOURCE_MANAGER_ENABLED
2501 /***********************************
2502  *  Callback to the RM                                       *
2503  ***********************************/
2504 void G729DEC_ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData)
2505 {
2506     OMX_COMMANDTYPE Cmd = OMX_CommandStateSet;
2507     OMX_STATETYPE state = OMX_StateIdle;
2508     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)cbData.hComponent;
2509     G729DEC_COMPONENT_PRIVATE *pCompPrivate = NULL;
2510
2511     pCompPrivate = (G729DEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
2512
2513     if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesPreempted){
2514         if (pCompPrivate->curState == OMX_StateExecuting ||
2515             pCompPrivate->curState == OMX_StatePause) {
2516
2517             write (pCompPrivate->cmdPipe[1], &Cmd, sizeof(Cmd));
2518             write (pCompPrivate->cmdDataPipe[1], &state ,sizeof(OMX_U32));
2519
2520             pCompPrivate->bPreempted = 1;
2521         }
2522     }
2523     else if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesAcquired){
2524         pCompPrivate->cbInfo.EventHandler ( pHandle,
2525                                             pHandle->pApplicationPrivate,
2526                                             OMX_EventResourcesAcquired,
2527                                             0, 0, NULL);
2528     }
2529 }
2530 #endif