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