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