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