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