hardware/ti/omap3/omx/audio/src/openmax_il/wbamr_dec/src/OMX_WbAmrDecoder.c

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