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 /* ==============================================================================
23 * Texas Instruments OMAP (TM) Platform Software
24 * (c) Copyright Texas Instruments, Incorporated. All Rights Reserved.
25 *
26 * Use of this software is controlled by the terms and conditions found
27 * in the license agreement under which this software has been supplied.
28 * ============================================================================ */
29 /**
30 * @file OMX_WmaDecoder.c
31 *
32 * This file implements OMX Component for WMA decoder that
33 * is fully compliant with the OMX Audio specification 1.5.
34 *
35 * @path $(CSLPATH)\
36 *
37 * @rev 0.1
38 */
39 /* ----------------------------------------------------------------------------
40 *!
41 *! Revision History
42 *! ===================================
43 *! 12-Sept-2005 mf: Initial Version. Change required per OMAPSWxxxxxxxxx
44 *! to provide _________________.
45 *!
46 * ============================================================================= */
47
48
49 /* ------compilation control switches -------------------------*/
50 /****************************************************************
51 * INCLUDE FILES
52 ****************************************************************/
53 /* ----- system and platform files ----------------------------*/
54 #ifdef UNDER_CE
55 #include <windows.h>
56 #include <oaf_osal.h>
57 #include <omx_core.h>
58 #else
59 #include <unistd.h>
60 #include <sys/time.h>
61 #include <sys/types.h>
62 #include <sys/ioctl.h>
63 #include <sys/select.h>
64 #include <errno.h>
65 #include <pthread.h>
66 #endif
67 #include <string.h>
68 #include <fcntl.h>
69 #include <stdlib.h>
70 #include <stdio.h>
71 #include <dbapi.h>
72
73 /*-------program files ----------------------------------------*/
74 #include "OMX_WmaDec_Utils.h"
75 /* interface with audio manager */
76 #define FIFO1 "/dev/fifo.1"
77 #define FIFO2 "/dev/fifo.2"
78
79 #ifdef DSP_RENDERING_ON
80 AM_COMMANDDATATYPE cmd_data;
81 int fdwrite, fdread;
82 int errno;
83 OMX_U32 streamID;
84 #endif
85 #define WMA_DEC_ROLE "audio_decoder.wma"
86
87 /****************************************************************
88 * EXTERNAL REFERENCES NOTE : only use if not found in header file
89 ****************************************************************/
90 /*--------data declarations -----------------------------------*/
91
92 /*--------function prototypes ---------------------------------*/
93
94 /****************************************************************
95 * PUBLIC DECLARATIONS Defined here, used elsewhere
96 ****************************************************************/
97 /*--------data declarations -----------------------------------*/
98
99 /*--------function prototypes ---------------------------------*/
100
101 /****************************************************************
102 * PRIVATE DECLARATIONS Defined here, used only here
103 ****************************************************************/
104 /*--------data declarations -----------------------------------*/
105
106 /*--------function prototypes ---------------------------------*/
107
108 static OMX_ERRORTYPE SetCallbacks (OMX_HANDLETYPE hComp,
109 OMX_CALLBACKTYPE* pCallBacks, OMX_PTR pAppData);
110 static OMX_ERRORTYPE GetComponentVersion (OMX_HANDLETYPE hComp,
111 OMX_STRING pComponentName,
112 OMX_VERSIONTYPE* pComponentVersion,
113 OMX_VERSIONTYPE* pSpecVersion,
114 OMX_UUIDTYPE* pComponentUUID);
115
116 static OMX_ERRORTYPE SendCommand (OMX_HANDLETYPE hComp, OMX_COMMANDTYPE nCommand,
117 OMX_U32 nParam, OMX_PTR pCmdData);
118
119 static OMX_ERRORTYPE GetParameter(OMX_HANDLETYPE hComp, OMX_INDEXTYPE nParamIndex,
120 OMX_PTR ComponentParamStruct);
121 static OMX_ERRORTYPE SetParameter (OMX_HANDLETYPE hComp,
122 OMX_INDEXTYPE nParamIndex,
123 OMX_PTR ComponentParamStruct);
124 static OMX_ERRORTYPE GetConfig (OMX_HANDLETYPE hComp,
125 OMX_INDEXTYPE nConfigIndex,
126 OMX_PTR pComponentConfigStructure);
127 static OMX_ERRORTYPE SetConfig (OMX_HANDLETYPE hComp,
128 OMX_INDEXTYPE nConfigIndex,
129 OMX_PTR pComponentConfigStructure);
130
131 static OMX_ERRORTYPE EmptyThisBuffer (OMX_HANDLETYPE hComp, OMX_BUFFERHEADERTYPE* pBuffer);
132 static OMX_ERRORTYPE FillThisBuffer (OMX_HANDLETYPE hComp, OMX_BUFFERHEADERTYPE* pBuffer);
133
134 static OMX_ERRORTYPE GetState (OMX_HANDLETYPE hComp, OMX_STATETYPE* pState);
135 static OMX_ERRORTYPE ComponentTunnelRequest (OMX_HANDLETYPE hComp,
136 OMX_U32 nPort, OMX_HANDLETYPE hTunneledComp,
137 OMX_U32 nTunneledPort,
138 OMX_TUNNELSETUPTYPE* pTunnelSetup);
139
140 static OMX_ERRORTYPE ComponentDeInit(OMX_HANDLETYPE pHandle);
141 static OMX_ERRORTYPE AllocateBuffer (OMX_IN OMX_HANDLETYPE hComponent,
142 OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
143 OMX_IN OMX_U32 nPortIndex,
144 OMX_IN OMX_PTR pAppPrivate,
145 OMX_IN OMX_U32 nSizeBytes);
146
147 static OMX_ERRORTYPE FreeBuffer(
148 OMX_IN OMX_HANDLETYPE hComponent,
149 OMX_IN OMX_U32 nPortIndex,
150 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
151
152 static OMX_ERRORTYPE UseBuffer (
153 OMX_IN OMX_HANDLETYPE hComponent,
154 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
155 OMX_IN OMX_U32 nPortIndex,
156 OMX_IN OMX_PTR pAppPrivate,
157 OMX_IN OMX_U32 nSizeBytes,
158 OMX_IN OMX_U8* pBuffer);
159
160 static OMX_ERRORTYPE GetExtensionIndex(
161 OMX_IN OMX_HANDLETYPE hComponent,
162 OMX_IN OMX_STRING cParameterName,
163 OMX_OUT OMX_INDEXTYPE* pIndexType);
164
165 static OMX_ERRORTYPE ComponentRoleEnum(
166 OMX_IN OMX_HANDLETYPE hComponent,
167 OMX_OUT OMX_U8 *cRole,
168 OMX_IN OMX_U32 nIndex);
169
170 /*-------------------------------------------------------------------*/
171 /**
172 * OMX_ComponentInit() Set the all the function pointers of component
173 *
174 * This method will update the component function pointer to the handle
175 *
176 * @param hComp handle for this instance of the component
177 *
178 * @retval OMX_NoError Success, ready to roll
179 * OMX_ErrorInsufficientResources If the malloc fails
180 **/
181 /*-------------------------------------------------------------------*/
OMX_ComponentInit(OMX_HANDLETYPE hComp)182 OMX_ERRORTYPE OMX_ComponentInit (OMX_HANDLETYPE hComp)
183 {
184
185 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef_ip = NULL, *pPortDef_op = NULL;
186 WMADEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
187 OMX_AUDIO_PARAM_WMATYPE *wma_ip = NULL;
188 OMX_AUDIO_PARAM_PCMMODETYPE *wma_op = NULL;
189 RCA_HEADER *rcaheader=NULL;
190
191 OMX_ERRORTYPE eError = OMX_ErrorNone;
192 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE*) hComp;
193 int i;
194
195 OMXDBG_PRINT(stderr, PRINT, 1, 0, "%d ::OMX_ComponentInit\n", __LINE__);
196
197 /*Set the all component function pointer to the handle */
198 pHandle->SetCallbacks = SetCallbacks;
199 pHandle->GetComponentVersion = GetComponentVersion;
200 pHandle->SendCommand = SendCommand;
201 pHandle->GetParameter = GetParameter;
202 pHandle->SetParameter = SetParameter;
203 pHandle->GetConfig = GetConfig;
204 pHandle->GetState = GetState;
205 pHandle->EmptyThisBuffer = EmptyThisBuffer;
206 pHandle->FillThisBuffer = FillThisBuffer;
207 pHandle->ComponentTunnelRequest = ComponentTunnelRequest;
208 pHandle->ComponentDeInit = ComponentDeInit;
209 pHandle->AllocateBuffer = AllocateBuffer;
210 pHandle->FreeBuffer = FreeBuffer;
211 pHandle->UseBuffer = UseBuffer;
212 pHandle->SetConfig = SetConfig;
213 pHandle->GetExtensionIndex = GetExtensionIndex;
214 pHandle->ComponentRoleEnum = ComponentRoleEnum;
215
216
217
218 /*Allocate the memory for Component private data area */
219 OMX_MALLOC_GENERIC(pHandle->pComponentPrivate, WMADEC_COMPONENT_PRIVATE);
220 ((WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pHandle = pHandle;
221
222 /* Initialize component data structures to default values */
223 ((WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->sPortParam.nPorts = 0x2;
224 ((WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->sPortParam.nStartPortNumber = 0x0;
225
226 eError = OMX_ErrorNone;
227
228 OMX_MALLOC_GENERIC(wma_ip, OMX_AUDIO_PARAM_WMATYPE);
229 OMX_MALLOC_GENERIC(wma_op, OMX_AUDIO_PARAM_PCMMODETYPE);
230 OMX_MALLOC_GENERIC(rcaheader, RCA_HEADER);
231
232 ((WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->wma_op=wma_op;
233 ((WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->rcaheader=rcaheader;
234
235 ((WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->wmaParams[INPUT_PORT] = wma_ip;
236 ((WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->wmaParams[OUTPUT_PORT] = (OMX_AUDIO_PARAM_WMATYPE*)wma_op;
237
238
239 pComponentPrivate = pHandle->pComponentPrivate;
240 OMX_MALLOC_GENERIC(pComponentPrivate->pInputBufferList, BUFFERLIST);
241 OMX_DBG_INIT(pComponentPrivate->dbg, "OMX_DBG_WMADEC");
242
243 #ifdef __PERF_INSTRUMENTATION__
244 OMX_PRDSP1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n", __LINE__);
245 pComponentPrivate->pPERF = PERF_Create(PERF_FOURCC('W','M','A','_'),
246 PERF_ModuleLLMM |
247 PERF_ModuleAudioDecode);
248 #endif
249
250 #ifdef ANDROID
251 pComponentPrivate->iPVCapabilityFlags.iIsOMXComponentMultiThreaded = OMX_TRUE;
252 pComponentPrivate->iPVCapabilityFlags.iOMXComponentNeedsNALStartCode = OMX_FALSE;
253 pComponentPrivate->iPVCapabilityFlags.iOMXComponentSupportsExternalOutputBufferAlloc = OMX_FALSE;
254 pComponentPrivate->iPVCapabilityFlags.iOMXComponentSupportsExternalInputBufferAlloc = OMX_FALSE;
255 pComponentPrivate->iPVCapabilityFlags.iOMXComponentSupportsMovableInputBuffers = OMX_FALSE;
256 pComponentPrivate->iPVCapabilityFlags.iOMXComponentSupportsPartialFrames = OMX_FALSE;
257 pComponentPrivate->iPVCapabilityFlags.iOMXComponentCanHandleIncompleteFrames = OMX_FALSE;
258 #endif
259
260 pComponentPrivate->pInputBufferList->numBuffers = 0; /* initialize number of buffers */
261 pComponentPrivate->bDspStoppedWhileExecuting = OMX_FALSE;
262 OMX_MALLOC_GENERIC(pComponentPrivate->pOutputBufferList, BUFFERLIST);
263
264 pComponentPrivate->pOutputBufferList->numBuffers = 0; /* initialize number of buffers */
265 OMX_MALLOC_GENERIC(pComponentPrivate->pHeaderInfo, WMA_HeadInfo);
266 OMX_MALLOC_GENERIC(pComponentPrivate->pDspDefinition, TI_OMX_DSP_DEFINITION);
267
268 /* Temporarily treat these as default values for Khronos tests */
269 pComponentPrivate->pHeaderInfo->iPackets.dwLo = 178 ;
270 pComponentPrivate->pHeaderInfo->iPlayDuration.dwHi = 0 ;
271 pComponentPrivate->pHeaderInfo->iPlayDuration.dwLo = 917760000 ;
272 pComponentPrivate->pHeaderInfo->iMaxPacketSize = 349 ;
273 pComponentPrivate->pHeaderInfo->iStreamType.Data1 = -127295936 ;
274 pComponentPrivate->pHeaderInfo->iStreamType.Data2 = 23373 ;
275 pComponentPrivate->pHeaderInfo->iStreamType.Data3 = 4559 ;
276 pComponentPrivate->pHeaderInfo->iStreamType.Data4[0] = 168 ;
277 pComponentPrivate->pHeaderInfo->iStreamType.Data4[1] = 253 ;
278 pComponentPrivate->pHeaderInfo->iStreamType.Data4[2] = 0 ;
279 pComponentPrivate->pHeaderInfo->iStreamType.Data4[3] = 128 ;
280 pComponentPrivate->pHeaderInfo->iStreamType.Data4[4] = 95 ;
281 pComponentPrivate->pHeaderInfo->iStreamType.Data4[5] = 92 ;
282 pComponentPrivate->pHeaderInfo->iStreamType.Data4[6] = 68 ;
283 pComponentPrivate->pHeaderInfo->iStreamType.Data4[7] = 43 ;
284 pComponentPrivate->pHeaderInfo->iTypeSpecific = 28 ;
285 pComponentPrivate->pHeaderInfo->iStreamNum = 1 ;
286 pComponentPrivate->pHeaderInfo->iFormatTag = 353 ;
287 pComponentPrivate->pHeaderInfo->iBlockAlign = 40 ;
288 pComponentPrivate->pHeaderInfo->iSamplePerSec = 8000;
289 pComponentPrivate->pHeaderInfo->iAvgBytesPerSec = 625 ;
290 pComponentPrivate->pHeaderInfo->iChannel = 1 ;
291 pComponentPrivate->pHeaderInfo->iValidBitsPerSample = 16 ;
292 pComponentPrivate->pHeaderInfo->iSizeWaveHeader = 10 ;
293 pComponentPrivate->pHeaderInfo->iEncodeOptV = 0 ;
294 pComponentPrivate->pHeaderInfo->iValidBitsPerSample = 16 ;
295 pComponentPrivate->pHeaderInfo->iChannelMask = 0 ;
296 pComponentPrivate->pHeaderInfo->iSamplePerBlock = 8704;
297
298
299 pComponentPrivate->bConfigData = 0; /* assume the first buffer received will contain only config data, need to use bufferFlag instead */
300 pComponentPrivate->reconfigInputPort = 0;
301 pComponentPrivate->reconfigOutputPort = 0;
302
303 for (i=0; i < MAX_NUM_OF_BUFS; i++) {
304 pComponentPrivate->pOutputBufferList->pBufHdr[i] = NULL;
305 pComponentPrivate->pInputBufferList->pBufHdr[i] = NULL;
306 }
307 pComponentPrivate->dasfmode = 0;
308 pComponentPrivate->bPortDefsAllocated = 0;
309 pComponentPrivate->bCompThreadStarted = 0;
310 pComponentPrivate->bInitParamsInitialized = 0;
311 pComponentPrivate->pMarkBuf = NULL;
312 pComponentPrivate->pMarkData = NULL;
313 pComponentPrivate->nEmptyBufferDoneCount = 0;
314 pComponentPrivate->nEmptyThisBufferCount = 0;
315 pComponentPrivate->strmAttr = NULL;
316 pComponentPrivate->bDisableCommandParam = 0;
317 pComponentPrivate->bEnableCommandParam = 0;
318
319 pComponentPrivate->nUnhandledFillThisBuffers=0;
320 pComponentPrivate->nUnhandledEmptyThisBuffers = 0;
321 pComponentPrivate->SendAfterEOS = 0;
322
323 pComponentPrivate->bFlushOutputPortCommandPending = OMX_FALSE;
324 pComponentPrivate->bFlushInputPortCommandPending = OMX_FALSE;
325
326
327
328 for (i=0; i < MAX_NUM_OF_BUFS; i++) {
329 pComponentPrivate->pInputBufHdrPending[i] = NULL;
330 pComponentPrivate->pOutputBufHdrPending[i] = NULL;
331 }
332 pComponentPrivate->nInvalidFrameCount = 0;
333 pComponentPrivate->nNumInputBufPending = 0;
334 pComponentPrivate->nNumOutputBufPending = 0;
335 pComponentPrivate->bDisableCommandPending = 0;
336 pComponentPrivate->bEnableCommandPending = 0;
337 pComponentPrivate->bBypassDSP = OMX_FALSE;
338 pComponentPrivate->bNoIdleOnStop= OMX_FALSE;
339 pComponentPrivate->bIdleCommandPending = OMX_FALSE;
340 pComponentPrivate->nOutStandingFillDones = 0;
341
342 pComponentPrivate->sInPortFormat.eEncoding = OMX_AUDIO_CodingWMA;
343 pComponentPrivate->sInPortFormat.nIndex = 0;
344 pComponentPrivate->sInPortFormat.nPortIndex = INPUT_PORT;
345 pComponentPrivate->bPreempted = OMX_FALSE;
346
347 pComponentPrivate->sOutPortFormat.eEncoding = OMX_AUDIO_CodingPCM; /*chrisk*/
348 pComponentPrivate->sOutPortFormat.nIndex = 1;
349 pComponentPrivate->sOutPortFormat.nPortIndex = OUTPUT_PORT;
350
351 OMX_MALLOC_SIZE(pComponentPrivate->sDeviceString, 100*sizeof(OMX_STRING), OMX_STRING);
352
353
354 /* PCM format defaults */
355 wma_op->nPortIndex = 1;
356 wma_op->nChannels = 2;
357 wma_op->eNumData= OMX_NumericalDataSigned;
358 wma_op->nBitPerSample = 16;
359 wma_op->nSamplingRate = 44100;
360 wma_op->ePCMMode = OMX_AUDIO_PCMModeLinear;
361
362
363 /* WMA format defaults */
364 wma_ip->nPortIndex = 0;
365 wma_ip->nChannels = 2;
366 wma_ip->nBitRate = 32000;
367 wma_ip->nSamplingRate = 44100;
368
369 /* initialize role name */
370 strcpy((char *) pComponentPrivate->componentRole.cRole, WMA_DEC_ROLE);
371 /* Initialize device string to the default value */
372 strcpy((char*)pComponentPrivate->sDeviceString,"/eteedn:i0:o0/codec\0");
373
374 /* Removing sleep() calls. Initialization.*/
375 #ifndef UNDER_CE
376 pthread_mutex_init(&pComponentPrivate->AlloBuf_mutex, NULL);
377 pthread_cond_init (&pComponentPrivate->AlloBuf_threshold, NULL);
378 pComponentPrivate->AlloBuf_waitingsignal = 0;
379
380 pthread_mutex_init(&pComponentPrivate->InLoaded_mutex, NULL);
381 pthread_cond_init (&pComponentPrivate->InLoaded_threshold, NULL);
382 pComponentPrivate->InLoaded_readytoidle = 0;
383
384 pthread_mutex_init(&pComponentPrivate->InIdle_mutex, NULL);
385 pthread_cond_init (&pComponentPrivate->InIdle_threshold, NULL);
386 pComponentPrivate->InIdle_goingtoloaded = 0;
387
388 pthread_mutex_init(&pComponentPrivate->codecStop_mutex, NULL);
389 pthread_cond_init (&pComponentPrivate->codecStop_threshold, NULL);
390 pComponentPrivate->codecStop_waitingsignal = 0;
391
392 pthread_mutex_init(&pComponentPrivate->codecFlush_mutex, NULL);
393 pthread_cond_init (&pComponentPrivate->codecFlush_threshold, NULL);
394 pComponentPrivate->codecFlush_waitingsignal = 0;
395 #else
396 OMX_CreateEvent(&(pComponentPrivate->AlloBuf_event));
397 pComponentPrivate->AlloBuf_waitingsignal = 0;
398
399 OMX_CreateEvent(&(pComponentPrivate->InLoaded_event));
400 pComponentPrivate->InLoaded_readytoidle = 0;
401
402 OMX_CreateEvent(&(pComponentPrivate->InIdle_event));
403 pComponentPrivate->InIdle_goingtoloaded = 0;
404 #endif
405 /* Removing sleep() calls. Initialization.*/
406
407 OMX_MALLOC_GENERIC(pPortDef_ip, OMX_PARAM_PORTDEFINITIONTYPE);
408 OMX_MALLOC_GENERIC(pPortDef_op,OMX_PARAM_PORTDEFINITIONTYPE );
409
410 OMX_PRCOMM2(pComponentPrivate->dbg, "%d ::pPortDef_ip = %p\n", __LINE__,pPortDef_ip);
411 OMX_PRCOMM2(pComponentPrivate->dbg, "%d ::pPortDef_op = %p\n", __LINE__,pPortDef_op);
412
413 ((WMADEC_COMPONENT_PRIVATE*) pHandle->pComponentPrivate)->pPortDef[INPUT_PORT]
414 = pPortDef_ip;
415
416 ((WMADEC_COMPONENT_PRIVATE*) pHandle->pComponentPrivate)->pPortDef[OUTPUT_PORT]
417 = pPortDef_op;
418
419 pPortDef_ip->nPortIndex = 0x0;
420 pPortDef_ip->nBufferCountActual = NUM_WMADEC_INPUT_BUFFERS;
421 pPortDef_ip->nBufferCountMin = NUM_WMADEC_INPUT_BUFFERS;
422 pPortDef_ip->eDir = OMX_DirInput;
423 pPortDef_ip->bEnabled = OMX_TRUE;
424 pPortDef_ip->nBufferAlignment = DSP_CACHE_ALIGNMENT;
425 pPortDef_ip->nBufferSize = INPUT_WMADEC_BUFFER_SIZE;
426 pPortDef_ip->bPopulated = 0;
427 pPortDef_ip->eDomain = OMX_PortDomainAudio;
428 pPortDef_ip->format.audio.eEncoding = OMX_AUDIO_CodingWMA;
429
430 pPortDef_op->nPortIndex = 0x1;
431 pPortDef_op->nBufferCountActual = NUM_WMADEC_OUTPUT_BUFFERS;
432 pPortDef_op->nBufferCountMin = NUM_WMADEC_OUTPUT_BUFFERS;
433 pPortDef_op->nBufferAlignment = DSP_CACHE_ALIGNMENT;
434 pPortDef_op->eDir = OMX_DirOutput;
435 pPortDef_op->bEnabled = OMX_TRUE;
436 if(pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferSize == 0)
437 {
438 pPortDef_op->nBufferSize = OUTPUT_WMADEC_BUFFER_SIZE;
439 }
440 else
441 {
442 pPortDef_op->nBufferSize = pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferSize;
443 }
444 pPortDef_op->bPopulated = 0;
445 pPortDef_op->eDomain = OMX_PortDomainAudio;
446 pComponentPrivate->bIsInvalidState = OMX_FALSE;
447 /* sPortFormat->eEncoding = OMX_AUDIO_CodingPCM; */ /*chrisk*/
448 pPortDef_op->format.audio.eEncoding = OMX_AUDIO_CodingPCM; /*chrisk*/
449
450 #ifdef RESOURCE_MANAGER_ENABLED
451 OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: Initialize RM Proxy... \n", __LINE__);
452 eError = RMProxy_NewInitalize();
453 OMX_PRINT2(pComponentPrivate->dbg, "%d ::OMX_ComponentInit\n", __LINE__);
454 if (eError != OMX_ErrorNone) {
455 OMX_ERROR4(pComponentPrivate->dbg, "%d ::Error returned from loading ResourceManagerProxy thread\n",
456 __LINE__);
457 goto EXIT;
458 }
459 #endif
460 OMX_PRINT1(pComponentPrivate->dbg, "%d ::Start Component Thread \n", __LINE__);
461 eError = WMADEC_StartComponentThread(pHandle);
462 /*OMX_PRINT1(pComponentPrivate->dbg, "%d ::OMX_ComponentInit\n", __LINE__);*/
463 if (eError != OMX_ErrorNone) {
464 OMX_ERROR4(pComponentPrivate->dbg, "%d ::Error returned from the Component\n",
465 __LINE__);
466 goto EXIT;
467 }
468 OMX_PRINT1(pComponentPrivate->dbg, "%d ::OMX_ComponentInit\n", __LINE__);
469
470
471
472
473 #ifdef DSP_RENDERING_ON
474 OMX_PRINT1(pComponentPrivate->dbg, "%d ::OMX_ComponentInit\n", __LINE__);
475 if((fdwrite=open(FIFO1,O_WRONLY))<0) {
476 OMX_TRACE4(pComponentPrivate->dbg, "[WMA Dec Component] - failure to open WRITE pipe\n");
477 eError = OMX_ErrorHardware;
478 }
479
480 OMX_PRINT1(pComponentPrivate->dbg, "%d ::OMX_ComponentInit\n", __LINE__);
481 if((fdread=open(FIFO2,O_RDONLY))<0) {
482 OMX_TRACE4(pComponentPrivate->dbg, "[WMA Dec Component] - failure to open READ pipe\n");
483 eError = OMX_ErrorHardware;
484 }
485 OMX_PRINT1(pComponentPrivate->dbg, "%d ::OMX_ComponentInit\n", __LINE__);
486
487 #endif
488 #ifdef __PERF_INSTRUMENTATION__
489 OMX_PRINT1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
490 PERF_ThreadCreated(pComponentPrivate->pPERF, pComponentPrivate->ComponentThread,
491 PERF_FOURCC('W','M','A','T'));
492 #endif
493 EXIT:
494
495
496
497 OMX_PRINT2(pComponentPrivate->dbg, "%d ::OMX_ComponentInit - returning %d\n", __LINE__,eError);
498 if(eError == OMX_ErrorInsufficientResources)
499 {
500 OMX_MEMFREE_STRUCT(pPortDef_op);
501 OMX_MEMFREE_STRUCT(pPortDef_ip);
502 OMX_MEMFREE_STRUCT(pComponentPrivate->sDeviceString);
503 OMX_MEMFREE_STRUCT(pComponentPrivate->pDspDefinition);
504 OMX_MEMFREE_STRUCT(pComponentPrivate->pHeaderInfo);
505 OMX_MEMFREE_STRUCT(pComponentPrivate->pOutputBufferList);
506 OMX_MEMFREE_STRUCT(pComponentPrivate->pInputBufferList);
507 OMX_MEMFREE_STRUCT(wma_op);
508 OMX_MEMFREE_STRUCT(wma_ip);
509 OMX_MEMFREE_STRUCT(pHandle->pComponentPrivate);
510
511 }
512 return eError;
513 }
514
515 /*-------------------------------------------------------------------*/
516 /**
517 * SetCallbacks() Sets application callbacks to the component
518 *
519 * This method will update application callbacks
520 * to the component. So that component can make use of those call back
521 * while sending buffers to the application. And also it will copy the
522 * application private data to component memory
523 *
524 * @param pComponent handle for this instance of the component
525 * @param pCallBacks application callbacks
526 * @param pAppData Application private data
527 *
528 * @retval OMX_NoError Success, ready to roll
529 * OMX_Error_BadParameter The input parameter pointer is null
530 **/
531 /*-------------------------------------------------------------------*/
532
SetCallbacks(OMX_HANDLETYPE pComponent,OMX_CALLBACKTYPE * pCallBacks,OMX_PTR pAppData)533 static OMX_ERRORTYPE SetCallbacks (OMX_HANDLETYPE pComponent,
534 OMX_CALLBACKTYPE* pCallBacks,
535 OMX_PTR pAppData)
536 {
537
538 OMX_ERRORTYPE eError = OMX_ErrorNone;
539
540 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE*)pComponent;
541
542 WMADEC_COMPONENT_PRIVATE *pComponentPrivate =
543 (WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
544
545 if (pCallBacks == NULL) {
546 OMX_PRINT1(pComponentPrivate->dbg, "About to return OMX_ErrorBadParameter on line %d\n",__LINE__);
547 eError = OMX_ErrorBadParameter;
548 OMX_ERROR4(pComponentPrivate->dbg, "%d :: Received the empty callbacks from the \
549 application\n",__LINE__);
550 goto EXIT;
551 }
552
553 /*Copy the callbacks of the application to the component private */
554 memcpy (&(pComponentPrivate->cbInfo), pCallBacks, sizeof(OMX_CALLBACKTYPE));
555
556 /*copy the application private data to component memory */
557 pHandle->pApplicationPrivate = pAppData;
558
559 pComponentPrivate->curState = OMX_StateLoaded;
560 #ifdef __PERF_INSTRUMENTATION__
561 OMX_PRDSP1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
562 /* PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundaryCleanup);*/
563 #endif
564 EXIT:
565 return eError;
566 }
567
568 /*-------------------------------------------------------------------*/
569 /**
570 * GetComponentVersion() This will return the component version
571 *
572 * This method will retrun the component version
573 *
574 * @param hComp handle for this instance of the component
575 * @param pCompnentName Name of the component
576 * @param pCompnentVersion handle for this instance of the component
577 * @param pSpecVersion application callbacks
578 * @param pCompnentUUID
579 *
580 * @retval OMX_NoError Success, ready to roll
581 * OMX_Error_BadParameter The input parameter pointer is null
582 **/
583 /*-------------------------------------------------------------------*/
584
GetComponentVersion(OMX_HANDLETYPE hComp,OMX_STRING pComponentName,OMX_VERSIONTYPE * pComponentVersion,OMX_VERSIONTYPE * pSpecVersion,OMX_UUIDTYPE * pComponentUUID)585 static OMX_ERRORTYPE GetComponentVersion (OMX_HANDLETYPE hComp,
586 OMX_STRING pComponentName,
587 OMX_VERSIONTYPE* pComponentVersion,
588 OMX_VERSIONTYPE* pSpecVersion,
589 OMX_UUIDTYPE* pComponentUUID)
590 {
591
592 OMX_ERRORTYPE eError = OMX_ErrorNone;
593 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE*) hComp;
594 WMADEC_COMPONENT_PRIVATE *pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
595 eError = OMX_ErrorNotImplemented;
596 #ifdef _ERROR_PROPAGATION__
597 if (pComponentPrivate->curState == OMX_StateInvalid){
598 eError = OMX_ErrorInvalidState;
599 goto EXIT;
600 }
601 #endif
602
603 EXIT:
604 OMX_PRINT1(pComponentPrivate->dbg, "Inside the GetComponentVersion\n");
605 return eError;
606
607 }
608
609
610 /*-------------------------------------------------------------------*/
611 /**
612 * SendCommand() used to send the commands to the component
613 *
614 * This method will be used by the application.
615 *
616 * @param phandle handle for this instance of the component
617 * @param Cmd Command to be sent to the component
618 * @param nParam indicates commmad is sent using this method
619 *
620 * @retval OMX_NoError Success, ready to roll
621 * OMX_Error_BadParameter The input parameter pointer is null
622 **/
623 /*-------------------------------------------------------------------*/
624
SendCommand(OMX_HANDLETYPE phandle,OMX_COMMANDTYPE Cmd,OMX_U32 nParam,OMX_PTR pCmdData)625 static OMX_ERRORTYPE SendCommand (OMX_HANDLETYPE phandle,
626 OMX_COMMANDTYPE Cmd,
627 OMX_U32 nParam,OMX_PTR pCmdData)
628 {
629
630 OMX_ERRORTYPE eError = OMX_ErrorNone;
631 int nRet;
632 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)phandle;
633 WMADEC_COMPONENT_PRIVATE *pCompPrivate =
634 (WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
635
636 #ifdef _ERROR_PROPAGATION__
637 if (pCompPrivate->curState == OMX_StateInvalid){
638 eError = OMX_ErrorInvalidState;
639 goto EXIT;
640 }
641 #else
642 OMX_PRINT1(pCompPrivate->dbg, "%d:::Inside SendCommand\n",__LINE__);
643 if(pCompPrivate->curState == OMX_StateInvalid){
644 eError = OMX_ErrorInvalidState;
645 OMX_ERROR4(pCompPrivate->dbg, "%d :: WMADEC: Error Notofication Sent to App\n",__LINE__);
646 pCompPrivate->cbInfo.EventHandler (
647 pHandle, pHandle->pApplicationPrivate,
648 OMX_EventError, OMX_ErrorInvalidState,0,
649 "Invalid State");
650
651 goto EXIT;
652 }
653 #endif
654
655 #ifdef __PERF_INSTRUMENTATION__
656 OMX_PRDSP1(pCompPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
657 PERF_SendingCommand(pCompPrivate->pPERF,
658 Cmd,
659 (Cmd == OMX_CommandMarkBuffer) ? ((OMX_U32) pCmdData) : nParam,
660 PERF_ModuleComponent);
661 #endif
662
663 switch(Cmd) {
664 case OMX_CommandStateSet:
665 OMX_PRINT1(pCompPrivate->dbg, "%d:::Inside SendCommand\n",__LINE__);
666 OMX_PRSTATE2(pCompPrivate->dbg, "%d:::pCompPrivate->curState = %d\n",__LINE__,pCompPrivate->curState);
667 if (nParam == OMX_StateLoaded) {
668 pCompPrivate->bLoadedCommandPending = OMX_TRUE;
669 }
670 if(pCompPrivate->curState == OMX_StateLoaded) {
671 if((nParam == OMX_StateExecuting) || (nParam == OMX_StatePause)) {
672 pCompPrivate->cbInfo.EventHandler (
673 pHandle,
674 pHandle->pApplicationPrivate,
675 OMX_EventError,
676 OMX_ErrorIncorrectStateTransition,
677 0,
678 NULL);
679 goto EXIT;
680 }
681
682 if(nParam == OMX_StateInvalid) {
683 OMX_PRINT1(pCompPrivate->dbg, "%d:::Inside SendCommand\n",__LINE__);
684 pCompPrivate->curState = OMX_StateInvalid;
685 pCompPrivate->cbInfo.EventHandler (
686 pHandle,
687 pHandle->pApplicationPrivate,
688 OMX_EventError,
689 OMX_ErrorInvalidState,
690 0,
691 NULL);
692 goto EXIT;
693 }
694 }
695 break;
696 case OMX_CommandFlush:
697 if(nParam > 1 && nParam != -1) {
698 eError = OMX_ErrorBadPortIndex;
699 goto EXIT;
700 }
701
702 break;
703 case OMX_CommandPortDisable:
704 break;
705 case OMX_CommandPortEnable:
706 break;
707 case OMX_CommandMarkBuffer:
708 if (nParam > 0) {
709 eError = OMX_ErrorBadPortIndex;
710 goto EXIT;
711 }
712 break;
713 default:
714 OMX_PRDSP2(pCompPrivate->dbg, "%d :: WMADEC: Command Received Default \
715 error\n",__LINE__);
716 pCompPrivate->cbInfo.EventHandler (
717 pHandle, pHandle->pApplicationPrivate,
718 OMX_EventError,
719 OMX_ErrorUndefined,0,
720 "Invalid Command");
721 break;
722
723 }
724
725 OMX_PRINT1(pCompPrivate->dbg, "%d:::Inside SendCommand\n",__LINE__);
726 nRet = write (pCompPrivate->cmdPipe[1], &Cmd, sizeof(Cmd));
727 if (nRet == -1) {
728 OMX_PRINT1(pCompPrivate->dbg, "%d:::Inside SendCommand\n",__LINE__);
729 eError = OMX_ErrorInsufficientResources;
730 goto EXIT;
731 }
732
733 if (Cmd == OMX_CommandMarkBuffer) {
734 nRet = write(pCompPrivate->cmdDataPipe[1],&pCmdData,sizeof(OMX_PTR));
735 }
736 else {
737 nRet = write(pCompPrivate->cmdDataPipe[1], &nParam,
738 sizeof(OMX_U32));
739 }
740
741 OMX_PRINT1(pCompPrivate->dbg, "%d:::Inside SendCommand\n",__LINE__);
742 OMX_PRINT2(pCompPrivate->dbg, "%d:::nRet = %d\n",__LINE__,nRet);
743 if (nRet == -1) {
744 OMX_ERROR4(pCompPrivate->dbg, "%d:::Inside SendCommand\n",__LINE__);
745 eError = OMX_ErrorInsufficientResources;
746 goto EXIT;
747 }
748 EXIT:
749 return eError;
750 }
751 /*-------------------------------------------------------------------*/
752 /**
753 * GetParameter() Gets the current configurations of the component
754 *
755 * @param hComp handle for this instance of the component
756 * @param nParamIndex
757 * @param ComponentParameterStructure
758 *
759 * @retval OMX_NoError Success, ready to roll
760 * OMX_Error_BadParameter The input parameter pointer is null
761 **/
762 /*-------------------------------------------------------------------*/
GetParameter(OMX_HANDLETYPE hComp,OMX_INDEXTYPE nParamIndex,OMX_PTR ComponentParameterStructure)763 static OMX_ERRORTYPE GetParameter (OMX_HANDLETYPE hComp,
764 OMX_INDEXTYPE nParamIndex,
765 OMX_PTR ComponentParameterStructure)
766 {
767
768 OMX_ERRORTYPE eError = OMX_ErrorNone;
769 WMADEC_COMPONENT_PRIVATE *pComponentPrivate;
770 OMX_PARAM_PORTDEFINITIONTYPE *pParameterStructure;
771 /*OMX_PARAM_BUFFERSUPPLIERTYPE *pBufferSupplier;*/
772
773 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)(((OMX_COMPONENTTYPE*)hComp)->pComponentPrivate);
774 pParameterStructure = (OMX_PARAM_PORTDEFINITIONTYPE*)ComponentParameterStructure;
775
776 if (pParameterStructure == NULL) {
777 eError = OMX_ErrorBadParameter;
778 goto EXIT;
779
780 }
781 OMX_PRINT1(pComponentPrivate->dbg, "pParameterStructure = %p\n",pParameterStructure);
782 #ifdef _ERROR_PROPAGATION__
783 if (pComponentPrivate->curState == OMX_StateInvalid){
784 eError = OMX_ErrorInvalidState;
785 goto EXIT;
786 }
787 #else
788 if(pComponentPrivate->curState == OMX_StateInvalid) {
789 pComponentPrivate->cbInfo.EventHandler(
790 hComp,
791 ((OMX_COMPONENTTYPE *)hComp)->pApplicationPrivate,
792 OMX_EventError,
793 OMX_ErrorIncorrectStateOperation,
794 0,
795 NULL);
796
797 }
798 #endif
799 switch(nParamIndex){
800 case OMX_IndexParamAudioInit:
801
802 OMX_PRINT1(pComponentPrivate->dbg, "OMX_IndexParamAudioInit\n");
803 memcpy(ComponentParameterStructure, &pComponentPrivate->sPortParam, sizeof(OMX_PORT_PARAM_TYPE));
804 break;
805 case OMX_IndexParamPortDefinition:
806 if(((OMX_PARAM_PORTDEFINITIONTYPE *)(ComponentParameterStructure))->nPortIndex ==
807 pComponentPrivate->pPortDef[INPUT_PORT]->nPortIndex) {
808
809
810 memcpy(ComponentParameterStructure,
811 pComponentPrivate->pPortDef[INPUT_PORT],
812 sizeof(OMX_PARAM_PORTDEFINITIONTYPE)
813 );
814 }
815 else if(((OMX_PARAM_PORTDEFINITIONTYPE *)(ComponentParameterStructure))->nPortIndex ==
816 pComponentPrivate->pPortDef[OUTPUT_PORT]->nPortIndex) {
817
818
819 memcpy(ComponentParameterStructure,
820 pComponentPrivate->pPortDef[OUTPUT_PORT],
821 sizeof(OMX_PARAM_PORTDEFINITIONTYPE)
822 );
823
824 }
825 else {
826 eError = OMX_ErrorBadPortIndex;
827 }
828 break;
829
830 case OMX_IndexParamAudioPortFormat:
831 if(((OMX_AUDIO_PARAM_PORTFORMATTYPE *)(ComponentParameterStructure))->nPortIndex ==
832 pComponentPrivate->pPortDef[INPUT_PORT]->nPortIndex) {
833
834 if(((OMX_AUDIO_PARAM_PORTFORMATTYPE *)(ComponentParameterStructure))->nIndex >
835 pComponentPrivate->sInPortFormat.nIndex) {
836
837 eError = OMX_ErrorNoMore;
838 }
839 else {
840 memcpy(ComponentParameterStructure, &pComponentPrivate->sInPortFormat,
841 sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
842 }
843 }
844 else if(((OMX_AUDIO_PARAM_PORTFORMATTYPE *)(ComponentParameterStructure))->nPortIndex ==
845 pComponentPrivate->pPortDef[OUTPUT_PORT]->nPortIndex){
846
847
848 if(((OMX_AUDIO_PARAM_PORTFORMATTYPE *)(ComponentParameterStructure))->nIndex >
849 pComponentPrivate->sOutPortFormat.nIndex) {
850
851 eError = OMX_ErrorNoMore;
852 }
853 else {
854
855 memcpy(ComponentParameterStructure, &pComponentPrivate->sOutPortFormat,
856 sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
857 }
858 }
859 else {
860
861 eError = OMX_ErrorBadPortIndex;
862 }
863 break;
864
865 case OMX_IndexParamPriorityMgmt:
866 break;
867 case OMX_IndexParamAudioWma:
868 OMX_PRINT2(pComponentPrivate->dbg, "%d :: GetParameter OMX_IndexParamAudioWma \n",__LINE__);
869 OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: GetParameter nPortIndex %ld\n",__LINE__, ((OMX_AUDIO_PARAM_PORTFORMATTYPE *)(ComponentParameterStructure))->nPortIndex);
870 OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: GetParameter wmaParams->nPortIndex %ld\n",__LINE__, pComponentPrivate->wmaParams[INPUT_PORT]->nPortIndex);
871 if(((OMX_AUDIO_PARAM_PORTFORMATTYPE *)(ComponentParameterStructure))->nPortIndex ==
872 pComponentPrivate->wmaParams[INPUT_PORT]->nPortIndex)
873 {
874 memcpy(ComponentParameterStructure, pComponentPrivate->wmaParams[INPUT_PORT], sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
875 }
876 else if(((OMX_AUDIO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->nPortIndex ==
877 pComponentPrivate->wmaParams[OUTPUT_PORT]->nPortIndex)
878 {
879 memcpy(ComponentParameterStructure, pComponentPrivate->wmaParams[OUTPUT_PORT], sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
880
881 }
882 else
883 {
884
885 eError = OMX_ErrorBadPortIndex;
886 }
887 break;
888 case OMX_IndexParamAudioPcm:
889 memcpy(ComponentParameterStructure,
890 (OMX_AUDIO_PARAM_PCMMODETYPE*)pComponentPrivate->wma_op,
891 sizeof(OMX_AUDIO_PARAM_PCMMODETYPE)
892 );
893 break;
894
895 case OMX_IndexParamCompBufferSupplier:
896 if(((OMX_PARAM_BUFFERSUPPLIERTYPE *)(ComponentParameterStructure))->nPortIndex == OMX_DirInput) {
897 OMX_PRBUFFER2(pComponentPrivate->dbg, ":: GetParameter OMX_IndexParamCompBufferSupplier \n");
898 /* memcpy(ComponentParameterStructure, pBufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE)); */
899
900 }
901 else if(((OMX_PARAM_BUFFERSUPPLIERTYPE *)(ComponentParameterStructure))->nPortIndex == OMX_DirOutput) {
902 OMX_PRBUFFER2(pComponentPrivate->dbg, ":: GetParameter OMX_IndexParamCompBufferSupplier \n");
903 /*memcpy(ComponentParameterStructure, pBufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE)); */
904 }
905 else {
906 OMX_ERROR2(pComponentPrivate->dbg, ":: OMX_ErrorBadPortIndex from GetParameter");
907 eError = OMX_ErrorBadPortIndex;
908 }
909 break;
910
911 case OMX_IndexParamVideoInit:
912 break;
913
914 case OMX_IndexParamImageInit:
915 break;
916
917 case OMX_IndexParamOtherInit:
918 /*#ifdef ANDROID
919 OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering OMX_IndexParamVideoInit\n", __LINE__);
920 OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering OMX_IndexParamImageInit/OtherInit\n", __LINE__);
921 memcpy(ComponentParameterStructure,pComponentPrivate->sPortParam, sizeof(OMX_PORT_PARAM_TYPE));
922
923
924 eError = OMX_ErrorNone;
925 #else
926 eError = OMX_ErrorUnsupportedIndex;
927 #endif*/
928 break;
929
930 #ifdef ANDROID
931 case (OMX_INDEXTYPE) PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX:
932 {
933 OMX_PRDSP1(pComponentPrivate->dbg, "Entering PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX::%d\n", __LINE__);
934 PV_OMXComponentCapabilityFlagsType* pCap_flags = (PV_OMXComponentCapabilityFlagsType *) ComponentParameterStructure;
935 if (NULL == pCap_flags)
936 {
937 OMX_ERROR4(pComponentPrivate->dbg, "%d :: ERROR PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX\n", __LINE__);
938 eError = OMX_ErrorBadParameter;
939 goto EXIT;
940 }
941 OMX_ERROR2(pComponentPrivate->dbg, "%d :: Copying PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX\n", __LINE__);
942 memcpy(pCap_flags, &(pComponentPrivate->iPVCapabilityFlags), sizeof(PV_OMXComponentCapabilityFlagsType));
943 eError = OMX_ErrorNone;
944 }
945 break;
946 #endif
947 default:
948 eError = OMX_ErrorUnsupportedIndex;
949 break;
950 }
951 EXIT:
952 OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting GetParameter:: %x\n",__LINE__,nParamIndex);
953 return eError;
954 }
955
956 /*-------------------------------------------------------------------*/
957 /**
958 * SetParameter() Sets configuration paramets to the component
959 *
960 * @param hComp handle for this instance of the component
961 * @param nParamIndex
962 * @param pCompParam
963 *
964 * @retval OMX_NoError Success, ready to roll
965 * OMX_Error_BadParameter The input parameter pointer is null
966 **/
967 /*-------------------------------------------------------------------*/
968
SetParameter(OMX_HANDLETYPE hComp,OMX_INDEXTYPE nParamIndex,OMX_PTR pCompParam)969 static OMX_ERRORTYPE SetParameter (OMX_HANDLETYPE hComp,
970 OMX_INDEXTYPE nParamIndex,
971 OMX_PTR pCompParam)
972 {
973
974
975 OMX_ERRORTYPE eError = OMX_ErrorNone;
976 OMX_COMPONENTTYPE* pHandle= (OMX_COMPONENTTYPE*)hComp;
977 WMADEC_COMPONENT_PRIVATE *pComponentPrivate;
978 OMX_PARAM_PORTDEFINITIONTYPE *pComponentParam = NULL;
979 OMX_PARAM_COMPONENTROLETYPE *pRole;
980 OMX_AUDIO_PARAM_PCMMODETYPE *wma_op;
981 OMX_PARAM_BUFFERSUPPLIERTYPE sBufferSupplier;
982 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)(((OMX_COMPONENTTYPE*)hComp)->pComponentPrivate);
983
984
985
986 if (pCompParam == NULL) {
987 eError = OMX_ErrorBadParameter;
988 goto EXIT;
989 }
990
991 #ifdef _ERROR_PROPAGATION__
992 if (pComponentPrivate->curState == OMX_StateInvalid){
993 eError = OMX_ErrorInvalidState;
994 goto EXIT;
995 }
996 #endif
997
998 switch(nParamIndex) {
999 case OMX_IndexParamAudioPortFormat:
1000 pComponentParam = (OMX_PARAM_PORTDEFINITIONTYPE *)pCompParam;
1001
1002 /* 0 means Input port */
1003 if (pComponentParam->nPortIndex == 0) {
1004 if (pComponentParam->eDir != OMX_DirInput) {
1005 OMX_PRBUFFER4(pComponentPrivate->dbg, "%d :: Invalid input buffer Direction\n",__LINE__);
1006 eError = OMX_ErrorBadParameter;
1007 OMX_ERROR4(pComponentPrivate->dbg, "About to return OMX_ErrorBadParameter on line %d\n",__LINE__);
1008 goto EXIT;
1009 }
1010
1011 }
1012 else if (pComponentParam->nPortIndex == 1) {
1013 /* 1 means Output port */
1014
1015 if (pComponentParam->eDir != OMX_DirOutput) {
1016 eError = OMX_ErrorBadParameter;
1017 OMX_ERROR4(pComponentPrivate->dbg, "About to return OMX_ErrorBadParameter on line %d\n",__LINE__);
1018 goto EXIT;
1019 }
1020 pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferSize = pComponentParam->nBufferSize;
1021 /*
1022 if (pComponentParam->nBufferSize != OUTPUT_WMADEC_BUFFER_SIZE) {
1023 eError = OMX_ErrorBadParameter;
1024 OMX_PRINT1(pComponentPrivate->dbg, "About to return OMX_ErrorBadParameter on line %d\n",__LINE__);
1025 goto EXIT;
1026 }
1027
1028 if (pComponentParam->format.audio.eEncoding != OMX_AUDIO_CodingPCM) {
1029 eError = OMX_ErrorBadParameter;
1030 goto EXIT;
1031 } */
1032 }
1033 else {
1034 eError = OMX_ErrorBadParameter;
1035 goto EXIT;
1036 }
1037 break;
1038 case OMX_IndexParamAudioWma:
1039 {
1040 OMX_AUDIO_PARAM_WMATYPE *pCompWmaParam =
1041 (OMX_AUDIO_PARAM_WMATYPE *)pCompParam;
1042
1043 /* 0 means Input port */
1044 if(pCompWmaParam->nPortIndex == 0) {
1045 OMX_PRCOMM2(pComponentPrivate->dbg, "pCompWmaParam->nPortIndex == 0\n");
1046 memcpy(((WMADEC_COMPONENT_PRIVATE*)
1047 pHandle->pComponentPrivate)->wmaParams[INPUT_PORT],
1048 pCompWmaParam, sizeof(OMX_AUDIO_PARAM_WMATYPE));
1049
1050 } else if (pCompWmaParam->nPortIndex == 1) {
1051 pComponentPrivate->wmaParams[OUTPUT_PORT]->nSize = pCompWmaParam->nSize;
1052 pComponentPrivate->wmaParams[OUTPUT_PORT]->nPortIndex = pCompWmaParam->nPortIndex;
1053 pComponentPrivate->wmaParams[OUTPUT_PORT]->nBitRate = pCompWmaParam->nBitRate;
1054 pComponentPrivate->wmaParams[OUTPUT_PORT]->eFormat = pCompWmaParam->eFormat;
1055 }
1056 else {
1057 eError = OMX_ErrorBadPortIndex;
1058 }
1059 }
1060 break;
1061 case OMX_IndexParamPortDefinition:
1062 if(((OMX_PARAM_PORTDEFINITIONTYPE *)(pCompParam))->nPortIndex ==
1063 pComponentPrivate->pPortDef[INPUT_PORT]->nPortIndex) {
1064
1065 memcpy(pComponentPrivate->pPortDef[INPUT_PORT],
1066 pCompParam,
1067 sizeof(OMX_PARAM_PORTDEFINITIONTYPE)
1068 );
1069
1070 }
1071 else if(((OMX_PARAM_PORTDEFINITIONTYPE *)(pCompParam))->nPortIndex ==
1072 pComponentPrivate->pPortDef[OUTPUT_PORT]->nPortIndex) {
1073
1074 memcpy(pComponentPrivate->pPortDef[OUTPUT_PORT],
1075 pCompParam,
1076 sizeof(OMX_PARAM_PORTDEFINITIONTYPE)
1077 );
1078
1079 }
1080 else {
1081 eError = OMX_ErrorBadPortIndex;
1082 }
1083 break;
1084 case OMX_IndexParamPriorityMgmt:
1085 if (pComponentPrivate->curState != OMX_StateLoaded) {
1086 eError = OMX_ErrorIncorrectStateOperation;
1087 }
1088 break;
1089 case OMX_IndexParamStandardComponentRole:
1090 if (pCompParam) {
1091 pRole = (OMX_PARAM_COMPONENTROLETYPE *)pCompParam;
1092 memcpy(&(pComponentPrivate->componentRole), (void *)pRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1093 } else {
1094 eError = OMX_ErrorBadParameter;
1095 }
1096 break;
1097
1098 case OMX_IndexParamAudioPcm:
1099 if(pCompParam){
1100 wma_op = (OMX_AUDIO_PARAM_PCMMODETYPE *)pCompParam;
1101 memcpy(pComponentPrivate->wma_op, wma_op, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
1102 }
1103 else{
1104 eError = OMX_ErrorBadParameter;
1105 }
1106 break;
1107
1108 case OMX_IndexParamCompBufferSupplier:
1109 if(((OMX_PARAM_PORTDEFINITIONTYPE *)(pCompParam))->nPortIndex ==
1110 pComponentPrivate->pPortDef[INPUT_PORT]->nPortIndex) {
1111 OMX_PRINT2(pComponentPrivate->dbg, ":: SetParameter OMX_IndexParamCompBufferSupplier \n");
1112 sBufferSupplier.eBufferSupplier = OMX_BufferSupplyInput;
1113 memcpy(&sBufferSupplier, pCompParam, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
1114 }
1115 else if(((OMX_PARAM_PORTDEFINITIONTYPE *)(pCompParam))->nPortIndex ==
1116 pComponentPrivate->pPortDef[OUTPUT_PORT]->nPortIndex) {
1117 OMX_PRINT2(pComponentPrivate->dbg, ":: SetParameter OMX_IndexParamCompBufferSupplier \n");
1118 sBufferSupplier.eBufferSupplier = OMX_BufferSupplyOutput;
1119 memcpy(&sBufferSupplier, pCompParam, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
1120 }
1121 else {
1122 OMX_ERROR2(pComponentPrivate->dbg, ":: OMX_ErrorBadPortIndex from SetParameter");
1123 eError = OMX_ErrorBadPortIndex;
1124 }
1125 break;
1126 default:
1127 break;
1128
1129 }
1130 EXIT:
1131 return eError;
1132 }
1133 /*-------------------------------------------------------------------*/
1134 /**
1135 * GetConfig() Gets the current configuration of to the component
1136 *
1137 * @param hComp handle for this instance of the component
1138 * @param nConfigIndex
1139 * @param ComponentConfigStructure
1140 *
1141 * @retval OMX_NoError Success, ready to roll
1142 * OMX_Error_BadParameter The input parameter pointer is null
1143 **/
1144 /*-------------------------------------------------------------------*/
1145
GetConfig(OMX_HANDLETYPE hComp,OMX_INDEXTYPE nConfigIndex,OMX_PTR ComponentConfigStructure)1146 static OMX_ERRORTYPE GetConfig (OMX_HANDLETYPE hComp,
1147 OMX_INDEXTYPE nConfigIndex,
1148 OMX_PTR ComponentConfigStructure)
1149 {
1150
1151 OMX_ERRORTYPE eError = OMX_ErrorNone;
1152
1153 WMADEC_COMPONENT_PRIVATE *pComponentPrivate;
1154 TI_OMX_STREAM_INFO *streamInfo;
1155
1156 OMX_MALLOC_GENERIC(streamInfo, TI_OMX_STREAM_INFO);
1157 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)
1158 (((OMX_COMPONENTTYPE*)hComp)->pComponentPrivate);
1159
1160 OMX_PRINT1(pComponentPrivate->dbg, "Inside GetConfig\n");
1161
1162 #ifdef _ERROR_PROPAGATION__
1163 if (pComponentPrivate->curState == OMX_StateInvalid){
1164 eError = OMX_ErrorInvalidState;
1165 goto EXIT;
1166 }
1167 #endif
1168
1169 if(nConfigIndex == OMX_IndexCustomWmaDecStreamIDConfig)
1170 {
1171 /* copy component info */
1172 streamInfo->streamId = pComponentPrivate->streamID;
1173 memcpy(ComponentConfigStructure,streamInfo,sizeof(TI_OMX_STREAM_INFO));
1174 } else if (nConfigIndex == OMX_IndexCustomDebug) {
1175 OMX_DBG_GETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
1176 }
1177
1178 EXIT:
1179 if(streamInfo)
1180 {
1181 free(streamInfo);
1182 streamInfo = NULL;
1183 }
1184 OMX_PRINT1(pComponentPrivate->dbg, "Exiting GetConfig\n");
1185 return eError;
1186 }
1187 /*-------------------------------------------------------------------*/
1188 /**
1189 * SetConfig() Sets the configraiton to the component
1190 *
1191 * @param hComp handle for this instance of the component
1192 * @param nConfigIndex
1193 * @param ComponentConfigStructure
1194 *
1195 * @retval OMX_NoError Success, ready to roll
1196 * OMX_Error_BadParameter The input parameter pointer is null
1197 **/
1198 /*-------------------------------------------------------------------*/
1199
SetConfig(OMX_HANDLETYPE hComp,OMX_INDEXTYPE nConfigIndex,OMX_PTR ComponentConfigStructure)1200 static OMX_ERRORTYPE SetConfig (OMX_HANDLETYPE hComp,
1201 OMX_INDEXTYPE nConfigIndex,
1202 OMX_PTR ComponentConfigStructure)
1203 {
1204 OMX_ERRORTYPE eError = OMX_ErrorNone;
1205 OMX_COMPONENTTYPE* pHandle = (OMX_COMPONENTTYPE*)hComp;
1206 WMADEC_COMPONENT_PRIVATE *pComponentPrivate;
1207 WMA_HeadInfo* headerInfo = NULL;
1208 TI_OMX_DSP_DEFINITION* pDspDefinition = (TI_OMX_DSP_DEFINITION*)ComponentConfigStructure;
1209 /*int flagValue = 0;*/
1210 OMX_S16* deviceString;
1211 TI_OMX_DATAPATH dataPath;
1212 OMXDBG_PRINT(stderr, PRINT, 1, 0, "%d :: Entering SetConfig\n", __LINE__);
1213 if (pHandle == NULL) {
1214 OMXDBG_PRINT(stderr, ERROR, 4, 0, "%d :: Invalid HANDLE OMX_ErrorBadParameter \n",__LINE__);
1215 eError = OMX_ErrorBadParameter;
1216 goto EXIT;
1217 }
1218 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1219 OMX_PRSTATE1(pComponentPrivate->dbg, "Set Config %d\n",__LINE__);
1220
1221 #ifdef _ERROR_PROPAGATION__
1222 if (pComponentPrivate->curState == OMX_StateInvalid){
1223 eError = OMX_ErrorInvalidState;
1224 goto EXIT;
1225 }
1226 #endif
1227
1228 switch (nConfigIndex) {
1229 case OMX_IndexCustomWMADECHeaderInfoConfig:
1230 memcpy(pComponentPrivate->pDspDefinition,pDspDefinition,sizeof(TI_OMX_DSP_DEFINITION));
1231 headerInfo = pDspDefinition->wmaHeaderInfo;
1232 memcpy(pComponentPrivate->pHeaderInfo,headerInfo,sizeof(WMA_HeadInfo));
1233 if(pComponentPrivate->pDspDefinition->dasfMode == 0){
1234 pComponentPrivate->dasfmode = 0;
1235 }
1236 else if (pComponentPrivate->pDspDefinition->dasfMode == 1) {
1237 pComponentPrivate->dasfmode = 1;
1238 }
1239 else if(pComponentPrivate->pDspDefinition->dasfMode == 2) {
1240 pComponentPrivate->dasfmode = 1;
1241 }
1242 pComponentPrivate->streamID = pDspDefinition->streamId;
1243 break;
1244 case OMX_IndexCustomWmaDecDataPath:
1245 deviceString = (OMX_S16*)ComponentConfigStructure;
1246 if (deviceString == NULL)
1247 {
1248 eError = OMX_ErrorBadParameter;
1249 goto EXIT;
1250 }
1251
1252 dataPath = *deviceString;
1253 switch(dataPath)
1254 {
1255 case DATAPATH_APPLICATION:
1256 OMX_MMMIXER_DATAPATH(pComponentPrivate->sDeviceString, RENDERTYPE_DECODER, pComponentPrivate->streamID);
1257 break;
1258
1259 case DATAPATH_APPLICATION_RTMIXER:
1260 strcpy((char*)pComponentPrivate->sDeviceString,(char*)RTM_STRING);
1261 break;
1262
1263 case DATAPATH_ACDN:
1264 strcpy((char*)pComponentPrivate->sDeviceString,(char*)ACDN_STRING);
1265 break;
1266
1267 default:
1268 break;
1269 }
1270 break;
1271 case OMX_IndexCustomDebug:
1272 OMX_DBG_SETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
1273 break;
1274 default:
1275 eError = OMX_ErrorUnsupportedIndex;
1276 break;
1277 }
1278 EXIT:
1279 OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting SetConfig\n", __LINE__);
1280 OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
1281 return eError;
1282
1283
1284 }
1285 /*-------------------------------------------------------------------*/
1286 /**
1287 * GetState() Gets the current state of the component
1288 *
1289 * @param pCompomponent handle for this instance of the component
1290 * @param pState
1291 *
1292 * @retval OMX_NoError Success, ready to roll
1293 * OMX_Error_BadParameter The input parameter pointer is null
1294 **/
1295 /*-------------------------------------------------------------------*/
1296
GetState(OMX_HANDLETYPE pComponent,OMX_STATETYPE * pState)1297 static OMX_ERRORTYPE GetState (OMX_HANDLETYPE pComponent, OMX_STATETYPE* pState)
1298 {
1299
1300 OMX_ERRORTYPE error = OMX_ErrorUndefined;
1301 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
1302
1303 if (!pState) {
1304 error = OMX_ErrorBadParameter;
1305 OMXDBG_PRINT(stderr, ERROR, 4, 0, "About to return OMX_ErrorBadParameter on line %d\n",__LINE__);
1306 goto EXIT;
1307 }
1308
1309 if (pHandle && pHandle->pComponentPrivate) {
1310 *pState = ((WMADEC_COMPONENT_PRIVATE*)
1311 pHandle->pComponentPrivate)->curState;
1312 } else {
1313 *pState = OMX_StateLoaded;
1314 }
1315
1316 error = OMX_ErrorNone;
1317
1318 EXIT:
1319 return error;
1320 }
1321
1322 /*-------------------------------------------------------------------*/
1323 /**
1324 * EmptyThisBuffer() This callback is used to send the input buffer to
1325 * component
1326 *
1327 * @param pComponent handle for this instance of the component
1328 * @param nPortIndex input port index
1329 * @param pBuffer buffer to be sent to codec
1330 *
1331 * @retval OMX_NoError Success, ready to roll
1332 * OMX_Error_BadParameter The input parameter pointer is null
1333 **/
1334 /*-------------------------------------------------------------------*/
EmptyThisBuffer(OMX_HANDLETYPE pComponent,OMX_BUFFERHEADERTYPE * pBuffer)1335 static OMX_ERRORTYPE EmptyThisBuffer (OMX_HANDLETYPE pComponent,
1336 OMX_BUFFERHEADERTYPE* pBuffer)
1337 {
1338 OMX_ERRORTYPE eError = OMX_ErrorNone;
1339 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
1340 WMADEC_COMPONENT_PRIVATE *pComponentPrivate =
1341 (WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1342 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
1343 int ret=0;
1344 pPortDef = ((WMADEC_COMPONENT_PRIVATE*)
1345 pComponentPrivate)->pPortDef[INPUT_PORT];
1346 #ifdef _ERROR_PROPAGATION__
1347 if (pComponentPrivate->curState == OMX_StateInvalid){
1348 eError = OMX_ErrorInvalidState;
1349 goto EXIT;
1350 }
1351 #endif
1352 #ifdef __PERF_INSTRUMENTATION__
1353 OMX_PRINT1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
1354 PERF_ReceivedFrame(pComponentPrivate->pPERF,
1355 pBuffer->pBuffer,
1356 pBuffer->nFilledLen,
1357 PERF_ModuleHLMM);
1358 #endif
1359 if(!pPortDef->bEnabled) {
1360 eError = OMX_ErrorIncorrectStateOperation;
1361 goto EXIT;
1362 }
1363
1364 if (pBuffer == NULL) {
1365 eError = OMX_ErrorBadParameter;
1366 OMX_ERROR4(pComponentPrivate->dbg, "About to return OMX_ErrorBadParameter on line %d\n",__LINE__);
1367 goto EXIT;
1368 }
1369
1370 if (pBuffer->nSize != sizeof(OMX_BUFFERHEADERTYPE)) {
1371 eError = OMX_ErrorBadParameter;
1372 goto EXIT;
1373 }
1374
1375 if (pBuffer->nVersion.nVersion != pComponentPrivate->nVersion) {
1376 eError = OMX_ErrorVersionMismatch;
1377 goto EXIT;
1378 }
1379
1380 if (pBuffer->nInputPortIndex != INPUT_PORT) {
1381 eError = OMX_ErrorBadPortIndex;
1382 goto EXIT;
1383 }
1384
1385 if(pComponentPrivate->curState != OMX_StateExecuting && pComponentPrivate->curState != OMX_StatePause
1386 && pComponentPrivate->curState != OMX_StateIdle) {
1387 eError = OMX_ErrorIncorrectStateOperation;
1388 goto EXIT;
1389 }
1390
1391 OMX_PRBUFFER1(pComponentPrivate->dbg, "\n------------------------------------------\n\n");
1392 OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: Component Sending Filled ip buff %p to Component Thread\n",
1393 __LINE__,pBuffer);
1394 OMX_PRBUFFER1(pComponentPrivate->dbg, "\n------------------------------------------\n\n");
1395
1396 if (pComponentPrivate->bBypassDSP == 0) {
1397 pComponentPrivate->app_nBuf--;
1398 }
1399
1400 pComponentPrivate->pMarkData = pBuffer->pMarkData;
1401 pComponentPrivate->hMarkTargetComponent = pBuffer->hMarkTargetComponent;
1402
1403 pComponentPrivate->nUnhandledEmptyThisBuffers++;
1404
1405 ret = write (pComponentPrivate->dataPipe[1], &pBuffer, sizeof(OMX_BUFFERHEADERTYPE*));
1406
1407 if (ret == -1) {
1408 OMX_TRACE4(pComponentPrivate->dbg, "%d :: Error in Writing to the Data pipe\n", __LINE__);
1409 eError = OMX_ErrorHardware;
1410 goto EXIT;
1411 }
1412
1413 pComponentPrivate->nEmptyThisBufferCount++;
1414 EXIT:
1415 return eError;
1416 }
1417 /**-------------------------------------------------------------------*
1418 * FillThisBuffer() This callback is used to send the output buffer to
1419 * the component
1420 *
1421 * @param pComponent handle for this instance of the component
1422 * @param nPortIndex output port number
1423 * @param pBuffer buffer to be sent to codec
1424 *
1425 * @retval OMX_NoError Success, ready to roll
1426 * OMX_Error_BadParameter The input parameter pointer is null
1427 **/
1428 /*-------------------------------------------------------------------*/
1429
FillThisBuffer(OMX_HANDLETYPE pComponent,OMX_BUFFERHEADERTYPE * pBuffer)1430 static OMX_ERRORTYPE FillThisBuffer (OMX_HANDLETYPE pComponent,
1431 OMX_BUFFERHEADERTYPE* pBuffer)
1432 {
1433
1434 OMX_ERRORTYPE eError = OMX_ErrorNone;
1435 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
1436 WMADEC_COMPONENT_PRIVATE *pComponentPrivate =
1437 (WMADEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1438 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
1439 int nRet=0;
1440
1441 OMX_PRBUFFER1(pComponentPrivate->dbg, "\n------------------------------------------\n\n");
1442 OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: Component Sending Emptied op buff %p to Component Thread\n",
1443 __LINE__,pBuffer);
1444 OMX_PRBUFFER1(pComponentPrivate->dbg, "\n------------------------------------------\n\n");
1445
1446 pPortDef = ((WMADEC_COMPONENT_PRIVATE*)
1447 pComponentPrivate)->pPortDef[OUTPUT_PORT];
1448 #ifdef _ERROR_PROPAGATION__
1449 if (pComponentPrivate->curState == OMX_StateInvalid){
1450 eError = OMX_ErrorInvalidState;
1451 goto EXIT;
1452 }
1453 #endif
1454 #ifdef __PERF_INSTRUMENTATION__
1455 OMX_PRDSP1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
1456 PERF_ReceivedFrame(pComponentPrivate->pPERF,
1457 pBuffer->pBuffer,
1458 0,
1459 PERF_ModuleHLMM);
1460 #endif
1461
1462 if(!pPortDef->bEnabled) {
1463 eError = OMX_ErrorIncorrectStateOperation;
1464 goto EXIT;
1465 }
1466
1467 if (pBuffer == NULL) {
1468 eError = OMX_ErrorBadParameter;
1469 OMX_ERROR4(pComponentPrivate->dbg, "About to return OMX_ErrorBadParameter on line %d\n",__LINE__);
1470 goto EXIT;
1471 }
1472
1473 if (pBuffer->nSize != sizeof(OMX_BUFFERHEADERTYPE)) {
1474 eError = OMX_ErrorBadParameter;
1475 goto EXIT;
1476 }
1477
1478 if (pBuffer->nVersion.nVersion != pComponentPrivate->nVersion) {
1479 eError = OMX_ErrorVersionMismatch;
1480 goto EXIT;
1481 }
1482
1483 if (pBuffer->nOutputPortIndex != OUTPUT_PORT) {
1484 eError = OMX_ErrorBadPortIndex;
1485 goto EXIT;
1486 }
1487
1488 if(pComponentPrivate->curState != OMX_StateExecuting && pComponentPrivate->curState != OMX_StatePause) {
1489 eError = OMX_ErrorIncorrectStateOperation;
1490 goto EXIT;
1491 }
1492
1493 OMX_PRBUFFER1(pComponentPrivate->dbg, "FillThisBuffer Line %d\n",__LINE__);
1494 pBuffer->nFilledLen = 0;
1495 OMX_PRBUFFER1(pComponentPrivate->dbg, "FillThisBuffer Line %d\n",__LINE__);
1496 /*Filling the Output buffer with zero */
1497
1498 memset (pBuffer->pBuffer,0,pBuffer->nAllocLen);
1499 OMX_PRBUFFER1(pComponentPrivate->dbg, "FillThisBuffer Line %d\n",__LINE__);
1500
1501 OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pMarkBuf = %p\n",pComponentPrivate->pMarkBuf);
1502 OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pMarkData = %p\n",pComponentPrivate->pMarkData);
1503 if(pComponentPrivate->pMarkBuf){
1504 OMX_PRBUFFER1(pComponentPrivate->dbg, "FillThisBuffer Line %d\n",__LINE__);
1505 pBuffer->hMarkTargetComponent = pComponentPrivate->pMarkBuf->hMarkTargetComponent;
1506 pBuffer->pMarkData = pComponentPrivate->pMarkBuf->pMarkData;
1507 pComponentPrivate->pMarkBuf = NULL;
1508 }
1509
1510 if (pComponentPrivate->pMarkData) {
1511 OMX_PRBUFFER1(pComponentPrivate->dbg, "FillThisBuffer Line %d\n",__LINE__);
1512 pBuffer->hMarkTargetComponent = pComponentPrivate->hMarkTargetComponent;
1513 pBuffer->pMarkData = pComponentPrivate->pMarkData;
1514 pComponentPrivate->pMarkData = NULL;
1515 }
1516 pComponentPrivate->nUnhandledFillThisBuffers++;
1517 nRet = write (pComponentPrivate->dataPipe[1], &pBuffer,
1518 sizeof (OMX_BUFFERHEADERTYPE*));
1519 if (nRet == -1) {
1520 OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error in Writing to the Data pipe\n", __LINE__);
1521 eError = OMX_ErrorHardware;
1522 goto EXIT;
1523 }
1524
1525 EXIT:
1526 return eError;
1527 }
1528 /*-------------------------------------------------------------------*/
1529 /**
1530 * OMX_ComponentDeinit() this methold will de init the component
1531 *
1532 * @param pComp handle for this instance of the component
1533 *
1534 * @retval OMX_NoError Success, ready to roll
1535 * OMX_Error_BadParameter The input parameter pointer is null
1536 **/
1537 /*-------------------------------------------------------------------*/
1538
ComponentDeInit(OMX_HANDLETYPE pHandle)1539 static OMX_ERRORTYPE ComponentDeInit(OMX_HANDLETYPE pHandle)
1540 {
1541
1542 OMX_ERRORTYPE eError = OMX_ErrorNone;
1543
1544 /* inform audio manager to remove the streamID*/
1545 /* compose the data */
1546 OMX_COMPONENTTYPE *pComponent = (OMX_COMPONENTTYPE *)pHandle;
1547 WMADEC_COMPONENT_PRIVATE *pComponentPrivate =
1548 (WMADEC_COMPONENT_PRIVATE *)pComponent->pComponentPrivate;
1549 struct OMX_TI_Debug dbg;
1550 dbg = pComponentPrivate->dbg;
1551
1552
1553 OMX_PRINT1(dbg, "%d ::ComponentDeInit\n",__LINE__);
1554
1555 #ifdef __PERF_INSTRUMENTATION__
1556 OMX_PRDSP1(dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
1557 PERF_Boundary(pComponentPrivate->pPERF,
1558 PERF_BoundaryStart | PERF_BoundaryCleanup);
1559 #endif
1560
1561 #ifdef DSP_RENDERING_ON
1562 close(fdwrite);
1563 close(fdread);
1564 #endif
1565
1566 #ifdef RESOURCE_MANAGER_ENABLED
1567 eError = RMProxy_NewSendCommand(pHandle, RMProxy_FreeResource,
1568 OMX_WMA_Decoder_COMPONENT, 0, 1234, NULL);
1569 if (eError != OMX_ErrorNone) {
1570 OMX_ERROR4(dbg, "%d ::OMX_AmrDecoder.c :: Error returned from destroy ResourceManagerProxy thread\n",
1571 __LINE__);
1572 }
1573 eError = RMProxy_Deinitalize();
1574 if (eError != OMX_ErrorNone) {
1575 OMX_ERROR4(dbg, "%d ::Error returned from destroy ResourceManagerProxy thread\n",
1576 __LINE__);
1577 }
1578 #endif
1579 OMX_PRINT1(dbg, "%d ::ComponentDeInit\n",__LINE__);
1580 pComponentPrivate->bIsStopping = 1;
1581 eError = WMADEC_StopComponentThread(pHandle);
1582 OMX_PRINT1(dbg, "%d ::ComponentDeInit\n",__LINE__);
1583 /* Wait for thread to exit so we can get the status into "error" */
1584
1585 /* close the pipe handles */
1586 WMADEC_FreeCompResources(pHandle);
1587 OMX_PRINT1(dbg, "%d ::After WMADEC_FreeCompResources\n",__LINE__);
1588 OMX_MEMFREE_STRUCT(pComponentPrivate->pHeaderInfo);
1589 OMX_MEMFREE_STRUCT(pComponentPrivate->pDspDefinition);
1590 OMX_MEMFREE_STRUCT(pComponentPrivate->pInputBufferList);
1591 OMX_MEMFREE_STRUCT(pComponentPrivate->pOutputBufferList);
1592 OMX_MEMFREE_STRUCT(pComponentPrivate->sDeviceString);
1593 OMX_MEMFREE_STRUCT(pComponentPrivate->rcaheader);
1594 #ifdef __PERF_INSTRUMENTATION__
1595 OMX_PRDSP1(dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
1596 PERF_Boundary(pComponentPrivate->pPERF,
1597 PERF_BoundaryComplete | PERF_BoundaryCleanup);
1598 PERF_Done(pComponentPrivate->pPERF);
1599 #endif
1600 OMX_MEMFREE_STRUCT(pComponentPrivate);
1601 OMX_PRINT1(dbg, "%d ::After free(pComponentPrivate)\n",__LINE__);
1602 OMX_DBG_CLOSE(dbg);
1603 return eError;
1604 }
1605
1606 /*-------------------------------------------------------------------*/
1607 /**
1608 * ComponentTunnelRequest() this method is not implemented in 1.5
1609 *
1610 * This method will update application callbacks
1611 * the application.
1612 *
1613 * @param pComp handle for this instance of the component
1614 * @param pCallBacks application callbacks
1615 * @param ptr
1616 *
1617 * @retval OMX_NoError Success, ready to roll
1618 * OMX_Error_BadParameter The input parameter pointer is null
1619 **/
1620 /*-------------------------------------------------------------------*/
1621
ComponentTunnelRequest(OMX_HANDLETYPE hComp,OMX_U32 nPort,OMX_HANDLETYPE hTunneledComp,OMX_U32 nTunneledPort,OMX_TUNNELSETUPTYPE * pTunnelSetup)1622 static OMX_ERRORTYPE ComponentTunnelRequest (OMX_HANDLETYPE hComp,
1623 OMX_U32 nPort, OMX_HANDLETYPE hTunneledComp,
1624 OMX_U32 nTunneledPort,
1625 OMX_TUNNELSETUPTYPE* pTunnelSetup)
1626 {
1627 OMXDBG_PRINT(stderr, PRINT, 1, 0, "===========================Inside the ComponentTunnelRequest==============================\n");
1628 OMX_ERRORTYPE eError = OMX_ErrorNone;
1629 OMXDBG_PRINT(stderr, ERROR, 4, 0, "Inside the ComponentTunnelRequest\n");
1630 eError = OMX_ErrorNotImplemented;
1631 return eError;
1632 }
1633
1634 /*-------------------------------------------------------------------*/
1635 /**
1636 * AllocateBuffer()
1637
1638 * @param pComp handle for this instance of the component
1639 * @param pCallBacks application callbacks
1640 * @param ptr
1641 *
1642 * @retval OMX_NoError Success, ready to roll
1643 * OMX_Error_BadParameter The input parameter pointer is null
1644 **/
1645 /*-------------------------------------------------------------------*/
1646
AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** pBuffer,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes)1647 static OMX_ERRORTYPE AllocateBuffer (OMX_IN OMX_HANDLETYPE hComponent,
1648 OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
1649 OMX_IN OMX_U32 nPortIndex,
1650 OMX_IN OMX_PTR pAppPrivate,
1651 OMX_IN OMX_U32 nSizeBytes)
1652
1653 {
1654 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
1655 WMADEC_COMPONENT_PRIVATE *pComponentPrivate;
1656 OMX_ERRORTYPE eError = OMX_ErrorNone;
1657 OMX_BUFFERHEADERTYPE *pBufferHeader;
1658
1659 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)
1660 (((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
1661
1662 pPortDef = ((WMADEC_COMPONENT_PRIVATE*)
1663 pComponentPrivate)->pPortDef[nPortIndex];
1664
1665 #ifdef _ERROR_PROPAGATION__
1666 if (pComponentPrivate->curState == OMX_StateInvalid){
1667 eError = OMX_ErrorInvalidState;
1668 goto EXIT;
1669 }
1670 #endif
1671
1672 OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: pPortDef = %p\n", __LINE__,pPortDef);
1673 OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: pPortDef->bEnabled = %d\n", __LINE__,pPortDef->bEnabled);
1674
1675 OMX_PRDSP2(pComponentPrivate->dbg, "pPortDef->bEnabled = %d\n", pPortDef->bEnabled);
1676
1677 if(!pPortDef->bEnabled) {
1678 pComponentPrivate->AlloBuf_waitingsignal = 1;
1679 #ifndef UNDER_CE
1680 pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1681 pthread_cond_wait(&pComponentPrivate->AlloBuf_threshold, &pComponentPrivate->AlloBuf_mutex);
1682 pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1683 #else
1684 OMX_WaitForEvent(&(pComponentPrivate->AlloBuf_event));
1685 #endif
1686
1687 }
1688
1689 OMX_MALLOC_GENERIC(pBufferHeader, OMX_BUFFERHEADERTYPE);
1690
1691 memset(pBufferHeader, 0x0, sizeof(OMX_BUFFERHEADERTYPE));
1692
1693 OMX_MALLOC_SIZE_DSPALIGN(pBufferHeader->pBuffer, nSizeBytes, OMX_U8);
1694 if(NULL == pBufferHeader->pBuffer) {
1695 OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: Malloc Failed\n",__LINE__);
1696 if (pBufferHeader) {
1697 OMX_MEMFREE_STRUCT(pBufferHeader);
1698 }
1699 goto EXIT;
1700 }
1701
1702 if (nPortIndex == INPUT_PORT)
1703 {
1704 pBufferHeader->nInputPortIndex = nPortIndex;
1705 pBufferHeader->nOutputPortIndex = -1;
1706 pComponentPrivate->pInputBufferList->pBufHdr[pComponentPrivate->pInputBufferList->numBuffers] = pBufferHeader;
1707 pComponentPrivate->pInputBufferList->bBufferPending[pComponentPrivate->pInputBufferList->numBuffers] = 0;
1708 OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pInputBufferList->pBufHdr[%d] = %p\n",pComponentPrivate->pInputBufferList->numBuffers,pComponentPrivate->pInputBufferList->pBufHdr[pComponentPrivate->pInputBufferList->numBuffers]);
1709 pComponentPrivate->pInputBufferList->bufferOwner[pComponentPrivate->pInputBufferList->numBuffers++] = 1;
1710 OMX_PRBUFFER1(pComponentPrivate->dbg, "Allocate Buffer Line %d\n",__LINE__);
1711 OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pInputBufferList->numBuffers = %d\n",pComponentPrivate->pInputBufferList->numBuffers);
1712 OMX_PRBUFFER1(pComponentPrivate->dbg, "pPortDef->nBufferCountMin = %ld\n",pPortDef->nBufferCountMin);
1713 if (pComponentPrivate->pInputBufferList->numBuffers == pPortDef->nBufferCountActual) {
1714 pPortDef->bPopulated = OMX_TRUE;
1715 }
1716 }
1717 else if (nPortIndex == OUTPUT_PORT) {
1718 pBufferHeader->nInputPortIndex = -1;
1719 pBufferHeader->nOutputPortIndex = nPortIndex;
1720 pComponentPrivate->pOutputBufferList->pBufHdr[pComponentPrivate->pOutputBufferList->numBuffers] = pBufferHeader;
1721 pComponentPrivate->pOutputBufferList->bBufferPending[pComponentPrivate->pOutputBufferList->numBuffers] = 0;
1722 OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pOutputBufferList->pBufHdr[%d] = %p\n",pComponentPrivate->pOutputBufferList->numBuffers,pComponentPrivate->pOutputBufferList->pBufHdr[pComponentPrivate->pOutputBufferList->numBuffers]);
1723 pComponentPrivate->pOutputBufferList->bufferOwner[pComponentPrivate->pOutputBufferList->numBuffers++] = 1;
1724 if (pComponentPrivate->pOutputBufferList->numBuffers == pPortDef->nBufferCountActual) {
1725 pPortDef->bPopulated = OMX_TRUE;
1726 }
1727 }
1728 else {
1729 eError = OMX_ErrorBadPortIndex;
1730 goto EXIT;
1731 }
1732
1733 if((pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated == pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled)&&
1734 (pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated == pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled) &&
1735 (pComponentPrivate->InLoaded_readytoidle))
1736
1737
1738 {
1739 pComponentPrivate->InLoaded_readytoidle = 0;
1740 #ifndef UNDER_CE
1741 pthread_mutex_lock(&pComponentPrivate->InLoaded_mutex);
1742 pthread_cond_signal(&pComponentPrivate->InLoaded_threshold);
1743 pthread_mutex_unlock(&pComponentPrivate->InLoaded_mutex);
1744 #else
1745 OMX_SignalEvent(&(pComponentPrivate->InLoaded_event));
1746 #endif
1747 }
1748
1749
1750 pBufferHeader->pAppPrivate = pAppPrivate;
1751 pBufferHeader->pPlatformPrivate = pComponentPrivate;
1752 pBufferHeader->nAllocLen = nSizeBytes;
1753 pBufferHeader->nVersion.s.nVersionMajor = WMADEC_MAJOR_VER;
1754 pBufferHeader->nVersion.s.nVersionMinor = WMADEC_MINOR_VER;
1755 pComponentPrivate->nVersion = pBufferHeader->nVersion.nVersion;
1756
1757
1758 pBufferHeader->nSize = sizeof(OMX_BUFFERHEADERTYPE);
1759 OMX_PRINT2(pComponentPrivate->dbg, "Line %d\n",__LINE__);
1760 *pBuffer = pBufferHeader;
1761
1762 if (pComponentPrivate->bEnableCommandPending && pPortDef->bPopulated) {
1763 SendCommand (pComponentPrivate->pHandle,
1764 OMX_CommandPortEnable,
1765 pComponentPrivate->bEnableCommandParam,NULL);
1766 }
1767
1768 #ifdef __PERF_INSTRUMENTATION__
1769 OMX_PRDSP1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
1770 PERF_ReceivedBuffer(pComponentPrivate->pPERF,
1771 (*pBuffer)->pBuffer, nSizeBytes,
1772 PERF_ModuleMemory);
1773 #endif
1774
1775 EXIT:
1776 OMX_PRINT1(pComponentPrivate->dbg, "AllocateBuffer returning %d\n",eError);
1777 return eError;
1778 }
1779
1780
1781 /* ================================================================================= */
1782 /**
1783 * @fn FreeBuffer() description for FreeBuffer
1784 FreeBuffer().
1785 Called by the OMX IL client to free a buffer.
1786 *
1787 * @see OMX_Core.h
1788 */
1789 /* ================================================================================ */
FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)1790 static OMX_ERRORTYPE FreeBuffer(
1791 OMX_IN OMX_HANDLETYPE hComponent,
1792 OMX_IN OMX_U32 nPortIndex,
1793 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
1794 {
1795
1796 OMX_ERRORTYPE eError = OMX_ErrorNone;
1797 WMADEC_COMPONENT_PRIVATE * pComponentPrivate = NULL;
1798 OMX_BUFFERHEADERTYPE* buff;
1799 int i;
1800 int inputIndex = -1;
1801 int outputIndex = -1;
1802 OMX_COMPONENTTYPE *pHandle;
1803
1804 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)
1805 (((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
1806
1807 pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
1808 for (i=0; i < MAX_NUM_OF_BUFS; i++) {
1809 buff = pComponentPrivate->pInputBufferList->pBufHdr[i];
1810 if (buff == pBuffer) {
1811 OMX_PRBUFFER2(pComponentPrivate->dbg, "Found matching input buffer\n");
1812 OMX_PRBUFFER2(pComponentPrivate->dbg, "buff = %p\n",buff);
1813 OMX_PRBUFFER2(pComponentPrivate->dbg, "pBuffer = %p\n",pBuffer);
1814 inputIndex = i;
1815 break;
1816 }
1817 else {
1818 OMX_PRBUFFER2(pComponentPrivate->dbg, "This is not a match\n");
1819 OMX_PRBUFFER2(pComponentPrivate->dbg, "buff = %p\n",buff);
1820 OMX_PRBUFFER2(pComponentPrivate->dbg, "pBuffer = %p\n",pBuffer);
1821 }
1822 }
1823
1824 for (i=0; i < MAX_NUM_OF_BUFS; i++) {
1825 buff = pComponentPrivate->pOutputBufferList->pBufHdr[i];
1826 if (buff == pBuffer) {
1827 OMX_PRBUFFER2(pComponentPrivate->dbg, "Found matching output buffer\n");
1828 OMX_PRBUFFER2(pComponentPrivate->dbg, "buff = %p\n",buff);
1829 OMX_PRBUFFER2(pComponentPrivate->dbg, "pBuffer = %p\n",pBuffer);
1830 outputIndex = i;
1831 break;
1832 }
1833 else {
1834 OMX_PRBUFFER2(pComponentPrivate->dbg, "This is not a match\n");
1835 OMX_PRBUFFER2(pComponentPrivate->dbg, "buff = %p\n",buff);
1836 OMX_PRBUFFER2(pComponentPrivate->dbg, "pBuffer = %p\n",pBuffer);
1837 }
1838 }
1839
1840
1841 if (inputIndex != -1) {
1842 if (pComponentPrivate->pInputBufferList->bufferOwner[inputIndex] == 1) {
1843 OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pInputBufferList->pBufHdr[inputIndex]->pBuffer, OMX_U8);
1844 }
1845 #ifdef __PERF_INSTRUMENTATION__
1846 OMX_PRDSP1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
1847 PERF_SendingBuffer(pComponentPrivate->pPERF,
1848 pComponentPrivate->pInputBufferList->pBufHdr[inputIndex]->pBuffer,
1849 pComponentPrivate->pInputBufferList->pBufHdr[inputIndex]->nAllocLen,
1850 PERF_ModuleMemory);
1851 #endif
1852 OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[FREE] %p\n",__LINE__,pComponentPrivate->pInputBufferList->pBufHdr[inputIndex]);
1853 OMX_MEMFREE_STRUCT(pComponentPrivate->pInputBufferList->pBufHdr[inputIndex]);
1854 pComponentPrivate->pInputBufferList->numBuffers--;
1855
1856 if (pComponentPrivate->pInputBufferList->numBuffers <
1857 pComponentPrivate->pPortDef[INPUT_PORT]->nBufferCountMin) {
1858
1859 pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated = OMX_FALSE;
1860 }
1861
1862 if(pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled &&
1863 pComponentPrivate->bLoadedCommandPending == OMX_FALSE &&
1864 (pComponentPrivate->curState == OMX_StateIdle ||
1865 pComponentPrivate->curState == OMX_StateExecuting ||
1866 pComponentPrivate->curState == OMX_StatePause)) {
1867 pComponentPrivate->cbInfo.EventHandler(
1868 pHandle, pHandle->pApplicationPrivate,
1869 OMX_EventError, OMX_ErrorPortUnpopulated,nPortIndex, NULL);
1870 }
1871 }
1872 else if (outputIndex != -1) {
1873 if (pComponentPrivate->pOutputBufferList->bufferOwner[outputIndex] == 1) {
1874 OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pOutputBufferList->pBufHdr[outputIndex]->pBuffer, OMX_U8);
1875 }
1876
1877 #ifdef __PERF_INSTRUMENTATION__
1878 OMX_PRDSP1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
1879 PERF_SendingBuffer(pComponentPrivate->pPERF,
1880 pComponentPrivate->pOutputBufferList->pBufHdr[outputIndex]->pBuffer,
1881 pComponentPrivate->pOutputBufferList->pBufHdr[outputIndex]->nAllocLen,
1882 PERF_ModuleMemory);
1883 #endif
1884
1885 OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[FREE] %p\n",__LINE__,pComponentPrivate->pOutputBufferList->pBufHdr[outputIndex]);
1886 OMX_MEMFREE_STRUCT(pComponentPrivate->pOutputBufferList->pBufHdr[outputIndex]);
1887 pComponentPrivate->pOutputBufferList->numBuffers--;
1888
1889 if (pComponentPrivate->pOutputBufferList->numBuffers <
1890 pComponentPrivate->pPortDef[OUTPUT_PORT]->nBufferCountMin) {
1891 pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated = OMX_FALSE;
1892 }
1893 if(pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled &&
1894 pComponentPrivate->bLoadedCommandPending == OMX_FALSE &&
1895 !pComponentPrivate->reconfigOutputPort &&
1896 (pComponentPrivate->curState == OMX_StateIdle ||
1897 pComponentPrivate->curState == OMX_StateExecuting ||
1898 pComponentPrivate->curState == OMX_StatePause)) {
1899 pComponentPrivate->cbInfo.EventHandler(
1900 pHandle, pHandle->pApplicationPrivate,
1901 OMX_EventError, OMX_ErrorPortUnpopulated,nPortIndex, NULL);
1902 }
1903 }
1904 else {
1905 OMX_ERROR2(pComponentPrivate->dbg, "%d::Returning OMX_ErrorBadParameter\n",__LINE__);
1906 eError = OMX_ErrorBadParameter;
1907 }
1908
1909
1910 if ((!pComponentPrivate->pInputBufferList->numBuffers &&
1911 !pComponentPrivate->pOutputBufferList->numBuffers) &&
1912 pComponentPrivate->InIdle_goingtoloaded)
1913 {
1914 pComponentPrivate->InIdle_goingtoloaded = 0;
1915 #ifndef UNDER_CE
1916 pthread_mutex_lock(&pComponentPrivate->InIdle_mutex);
1917 pthread_cond_signal(&pComponentPrivate->InIdle_threshold);
1918 pthread_mutex_unlock(&pComponentPrivate->InIdle_mutex);
1919 #else
1920 OMX_SignalEvent(&(pComponentPrivate->InIdle_event));
1921 #endif
1922 }
1923
1924 /* Removing sleep() calls. There are no allocated buffers. */
1925 #if 0
1926 if (pComponentPrivate->bDisableCommandPending &&
1927 (pComponentPrivate->pInputBufferList->numBuffers +
1928 pComponentPrivate->pOutputBufferList->numBuffers == 0)) {
1929 if (pComponentPrivate->pInputBufferList->numBuffers +
1930 pComponentPrivate->pOutputBufferList->numBuffers == 0) {
1931 SendCommand (pComponentPrivate->pHandle,OMX_CommandPortDisable,
1932 pComponentPrivate->bDisableCommandParam,NULL);
1933 }
1934 }
1935 #else
1936 if (pComponentPrivate->bDisableCommandPending &&
1937 (pComponentPrivate->pInputBufferList->numBuffers == 0)) {
1938 pComponentPrivate->bDisableCommandPending = OMX_FALSE;
1939 pComponentPrivate->cbInfo.EventHandler( pComponentPrivate->pHandle,
1940 pComponentPrivate->pHandle->pApplicationPrivate,
1941 OMX_EventCmdComplete,
1942 OMX_CommandPortDisable,
1943 INPUT_PORT,
1944 NULL);
1945
1946 }
1947 if (pComponentPrivate->bDisableCommandPending &&
1948 (pComponentPrivate->pOutputBufferList->numBuffers == 0)) {
1949 pComponentPrivate->bDisableCommandPending = OMX_FALSE;
1950 pComponentPrivate->cbInfo.EventHandler( pComponentPrivate->pHandle,
1951 pComponentPrivate->pHandle->pApplicationPrivate,
1952 OMX_EventCmdComplete,
1953 OMX_CommandPortDisable,
1954 OUTPUT_PORT,
1955 NULL);
1956
1957 }
1958
1959 #endif
1960
1961 OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting FreeBuffer\n", __LINE__);
1962 return eError;
1963 }
1964
1965
1966 /* ================================================================================= */
1967 /**
1968 * @fn UseBuffer() description for UseBuffer
1969 UseBuffer().
1970 Called by the OMX IL client to pass a buffer to be used.
1971 *
1972 * @see OMX_Core.h
1973 */
1974 /* ================================================================================ */
UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes,OMX_IN OMX_U8 * pBuffer)1975 static OMX_ERRORTYPE UseBuffer (
1976 OMX_IN OMX_HANDLETYPE hComponent,
1977 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
1978 OMX_IN OMX_U32 nPortIndex,
1979 OMX_IN OMX_PTR pAppPrivate,
1980 OMX_IN OMX_U32 nSizeBytes,
1981 OMX_IN OMX_U8* pBuffer)
1982 {
1983
1984 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
1985 WMADEC_COMPONENT_PRIVATE *pComponentPrivate;
1986 OMX_ERRORTYPE eError = OMX_ErrorNone;
1987 OMX_BUFFERHEADERTYPE *pBufferHeader;
1988
1989 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)
1990 (((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
1991
1992 #ifdef _ERROR_PROPAGATION__
1993 if (pComponentPrivate->curState == OMX_StateInvalid){
1994 eError = OMX_ErrorInvalidState;
1995 goto EXIT;
1996 }
1997
1998 #endif
1999
2000 #ifdef __PERF_INSTRUMENTATION__
2001 OMX_PRDSP1(pComponentPrivate->dbg, "PERF %d :: OMX_WmaDecoder.c\n",__LINE__);
2002 PERF_ReceivedBuffer(pComponentPrivate->pPERF,
2003 pBuffer, nSizeBytes,
2004 PERF_ModuleHLMM);
2005 #endif
2006
2007 pPortDef = ((WMADEC_COMPONENT_PRIVATE*)
2008 pComponentPrivate)->pPortDef[nPortIndex];
2009 if(!pPortDef->bEnabled){
2010 pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
2011 pComponentPrivate->AlloBuf_waitingsignal = 1;
2012 //wait for the port to be enabled before we accept buffers
2013 pthread_cond_wait(&pComponentPrivate->AlloBuf_threshold, &pComponentPrivate->AlloBuf_mutex);
2014 pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
2015 }
2016 OMX_PRCOMM1(pComponentPrivate->dbg, "%d :: pPortDef = %p\n", __LINE__,pPortDef);
2017 OMX_PRCOMM1(pComponentPrivate->dbg, "%d :: pPortDef->bEnabled = %d\n", __LINE__,pPortDef->bEnabled);
2018
2019 OMX_PRINT1(pComponentPrivate->dbg, "Line %d\n",__LINE__);
2020 if(!pPortDef->bEnabled) {
2021 OMX_ERROR4(pComponentPrivate->dbg, "%d :: In AllocateBuffer\n", __LINE__);
2022 eError = OMX_ErrorIncorrectStateOperation;
2023 goto EXIT;
2024 }
2025
2026 OMX_PRINT1(pComponentPrivate->dbg, "Line %d\n",__LINE__);
2027 OMX_PRINT1(pComponentPrivate->dbg, "pPortDef->bPopulated =%d\n",pPortDef->bPopulated);
2028 OMX_PRINT1(pComponentPrivate->dbg, "nSizeBytes =%ld\n",nSizeBytes);
2029 OMX_PRBUFFER1(pComponentPrivate->dbg, "pPortDef->nBufferSize =%ld\n",pPortDef->nBufferSize);
2030
2031 #ifndef UNDER_CE
2032 if(pPortDef->bPopulated) {
2033 eError = OMX_ErrorBadParameter;
2034 goto EXIT;
2035 }
2036 #endif
2037
2038 OMX_PRINT1(pComponentPrivate->dbg, "Line %d\n",__LINE__);
2039 OMX_MALLOC_GENERIC(pBufferHeader, OMX_BUFFERHEADERTYPE);
2040 OMX_PRBUFFER2(pComponentPrivate->dbg, "%d:[ALLOC] %p\n",__LINE__,pBufferHeader);
2041
2042 if (pBufferHeader == 0) {
2043 eError = OMX_ErrorInsufficientResources;
2044 goto EXIT;
2045 }
2046 memset((pBufferHeader), 0x0, sizeof(OMX_BUFFERHEADERTYPE));
2047
2048 OMX_PRINT1(pComponentPrivate->dbg, "Line %d\n",__LINE__);
2049 if (nPortIndex == OUTPUT_PORT) {
2050 pBufferHeader->nInputPortIndex = -1;
2051 pBufferHeader->nOutputPortIndex = nPortIndex;
2052 pComponentPrivate->pOutputBufferList->pBufHdr[pComponentPrivate->pOutputBufferList->numBuffers] = pBufferHeader;
2053 pComponentPrivate->pOutputBufferList->bBufferPending[pComponentPrivate->pOutputBufferList->numBuffers] = 0;
2054 pComponentPrivate->pOutputBufferList->bufferOwner[pComponentPrivate->pOutputBufferList->numBuffers++] = 0;
2055 if (pComponentPrivate->pOutputBufferList->numBuffers == pPortDef->nBufferCountActual) {
2056 pPortDef->bPopulated = OMX_TRUE;
2057 }
2058 }
2059 else {
2060 pBufferHeader->nInputPortIndex = nPortIndex;
2061 pBufferHeader->nOutputPortIndex = -1;
2062 pComponentPrivate->pInputBufferList->pBufHdr[pComponentPrivate->pInputBufferList->numBuffers] = pBufferHeader;
2063 pComponentPrivate->pInputBufferList->bBufferPending[pComponentPrivate->pInputBufferList->numBuffers] = 0;
2064 pComponentPrivate->pInputBufferList->bufferOwner[pComponentPrivate->pInputBufferList->numBuffers++] = 0;
2065 if (pComponentPrivate->pInputBufferList->numBuffers == pPortDef->nBufferCountActual) {
2066 pPortDef->bPopulated = OMX_TRUE;
2067 }
2068 }
2069
2070 if((pComponentPrivate->pPortDef[OUTPUT_PORT]->bPopulated == pComponentPrivate->pPortDef[OUTPUT_PORT]->bEnabled)&&
2071 (pComponentPrivate->pPortDef[INPUT_PORT]->bPopulated == pComponentPrivate->pPortDef[INPUT_PORT]->bEnabled) &&
2072 (pComponentPrivate->InLoaded_readytoidle))
2073 {
2074 pComponentPrivate->InLoaded_readytoidle = 0;
2075 #ifndef UNDER_CE
2076 pthread_mutex_lock(&pComponentPrivate->InLoaded_mutex);
2077 pthread_cond_signal(&pComponentPrivate->InLoaded_threshold);
2078 pthread_mutex_unlock(&pComponentPrivate->InLoaded_mutex);
2079 #else
2080 OMX_SignalEvent(&(pComponentPrivate->InLoaded_event));
2081 #endif
2082 }
2083
2084 OMX_PRINT1(pComponentPrivate->dbg, "Line %d\n",__LINE__);
2085 pBufferHeader->pAppPrivate = pAppPrivate;
2086 pBufferHeader->pPlatformPrivate = pComponentPrivate;
2087 pBufferHeader->nAllocLen = nSizeBytes;
2088 pBufferHeader->nVersion.s.nVersionMajor = WMADEC_MAJOR_VER;
2089 pBufferHeader->nVersion.s.nVersionMinor = WMADEC_MINOR_VER;
2090 pComponentPrivate->nVersion = pBufferHeader->nVersion.nVersion;
2091 pBufferHeader->pBuffer = pBuffer;
2092 pBufferHeader->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2093 OMX_PRINT1(pComponentPrivate->dbg, "Line %d\n",__LINE__);
2094 *ppBufferHdr = pBufferHeader;
2095 OMX_PRBUFFER1(pComponentPrivate->dbg, "pBufferHeader = %p\n",pBufferHeader);
2096 if (pComponentPrivate->bEnableCommandPending && pPortDef->bPopulated){
2097 OMX_PRCOMM2(pComponentPrivate->dbg, "Sending command before exiting usbuffer\n");
2098 SendCommand (pComponentPrivate->pHandle,
2099 OMX_CommandPortEnable,
2100 pComponentPrivate->bEnableCommandParam,NULL);
2101 }
2102 OMX_PRINT1(pComponentPrivate->dbg, "exiting Use buffer\n");
2103 EXIT:
2104 return eError;
2105 }
2106
2107
2108 /* ================================================================================= */
2109 /**
2110 * @fn GetExtensionIndex() description for GetExtensionIndex
2111 GetExtensionIndex().
2112 Returns index for vendor specific settings.
2113 *
2114 * @see OMX_Core.h
2115 */
2116 /* ================================================================================ */
GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_STRING cParameterName,OMX_OUT OMX_INDEXTYPE * pIndexType)2117 static OMX_ERRORTYPE GetExtensionIndex(
2118 OMX_IN OMX_HANDLETYPE hComponent,
2119 OMX_IN OMX_STRING cParameterName,
2120 OMX_OUT OMX_INDEXTYPE* pIndexType)
2121 {
2122
2123 OMX_ERRORTYPE eError = OMX_ErrorNone;
2124
2125 OMXDBG_PRINT(stderr, PRINT, 1, 0, "GetExtensionIndex\n");
2126 if (!(strcmp(cParameterName,"OMX.TI.index.config.wmaheaderinfo"))) {
2127 *pIndexType = OMX_IndexCustomWMADECHeaderInfoConfig;
2128 OMXDBG_PRINT(stderr, DSP, 2, 0, "OMX_IndexCustomWMADECHeaderInfoConfig\n");
2129 }
2130 else if(!(strcmp(cParameterName,"OMX.TI.index.config.wmastreamIDinfo")))
2131 {
2132 *pIndexType = OMX_IndexCustomWmaDecStreamIDConfig;
2133
2134 }
2135 else if(!(strcmp(cParameterName,"OMX.TI.index.config.wmadec.datapath")))
2136 {
2137 *pIndexType = OMX_IndexCustomWmaDecDataPath;
2138 }
2139 else if(!(strcmp(cParameterName,"OMX.TI.WMA.Decode.Debug")))
2140 {
2141 *pIndexType = OMX_IndexCustomDebug;
2142 }
2143 else {
2144 eError = OMX_ErrorBadParameter;
2145 }
2146
2147 OMXDBG_PRINT(stderr, PRINT, 1, 0, "Exiting GetExtensionIndex\n");
2148 return eError;
2149 }
2150
2151 /* ================================================================================= */
2152 /**
2153 * @fn ComponentRoleEnum() description for ComponentRoleEnum()
2154
2155 Returns the role at the given index
2156 *
2157 * @see OMX_Core.h
2158 */
2159 /* ================================================================================ */
ComponentRoleEnum(OMX_IN OMX_HANDLETYPE hComponent,OMX_OUT OMX_U8 * cRole,OMX_IN OMX_U32 nIndex)2160 static OMX_ERRORTYPE ComponentRoleEnum(
2161 OMX_IN OMX_HANDLETYPE hComponent,
2162 OMX_OUT OMX_U8 *cRole,
2163 OMX_IN OMX_U32 nIndex)
2164 {
2165 WMADEC_COMPONENT_PRIVATE *pComponentPrivate;
2166
2167 OMX_ERRORTYPE eError = OMX_ErrorNone;
2168 pComponentPrivate = (WMADEC_COMPONENT_PRIVATE *)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
2169
2170 if(nIndex == 0){
2171 memcpy(cRole, &pComponentPrivate->componentRole.cRole, sizeof(OMX_U8) * OMX_MAX_STRINGNAME_SIZE);
2172 OMX_PRINT1(pComponentPrivate->dbg, "::::In ComponenetRoleEnum: cRole is set to %s\n",cRole);
2173 }
2174 else {
2175 eError = OMX_ErrorNoMore;
2176 }
2177 return eError;
2178 };
2179
2180
2181 #ifdef UNDER_CE
2182 /* ================================================================================= */
2183 /**
2184 * @fns Sleep replace for WIN CE
2185 */
2186 /* ================================================================================ */
OMX_CreateEvent(OMX_Event * event)2187 int OMX_CreateEvent(OMX_Event *event){
2188
2189 int ret = OMX_ErrorNone;
2190 HANDLE createdEvent = NULL;
2191 if(event == NULL){
2192 ret = OMX_ErrorBadParameter;
2193 goto EXIT;
2194 }
2195 event->event = CreateEvent(NULL, TRUE, FALSE, NULL);
2196 if(event->event == NULL)
2197 ret = (int)GetLastError();
2198 EXIT:
2199 return ret;
2200 }
2201
OMX_SignalEvent(OMX_Event * event)2202 int OMX_SignalEvent(OMX_Event *event){
2203
2204 int ret = OMX_ErrorNone;
2205 if(event == NULL){
2206 ret = OMX_ErrorBadParameter;
2207 goto EXIT;
2208 }
2209 SetEvent(event->event);
2210 ret = (int)GetLastError();
2211 EXIT:
2212 return ret;
2213 }
2214
OMX_WaitForEvent(OMX_Event * event)2215 int OMX_WaitForEvent(OMX_Event *event) {
2216
2217 int ret = OMX_ErrorNone;
2218 if(event == NULL){
2219 ret = OMX_ErrorBadParameter;
2220 goto EXIT;
2221 }
2222 WaitForSingleObject(event->event, INFINITE);
2223 ret = (int)GetLastError();
2224 EXIT:
2225 return ret;
2226 }
2227
OMX_DestroyEvent(OMX_Event * event)2228 int OMX_DestroyEvent(OMX_Event *event) {
2229
2230 int ret = OMX_ErrorNone;
2231 if(event == NULL){
2232 ret = OMX_ErrorBadParameter;
2233 goto EXIT;
2234 }
2235 CloseHandle(event->event);
2236 EXIT:
2237 return ret;
2238 }
2239 #endif
2240
2241