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
100HINSTANCE g_hLcmlDllHandle = NULL;
101
102#endif
103
104static 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
122OMX_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
374OMX_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
454OMX_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
539OMX_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
613OMX_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
656OMX_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/* ========================================================================== */
1434OMX_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
1658OMX_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
1716OMX_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
2019OMX_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
2071OMX_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
2112OMX_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
2156OMX_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
2176OMX_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
2198void 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
2220void 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
2242OMX_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
2264OMX_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
2287OMX_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/* ================================================================================ */
2416OMX_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 ***********************************/
2504void 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
2531