1 /* 2 * Copyright (c) 2010, Texas Instruments Incorporated 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * * Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * * Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * * Neither the name of Texas Instruments Incorporated nor the names of 17 * its contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /** 34 * @file omx_proxy_common.c 35 * This file contains methods that provides the functionality for 36 * the OpenMAX1.1 DOMX Framework OMX Common Proxy . 37 * 38 * @path \WTSD_DucatiMMSW\framework\domx\omx_proxy_common\src 39 * 40 * @rev 1.0 41 */ 42 43 /*============================================================== 44 *! Revision History 45 *! ============================ 46 *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation 47 *! 48 *! 19-August-2009 B Ravi Kiran ravi.kiran (at) ti.com: Initial Version 49 *================================================================*/ 50 51 /* ------compilation control switches ----------------------------------------*/ 52 #define TILER_BUFF 53 #define ALLOCATE_TILER_BUFFER_IN_PROXY 54 // This has been enabled enbled only in Android.mk 55 // #define ENABLE_GRALLOC_BUFFER 56 /****************************************************************** 57 * INCLUDE FILES 58 ******************************************************************/ 59 /* ----- system and platform files ----------------------------*/ 60 #include <string.h> 61 62 #include "timm_osal_memory.h" 63 #include "timm_osal_mutex.h" 64 #include "OMX_TI_Common.h" 65 #include "OMX_TI_Index.h" 66 #include "OMX_TI_Core.h" 67 /*-------program files ----------------------------------------*/ 68 #include "omx_proxy_common.h" 69 #include "omx_rpc.h" 70 #include "omx_rpc_stub.h" 71 #include "omx_rpc_utils.h" 72 #include "OMX_TI_IVCommon.h" 73 #include "profile.h" 74 75 #ifdef ALLOCATE_TILER_BUFFER_IN_PROXY 76 77 #ifdef USE_ION 78 #include <unistd.h> 79 #include <ion/ion.h> 80 #include <sys/ioctl.h> 81 #include <sys/mman.h> 82 #include <sys/eventfd.h> 83 #include <fcntl.h> 84 #include <linux/rpmsg_omx.h> 85 #include <errno.h> 86 #endif 87 88 #endif 89 90 #ifdef ENABLE_GRALLOC_BUFFERS 91 #include "native_handle.h" 92 #include "hal_public.h" 93 #endif 94 95 #ifdef TILER_BUFF 96 #define PortFormatIsNotYUV 0 97 98 static OMX_ERRORTYPE _RPC_IsProxyComponent(OMX_HANDLETYPE hComponent, 99 OMX_BOOL * bIsProxy); 100 OMX_ERRORTYPE RPC_UTIL_GetStride(OMX_COMPONENTTYPE * hRemoteComp, 101 OMX_U32 nPortIndex, OMX_U32 * nStride); 102 OMX_ERRORTYPE RPC_UTIL_GetNumLines(OMX_COMPONENTTYPE * hComp, 103 OMX_U32 nPortIndex, OMX_U32 * nNumOfLines); 104 105 #endif 106 107 #ifdef ALLOCATE_TILER_BUFFER_IN_PROXY 108 109 static OMX_ERRORTYPE PROXY_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent, 110 OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, 111 OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_PTR pAppPrivate, 112 OMX_IN OMX_U32 nSizeBytes, OMX_IN OMX_U8 * pBuffer); 113 #endif 114 115 #define LINUX_PAGE_SIZE 4096 116 #define MAXNAMESIZE 128 117 118 #define CORE_MAX 4 119 #define CORE_CHIRON 3 120 #define CORE_SYSM3 2 121 #define CORE_APPM3 1 122 #define CORE_TESLA 0 123 124 #define MAX_CORENAME_LENGTH 32 125 char Core_Array[][MAX_CORENAME_LENGTH] = 126 { "TESLA", "DUCATI1", "DUCATI0", "CHIRON" }; 127 128 /****************************************************************** 129 * MACROS - LOCAL 130 ******************************************************************/ 131 132 #ifdef USE_ION 133 134 135 RPC_OMX_ERRORTYPE RPC_RegisterBuffer(OMX_HANDLETYPE hRPCCtx, int fd, 136 OMX_PTR *handle1, OMX_PTR *handle2, 137 PROXY_BUFFER_TYPE proxyBufferType) 138 { 139 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 140 int status; 141 RPC_OMX_CONTEXT *pRPCCtx = (RPC_OMX_CONTEXT *) hRPCCtx; 142 143 if ((fd < 0) || (handle1 == NULL) || 144 ((proxyBufferType == GrallocPointers) && (handle2 == NULL))) { 145 eRPCError = RPC_OMX_ErrorBadParameter; 146 goto EXIT; 147 } 148 149 if (proxyBufferType != GrallocPointers) { 150 struct ion_fd_data ion_data; 151 152 ion_data.fd = fd; 153 ion_data.handle = NULL; 154 status = ioctl(pRPCCtx->fd_omx, OMX_IOCIONREGISTER, &ion_data); 155 if (status < 0) { 156 DOMX_ERROR("RegisterBuffer ioctl call failed"); 157 eRPCError = RPC_OMX_ErrorInsufficientResources; 158 goto EXIT; 159 } 160 if (ion_data.handle) 161 *handle1 = ion_data.handle; 162 } else { 163 #ifdef OMX_IOCPVRREGISTER 164 struct omx_pvr_data pvr_data; 165 166 pvr_data.fd = fd; 167 memset(pvr_data.handles, 0x0, sizeof(pvr_data.handles)); 168 status = ioctl(pRPCCtx->fd_omx, OMX_IOCPVRREGISTER, &pvr_data); 169 if (status < 0) { 170 if (errno == ENOTTY) { 171 DOMX_DEBUG("OMX_IOCPVRREGISTER not supported with current kernel version"); 172 } else { 173 DOMX_ERROR("RegisterBuffer ioctl call failed"); 174 eRPCError = RPC_OMX_ErrorInsufficientResources; 175 } 176 goto EXIT; 177 } 178 179 if (pvr_data.handles[0]) 180 *handle1 = pvr_data.handles[0]; 181 if (pvr_data.handles[1]) 182 *handle2 = pvr_data.handles[1]; 183 #endif 184 } 185 186 187 EXIT: 188 return eRPCError; 189 } 190 191 RPC_OMX_ERRORTYPE RPC_UnRegisterBuffer(OMX_HANDLETYPE hRPCCtx, OMX_PTR handle) 192 { 193 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 194 int status; 195 struct ion_fd_data data; 196 RPC_OMX_CONTEXT *pRPCCtx = (RPC_OMX_CONTEXT *) hRPCCtx; 197 198 if (handle == NULL) { 199 eRPCError = RPC_OMX_ErrorBadParameter; 200 goto EXIT; 201 } 202 203 data.handle = handle; 204 status = ioctl(pRPCCtx->fd_omx, OMX_IOCIONUNREGISTER, &data); 205 if (status < 0) { 206 eRPCError = RPC_OMX_ErrorInsufficientResources; 207 goto EXIT; 208 } 209 210 EXIT: 211 return eRPCError; 212 } 213 214 static OMX_ERRORTYPE PROXY_AllocateBufferIonCarveout(PROXY_COMPONENT_PRIVATE *pCompPrv, 215 size_t len, struct ion_handle **handle) 216 { 217 int fd; 218 int ret; 219 struct ion_handle *temp; 220 size_t stride; 221 222 ret = ion_alloc(pCompPrv->ion_fd, len, 0x1000, 1 << ION_HEAP_TYPE_CARVEOUT, &temp); 223 224 if (ret || ((int)temp == -ENOMEM)) { 225 ret = ion_alloc_tiler(pCompPrv->ion_fd, len, 1, TILER_PIXEL_FMT_PAGE, 226 OMAP_ION_HEAP_TILER_MASK, &temp, &stride); 227 } 228 229 if (ret || ((int)temp == -ENOMEM)) { 230 DOMX_ERROR("FAILED to allocate buffer of size=%d. ret=0x%x",len, ret); 231 return OMX_ErrorInsufficientResources; 232 } 233 234 if (ret) 235 return OMX_ErrorInsufficientResources; 236 *handle = temp; 237 return OMX_ErrorNone; 238 } 239 #endif 240 241 /* ===========================================================================*/ 242 /** 243 * @name PROXY_EventHandler() 244 * @brief 245 * @param void 246 * @return OMX_ErrorNone = Successful 247 * @sa TBD 248 * 249 */ 250 /* ===========================================================================*/ 251 OMX_ERRORTYPE PROXY_EventHandler(OMX_HANDLETYPE hComponent, 252 OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2, 253 OMX_PTR pEventData) 254 { 255 OMX_ERRORTYPE eError = OMX_ErrorNone; 256 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 257 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 258 OMX_PTR pTmpData = NULL; 259 260 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 261 262 PROXY_require((hComp->pComponentPrivate != NULL), 263 OMX_ErrorBadParameter, 264 "This is fatal error, processing cant proceed - please debug"); 265 266 DOMX_ENTER 267 ("hComponent=%p, pCompPrv=%p, eEvent=%p, nData1=%p, nData2=%p, pEventData=%p", 268 hComponent, pCompPrv, eEvent, nData1, nData2, pEventData); 269 270 switch (eEvent) 271 { 272 #if 0 // This feature is currently not supported, so kept in if(0) to be supported in the future 273 case OMX_TI_EventBufferRefCount: 274 DOMX_DEBUG("Received Ref Count Event"); 275 /*nData1 will be pBufferHeader, nData2 will be present count. Need to find local 276 buffer header for nData1 which is remote buffer header */ 277 278 PROXY_assert((nData1 != 0), OMX_ErrorBadParameter, 279 "Received NULL buffer header from OMX component"); 280 281 /*find local buffer header equivalent */ 282 for (count = 0; count < pCompPrv->nTotalBuffers; ++count) 283 { 284 if (pCompPrv->tBufList[count].pBufHeaderRemote == 285 nData1) 286 { 287 pLocalBufHdr = 288 pCompPrv->tBufList[count].pBufHeader; 289 pLocalBufHdr->pBuffer = 290 (OMX_U8 *) pCompPrv->tBufList[count]. 291 pBufferActual; 292 break; 293 } 294 } 295 PROXY_assert((count != pCompPrv->nTotalBuffers), 296 OMX_ErrorBadParameter, 297 "Received invalid-buffer header from OMX component"); 298 299 /*update local buffer header */ 300 nData1 = (OMX_U32) pLocalBufHdr; 301 break; 302 #endif 303 case OMX_EventMark: 304 DOMX_DEBUG("Received Mark Event"); 305 PROXY_assert((pEventData != NULL), OMX_ErrorUndefined, 306 "MarkData corrupted"); 307 pTmpData = pEventData; 308 pEventData = 309 ((PROXY_MARK_DATA *) pEventData)->pMarkDataActual; 310 TIMM_OSAL_Free(pTmpData); 311 break; 312 313 default: 314 break; 315 } 316 317 EXIT: 318 if (eError == OMX_ErrorNone) 319 { 320 pCompPrv->tCBFunc.EventHandler(hComponent, 321 pCompPrv->pILAppData, eEvent, nData1, nData2, pEventData); 322 } else if (pCompPrv) 323 { 324 pCompPrv->tCBFunc.EventHandler(hComponent, 325 pCompPrv->pILAppData, OMX_EventError, eError, 0, NULL); 326 } 327 328 DOMX_EXIT("eError: %d", eError); 329 return OMX_ErrorNone; 330 } 331 332 /* ===========================================================================*/ 333 /** 334 * @name PROXY_EmptyBufferDone() 335 * @brief 336 * @param 337 * @return OMX_ErrorNone = Successful 338 * @sa TBD 339 * 340 */ 341 /* ===========================================================================*/ 342 static OMX_ERRORTYPE PROXY_EmptyBufferDone(OMX_HANDLETYPE hComponent, 343 OMX_U32 remoteBufHdr, OMX_U32 nfilledLen, OMX_U32 nOffset, OMX_U32 nFlags) 344 { 345 OMX_ERRORTYPE eError = OMX_ErrorNone; 346 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 347 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 348 OMX_U16 count; 349 OMX_BUFFERHEADERTYPE *pBufHdr = NULL; 350 351 PROXY_require((hComp->pComponentPrivate != NULL), 352 OMX_ErrorBadParameter, 353 "This is fatal error, processing cant proceed - please debug"); 354 355 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 356 357 DOMX_ENTER 358 ("hComponent=%p, pCompPrv=%p, remoteBufHdr=%p, nFilledLen=%d, nOffset=%d, nFlags=%08x", 359 hComponent, pCompPrv, remoteBufHdr, nfilledLen, nOffset, nFlags); 360 361 for (count = 0; count < pCompPrv->nTotalBuffers; ++count) 362 { 363 if (pCompPrv->tBufList[count].pBufHeaderRemote == 364 remoteBufHdr) 365 { 366 pBufHdr = pCompPrv->tBufList[count].pBufHeader; 367 pBufHdr->nFilledLen = nfilledLen; 368 pBufHdr->nOffset = nOffset; 369 pBufHdr->nFlags = nFlags; 370 /* Setting mark info to NULL. This would always be 371 NULL in EBD, whether component has propagated the 372 mark or has generated mark event */ 373 pBufHdr->hMarkTargetComponent = NULL; 374 pBufHdr->pMarkData = NULL; 375 break; 376 } 377 } 378 PROXY_assert((count != pCompPrv->nTotalBuffers), 379 OMX_ErrorBadParameter, 380 "Received invalid-buffer header from OMX component"); 381 382 KPI_OmxCompBufferEvent(KPI_BUFFER_EBD, hComponent, &(pCompPrv->tBufList[count])); 383 384 EXIT: 385 if (eError == OMX_ErrorNone) 386 { 387 pCompPrv->tCBFunc.EmptyBufferDone(hComponent, 388 pCompPrv->pILAppData, pBufHdr); 389 } else if (pCompPrv) 390 { 391 pCompPrv->tCBFunc.EventHandler(hComponent, 392 pCompPrv->pILAppData, OMX_EventError, eError, 0, NULL); 393 } 394 395 DOMX_EXIT("eError: %d", eError); 396 return OMX_ErrorNone; 397 } 398 399 /* ===========================================================================*/ 400 /** 401 * @name PROXY_FillBufferDone() 402 * @brief 403 * @param 404 * @return OMX_ErrorNone = Successful 405 * @sa TBD 406 * 407 */ 408 /* ===========================================================================*/ 409 OMX_ERRORTYPE PROXY_FillBufferDone(OMX_HANDLETYPE hComponent, 410 OMX_U32 remoteBufHdr, OMX_U32 nfilledLen, OMX_U32 nOffset, OMX_U32 nFlags, 411 OMX_TICKS nTimeStamp, OMX_HANDLETYPE hMarkTargetComponent, 412 OMX_PTR pMarkData) 413 { 414 415 OMX_ERRORTYPE eError = OMX_ErrorNone; 416 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 417 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 418 OMX_U16 count; 419 OMX_BUFFERHEADERTYPE *pBufHdr = NULL; 420 421 PROXY_require((hComp->pComponentPrivate != NULL), 422 OMX_ErrorBadParameter, 423 "This is fatal error, processing cant proceed - please debug"); 424 425 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 426 427 DOMX_ENTER 428 ("hComponent=%p, pCompPrv=%p, remoteBufHdr=%p, nFilledLen=%d, nOffset=%d, nFlags=%08x", 429 hComponent, pCompPrv, remoteBufHdr, nfilledLen, nOffset, nFlags); 430 431 for (count = 0; count < pCompPrv->nTotalBuffers; ++count) 432 { 433 if (pCompPrv->tBufList[count].pBufHeaderRemote == 434 remoteBufHdr) 435 { 436 pBufHdr = pCompPrv->tBufList[count].pBufHeader; 437 pBufHdr->nFilledLen = nfilledLen; 438 pBufHdr->nOffset = nOffset; 439 pBufHdr->nFlags = nFlags; 440 pBufHdr->nTimeStamp = nTimeStamp; 441 if (pMarkData != NULL) 442 { 443 /*Update mark info in the buffer header */ 444 pBufHdr->pMarkData = 445 ((PROXY_MARK_DATA *) 446 pMarkData)->pMarkDataActual; 447 pBufHdr->hMarkTargetComponent = 448 ((PROXY_MARK_DATA *) 449 pMarkData)->hComponentActual; 450 TIMM_OSAL_Free(pMarkData); 451 } 452 break; 453 } 454 } 455 PROXY_assert((count != pCompPrv->nTotalBuffers), 456 OMX_ErrorBadParameter, 457 "Received invalid-buffer header from OMX component"); 458 459 KPI_OmxCompBufferEvent(KPI_BUFFER_FBD, hComponent, &(pCompPrv->tBufList[count])); 460 461 EXIT: 462 if (eError == OMX_ErrorNone) 463 { 464 pCompPrv->tCBFunc.FillBufferDone(hComponent, 465 pCompPrv->pILAppData, pBufHdr); 466 } else if (pCompPrv) 467 { 468 pCompPrv->tCBFunc.EventHandler(hComponent, 469 pCompPrv->pILAppData, OMX_EventError, eError, 0, NULL); 470 } 471 472 DOMX_EXIT("eError: %d", eError); 473 return OMX_ErrorNone; 474 } 475 476 /* ===========================================================================*/ 477 /** 478 * @name PROXY_EmptyThisBuffer() 479 * @brief 480 * @param void 481 * @return OMX_ErrorNone = Successful 482 * @sa TBD 483 * 484 */ 485 /* ===========================================================================*/ 486 OMX_ERRORTYPE PROXY_EmptyThisBuffer(OMX_HANDLETYPE hComponent, 487 OMX_BUFFERHEADERTYPE * pBufferHdr) 488 { 489 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 490 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 491 PROXY_COMPONENT_PRIVATE *pCompPrv; 492 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 493 OMX_U32 count = 0; 494 OMX_COMPONENTTYPE *pMarkComp = NULL; 495 PROXY_COMPONENT_PRIVATE *pMarkCompPrv = NULL; 496 OMX_PTR pMarkData = NULL; 497 OMX_BOOL bFreeMarkIfError = OMX_FALSE; 498 OMX_BOOL bIsProxy = OMX_FALSE , bMapBuffer; 499 500 PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL); 501 PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter, 502 NULL); 503 PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE); 504 505 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 506 507 DOMX_ENTER 508 ("hComponent=%p, pCompPrv=%p, nFilledLen=%d, nOffset=%d, nFlags=%08x", 509 hComponent, pCompPrv, pBufferHdr->nFilledLen, 510 pBufferHdr->nOffset, pBufferHdr->nFlags); 511 512 /*First find the index of this buffer header to retrieve remote buffer header */ 513 for (count = 0; count < pCompPrv->nTotalBuffers; count++) 514 { 515 if (pCompPrv->tBufList[count].pBufHeader == pBufferHdr) 516 { 517 DOMX_DEBUG("Buffer Index of Match %d ", count); 518 break; 519 } 520 } 521 PROXY_assert((count != pCompPrv->nTotalBuffers), 522 OMX_ErrorBadParameter, 523 "Could not find the remote header in buffer list"); 524 525 if (pBufferHdr->hMarkTargetComponent != NULL) 526 { 527 pMarkComp = 528 (OMX_COMPONENTTYPE *) (pBufferHdr->hMarkTargetComponent); 529 /* Check is mark comp is proxy */ 530 eError = _RPC_IsProxyComponent(pMarkComp, &bIsProxy); 531 PROXY_assert(eError == OMX_ErrorNone, eError, ""); 532 533 /*Replacing original mark data with proxy specific structure */ 534 pMarkData = pBufferHdr->pMarkData; 535 pBufferHdr->pMarkData = 536 TIMM_OSAL_Malloc(sizeof(PROXY_MARK_DATA), TIMM_OSAL_TRUE, 537 0, TIMMOSAL_MEM_SEGMENT_INT); 538 PROXY_assert(pBufferHdr->pMarkData != NULL, 539 OMX_ErrorInsufficientResources, "Malloc failed"); 540 bFreeMarkIfError = OMX_TRUE; 541 ((PROXY_MARK_DATA *) (pBufferHdr-> 542 pMarkData))->hComponentActual = pMarkComp; 543 ((PROXY_MARK_DATA *) (pBufferHdr-> 544 pMarkData))->pMarkDataActual = pMarkData; 545 546 /* If proxy comp then replace hMarkTargetComponent with remote 547 handle */ 548 if (bIsProxy) 549 { 550 pMarkCompPrv = pMarkComp->pComponentPrivate; 551 PROXY_assert(pMarkCompPrv != NULL, 552 OMX_ErrorBadParameter, NULL); 553 554 /* Replacing with remote component handle */ 555 pBufferHdr->hMarkTargetComponent = 556 ((RPC_OMX_CONTEXT *) pMarkCompPrv->hRemoteComp)-> 557 hActualRemoteCompHandle; 558 } 559 } 560 561 bMapBuffer = 562 pCompPrv->proxyPortBuffers[pBufferHdr->nInputPortIndex].proxyBufferType == 563 EncoderMetadataPointers; 564 565 KPI_OmxCompBufferEvent(KPI_BUFFER_ETB, hComponent, &(pCompPrv->tBufList[count])); 566 567 eRPCError = 568 RPC_EmptyThisBuffer(pCompPrv->hRemoteComp, pBufferHdr, 569 pCompPrv->tBufList[count].pBufHeaderRemote, &eCompReturn,bMapBuffer); 570 571 PROXY_checkRpcError(); 572 573 EXIT: 574 /*If ETB is about to return an error then this means that buffer has not 575 been accepted by the component. Thus the allocated mark data will be 576 lost so free it here. Also replace original mark data in the header */ 577 if ((eError != OMX_ErrorNone) && bFreeMarkIfError) 578 { 579 pBufferHdr->hMarkTargetComponent = 580 ((PROXY_MARK_DATA *) (pBufferHdr-> 581 pMarkData))->hComponentActual; 582 pMarkData = 583 ((PROXY_MARK_DATA *) (pBufferHdr-> 584 pMarkData))->pMarkDataActual; 585 TIMM_OSAL_Free(pBufferHdr->pMarkData); 586 pBufferHdr->pMarkData = pMarkData; 587 } 588 589 DOMX_EXIT("eError: %d", eError); 590 return eError; 591 } 592 593 594 /* ===========================================================================*/ 595 /** 596 * @name PROXY_FillThisBuffer() 597 * @brief 598 * @param void 599 * @return OMX_ErrorNone = Successful 600 * @sa TBD 601 * 602 */ 603 /* ===========================================================================*/ 604 OMX_ERRORTYPE PROXY_FillThisBuffer(OMX_HANDLETYPE hComponent, 605 OMX_BUFFERHEADERTYPE * pBufferHdr) 606 { 607 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 608 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 609 PROXY_COMPONENT_PRIVATE *pCompPrv; 610 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 611 OMX_U32 count = 0; 612 613 PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL); 614 PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter, 615 NULL); 616 PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE); 617 618 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 619 620 DOMX_ENTER 621 ("hComponent = %p, pCompPrv = %p, nFilledLen = %d, nOffset = %d, nFlags = %08x", 622 hComponent, pCompPrv, pBufferHdr->nFilledLen, 623 pBufferHdr->nOffset, pBufferHdr->nFlags); 624 625 /*First find the index of this buffer header to retrieve remote buffer header */ 626 for (count = 0; count < pCompPrv->nTotalBuffers; count++) 627 { 628 if (pCompPrv->tBufList[count].pBufHeader == pBufferHdr) 629 { 630 DOMX_DEBUG("Buffer Index of Match %d ", count); 631 break; 632 } 633 } 634 PROXY_assert((count != pCompPrv->nTotalBuffers), 635 OMX_ErrorBadParameter, 636 "Could not find the remote header in buffer list"); 637 638 KPI_OmxCompBufferEvent(KPI_BUFFER_FTB, hComponent, &(pCompPrv->tBufList[count])); 639 640 eRPCError = RPC_FillThisBuffer(pCompPrv->hRemoteComp, pBufferHdr, 641 pCompPrv->tBufList[count].pBufHeaderRemote, &eCompReturn); 642 643 PROXY_checkRpcError(); 644 645 EXIT: 646 DOMX_EXIT("eError: %d", eError); 647 return eError; 648 } 649 650 651 /* ===========================================================================*/ 652 /** 653 * @name PROXY_AllocateBuffer() 654 * @brief 655 * @param void 656 * @return OMX_ErrorNone = Successful 657 * @sa TBD 658 * 659 */ 660 /* ===========================================================================*/ 661 OMX_ERRORTYPE PROXY_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent, 662 OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, 663 OMX_IN OMX_U32 nPortIndex, 664 OMX_IN OMX_PTR pAppPrivate, OMX_IN OMX_U32 nSizeBytes) 665 { 666 OMX_ERRORTYPE eError = OMX_ErrorNone; 667 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 668 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 669 OMX_U32 currentBuffer = 0, i = 0; 670 OMX_BOOL bSlotFound = OMX_FALSE; 671 #ifdef USE_ION 672 struct ion_handle *handle = NULL; 673 OMX_PTR pIonMappedBuffer = NULL; 674 #endif 675 676 #ifdef ALLOCATE_TILER_BUFFER_IN_PROXY 677 // Do the tiler allocations in Proxy and call use buffers on Ducati. 678 679 //Round Off the size to allocate and map to next page boundary. 680 OMX_U32 nSize = (nSizeBytes + LINUX_PAGE_SIZE - 1) & ~(LINUX_PAGE_SIZE - 1); 681 OMX_U32 nStride = 0; 682 OMX_U8* pMemptr = NULL; 683 OMX_CONFIG_RECTTYPE tParamRect; 684 OMX_PARAM_PORTDEFINITIONTYPE tParamPortDef; 685 686 PROXY_require((hComp->pComponentPrivate != NULL), 687 OMX_ErrorBadParameter, NULL); 688 PROXY_require(ppBufferHdr != NULL, OMX_ErrorBadParameter, 689 "Pointer to buffer header is NULL"); 690 691 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 692 693 DOMX_ENTER 694 ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pAppPrivate = %p, nSizeBytes = %d", 695 hComponent, pCompPrv, nPortIndex, pAppPrivate, nSizeBytes); 696 697 /*Pick up 1st empty slot */ 698 /*The same empty spot will be picked up by the subsequent 699 Use buffer call to fill in the corresponding buffer 700 Buffer header in the list */ 701 702 bSlotFound = OMX_FALSE; 703 for (i = 0; i < pCompPrv->nTotalBuffers; i++) 704 { 705 if (pCompPrv->tBufList[i].pBufHeader == NULL) 706 { 707 currentBuffer = i; 708 bSlotFound = OMX_TRUE; 709 break; 710 } 711 } 712 713 if (bSlotFound == OMX_FALSE) 714 { 715 currentBuffer = pCompPrv->nTotalBuffers; 716 } 717 718 /*To find whether buffer is 2D or 1D */ 719 eError = 720 RPC_UTIL_GetStride(pCompPrv->hRemoteComp, nPortIndex, &nStride); 721 PROXY_assert(eError == OMX_ErrorNone, eError, 722 "Failed to get stride of component"); 723 724 if (nStride == LINUX_PAGE_SIZE && \ 725 pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType != EncoderMetadataPointers) //Allocate 2D buffer 726 { 727 #if USE_ION 728 DOMX_ERROR ("Tiler 2d port buffers not implemented"); 729 eError = OMX_ErrorNotImplemented; 730 goto EXIT; 731 #endif 732 } 733 #ifdef USE_ION 734 else if (pCompPrv->bUseIon == OMX_TRUE) 735 { 736 eError = PROXY_AllocateBufferIonCarveout(pCompPrv, nSize, &handle); 737 pCompPrv->tBufList[currentBuffer].pYBuffer = handle; 738 if (pCompPrv->bMapIonBuffers == OMX_TRUE) 739 { 740 DOMX_DEBUG("before mapping, handle = %x, nSize = %d",handle,nSize); 741 if (ion_map(pCompPrv->ion_fd, handle, nSize, PROT_READ | PROT_WRITE, MAP_SHARED, 0, 742 &pIonMappedBuffer, &(pCompPrv->tBufList[currentBuffer].mmap_fd)) < 0) 743 { 744 DOMX_ERROR("userspace mapping of ION buffers returned error"); 745 eError = OMX_ErrorInsufficientResources; 746 goto EXIT; 747 } 748 } else { 749 if (ion_share(pCompPrv->ion_fd, handle, &(pCompPrv->tBufList[currentBuffer].mmap_fd)) < 0) { 750 DOMX_ERROR("ion_share failed !!! \n"); 751 goto EXIT; 752 } else { 753 DOMX_DEBUG("ion_share success pMemptr: 0x%x \n", pCompPrv->tBufList[currentBuffer].mmap_fd); 754 } 755 } 756 pMemptr = pCompPrv->tBufList[currentBuffer].mmap_fd; 757 DOMX_DEBUG ("Ion handle recieved = %x",handle); 758 if (eError != OMX_ErrorNone) 759 goto EXIT; 760 } 761 #endif 762 763 /*No need to increment Allocated buffers here. 764 It will be done in the subsequent use buffer call below*/ 765 eError = PROXY_UseBuffer(hComponent, ppBufferHdr, nPortIndex, pAppPrivate, nSize, pMemptr); 766 767 if(eError != OMX_ErrorNone) { 768 DOMX_ERROR("PROXY_UseBuffer in PROXY_AllocateBuffer failed with error %d (0x%08x)", eError, eError); 769 #ifdef USE_ION 770 ion_free(pCompPrv->ion_fd, 771 (struct ion_handle *)pCompPrv->tBufList[currentBuffer].pYBuffer); 772 close(pCompPrv->tBufList[currentBuffer].mmap_fd); 773 #endif 774 goto EXIT; 775 } 776 else { 777 #ifndef USE_ION 778 pCompPrv->tBufList[currentBuffer].pYBuffer = pMemptr; 779 #endif 780 } 781 782 #ifdef USE_ION 783 if (pCompPrv->bUseIon == OMX_TRUE && pCompPrv->bMapIonBuffers == OMX_TRUE) 784 { 785 DOMX_DEBUG("before mapping, handle = %x, nSize = %d",handle,nSize); 786 (*ppBufferHdr)->pBuffer = pIonMappedBuffer; 787 } else { 788 (*ppBufferHdr)->pBuffer = (OMX_U8 *)handle; 789 } 790 #endif 791 792 #else 793 //This code is the un-changed version of original implementation. 794 OMX_BUFFERHEADERTYPE *pBufferHeader = NULL; 795 OMX_U32 pBufHeaderRemote = 0; 796 OMX_U32 currentBuffer = 0, i = 0; 797 OMX_U8 *pBuffer = NULL; 798 OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL; 799 OMX_BOOL bSlotFound = OMX_FALSE; 800 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 801 OMX_ERRORTYPE eCompReturn = OMX_ErrorNone; 802 803 PROXY_require((hComp->pComponentPrivate != NULL), 804 OMX_ErrorBadParameter, NULL); 805 PROXY_require(ppBufferHdr != NULL, OMX_ErrorBadParameter, 806 "Pointer to buffer header is NULL"); 807 808 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 809 810 DOMX_ENTER 811 ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pAppPrivate = %p, nSizeBytes = %d", 812 hComponent, pCompPrv, nPortIndex, pAppPrivate, nSizeBytes); 813 814 /*Pick up 1st empty slot */ 815 for (i = 0; i < pCompPrv->nTotalBuffers; i++) 816 { 817 if (pCompPrv->tBufList[i].pBufHeader == 0) 818 { 819 currentBuffer = i; 820 bSlotFound = OMX_TRUE; 821 break; 822 } 823 } 824 if (!bSlotFound) 825 { 826 currentBuffer = pCompPrv->nTotalBuffers; 827 } 828 829 DOMX_DEBUG("In AB, no. of buffers = %d", pCompPrv->nTotalBuffers); 830 PROXY_assert((pCompPrv->nTotalBuffers < MAX_NUM_PROXY_BUFFERS), 831 OMX_ErrorInsufficientResources, 832 "Proxy cannot handle more than MAX buffers"); 833 834 //Allocating Local bufferheader to be maintained locally within proxy 835 pBufferHeader = 836 (OMX_BUFFERHEADERTYPE *) 837 TIMM_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE), TIMM_OSAL_TRUE, 0, 838 TIMMOSAL_MEM_SEGMENT_INT); 839 PROXY_assert((pBufferHeader != NULL), OMX_ErrorInsufficientResources, 840 "Allocation of Buffer Header structure failed"); 841 842 pPlatformPrivate = 843 (OMX_TI_PLATFORMPRIVATE *) 844 TIMM_OSAL_Malloc(sizeof(OMX_TI_PLATFORMPRIVATE), TIMM_OSAL_TRUE, 845 0, TIMMOSAL_MEM_SEGMENT_INT); 846 PROXY_assert(pPlatformPrivate != NULL, OMX_ErrorInsufficientResources, 847 "Allocation of platform private structure failed"); 848 pBufferHeader->pPlatformPrivate = pPlatformPrivate; 849 850 DOMX_DEBUG(" Calling RPC "); 851 852 eRPCError = 853 RPC_AllocateBuffer(pCompPrv->hRemoteComp, &pBufferHeader, 854 nPortIndex, &pBufHeaderRemote, pAppPrivate, nSizeBytes, 855 &eCompReturn); 856 857 PROXY_checkRpcError(); 858 859 DOMX_DEBUG("Allocate Buffer Successful"); 860 DOMX_DEBUG("Value of pBufHeaderRemote: %p LocalBufferHdr :%p", 861 pBufHeaderRemote, pBufferHeader); 862 863 pCompPrv->tBufList[currentBuffer].pBufHeader = pBufferHeader; 864 pCompPrv->tBufList[currentBuffer].pBufHeaderRemote = pBufHeaderRemote; 865 866 867 //keeping track of number of Buffers 868 pCompPrv->nAllocatedBuffers++; 869 870 if (pCompPrv->nTotalBuffers < pCompPrv->nAllocatedBuffers) 871 { 872 pCompPrv->nTotalBuffers = pCompPrv->nAllocatedBuffers; 873 } 874 875 *ppBufferHdr = pBufferHeader; 876 877 EXIT: 878 if (eError != OMX_ErrorNone) 879 { 880 if (pPlatformPrivate) 881 TIMM_OSAL_Free(pPlatformPrivate); 882 if (pBufferHeader) 883 TIMM_OSAL_Free(pBufferHeader); 884 } 885 DOMX_EXIT("eError: %d", eError); 886 return eError; 887 #endif //ALLOCATE_TILER_BUFFER_IN_PROXY 888 889 EXIT: 890 DOMX_EXIT("eError: %d", eError); 891 return eError; 892 } 893 894 895 /* ===========================================================================*/ 896 /** 897 * @name PROXY_UseBuffer() 898 * @brief 899 * @param void 900 * @return OMX_ErrorNone = Successful 901 * @sa TBD 902 * 903 */ 904 /* ===========================================================================*/ 905 static OMX_ERRORTYPE PROXY_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent, 906 OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, 907 OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_PTR pAppPrivate, 908 OMX_IN OMX_U32 nSizeBytes, OMX_IN OMX_U8 * pBuffer) 909 { 910 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 911 OMX_BUFFERHEADERTYPE *pBufferHeader = NULL; 912 OMX_U32 pBufHeaderRemote = 0; 913 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 914 OMX_U32 currentBuffer = 0, i = 0, nStride = 0, nNumLines = 0; 915 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 916 OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL; 917 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 918 OMX_BOOL bSlotFound = OMX_FALSE; 919 OMX_PTR pAuxBuf0 = pBuffer; 920 OMX_PTR pMappedMetaDataBuffer = NULL; 921 OMX_TI_PARAM_METADATABUFFERINFO tMetaDataBuffer; 922 OMX_U32 nBufferHeight = 0; 923 OMX_CONFIG_RECTTYPE tParamRect; 924 OMX_PARAM_PORTDEFINITIONTYPE tParamPortDef; 925 926 #ifdef USE_ION 927 OMX_PTR pMetadataBuffer = NULL; 928 #endif 929 930 PROXY_require((hComp->pComponentPrivate != NULL), 931 OMX_ErrorBadParameter, NULL); 932 PROXY_require(pBuffer != NULL, OMX_ErrorBadParameter, "Pointer to buffer is NULL"); 933 PROXY_require(ppBufferHdr != NULL, OMX_ErrorBadParameter, 934 "Pointer to buffer header is NULL"); 935 936 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 937 938 DOMX_ENTER 939 ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pAppPrivate = %p, nSizeBytes = %d, pBuffer = %p", 940 hComponent, pCompPrv, nPortIndex, pAppPrivate, nSizeBytes, 941 pBuffer); 942 943 /*Pick up 1st empty slot */ 944 for (i = 0; i < pCompPrv->nTotalBuffers; i++) 945 { 946 if (pCompPrv->tBufList[i].pBufHeader == 0) 947 { 948 currentBuffer = i; 949 bSlotFound = OMX_TRUE; 950 break; 951 } 952 } 953 if (!bSlotFound) 954 { 955 currentBuffer = pCompPrv->nTotalBuffers; 956 } 957 DOMX_DEBUG("In UB, no. of buffers = %d", pCompPrv->nTotalBuffers); 958 959 PROXY_assert((pCompPrv->nTotalBuffers < MAX_NUM_PROXY_BUFFERS), 960 OMX_ErrorInsufficientResources, 961 "Proxy cannot handle more than MAX buffers"); 962 963 //Allocating Local bufferheader to be maintained locally within proxy 964 pBufferHeader = 965 (OMX_BUFFERHEADERTYPE *) 966 TIMM_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE), TIMM_OSAL_TRUE, 0, 967 TIMMOSAL_MEM_SEGMENT_INT); 968 PROXY_assert((pBufferHeader != NULL), OMX_ErrorInsufficientResources, 969 "Allocation of Buffer Header structure failed"); 970 971 pPlatformPrivate = 972 (OMX_TI_PLATFORMPRIVATE *) 973 TIMM_OSAL_Malloc(sizeof(OMX_TI_PLATFORMPRIVATE), TIMM_OSAL_TRUE, 974 0, TIMMOSAL_MEM_SEGMENT_INT); 975 PROXY_assert(pPlatformPrivate != NULL, OMX_ErrorInsufficientResources, 976 "Allocation of platform private structure failed"); 977 TIMM_OSAL_Memset(pPlatformPrivate, 0, sizeof(OMX_TI_PLATFORMPRIVATE)); 978 979 pBufferHeader->pPlatformPrivate = pPlatformPrivate; 980 ((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->nSize = sizeof(OMX_TI_PLATFORMPRIVATE); 981 982 #ifdef ENABLE_GRALLOC_BUFFERS 983 984 if(pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == GrallocPointers) 985 { 986 //Extracting buffer pointer from the gralloc buffer 987 pAuxBuf0 = (OMX_U8 *)(((IMG_native_handle_t*)pBuffer)->fd[0]); 988 } 989 #endif 990 991 DOMX_DEBUG("Preparing buffer to Remote Core..."); 992 pBufferHeader->pBuffer = pBuffer; 993 /*To find whether buffer is 2D or 1D */ 994 eError = 995 RPC_UTIL_GetStride(pCompPrv->hRemoteComp, nPortIndex, &nStride); 996 PROXY_assert(eError == OMX_ErrorNone, eError, 997 "Failed to get stride of component"); 998 if (nStride == LINUX_PAGE_SIZE) 999 { 1000 // Change this to extract UV pointer from gralloc handle once new gralloc interface is available 1001 /*2D buffer, assume NV12 format */ 1002 eError = 1003 RPC_UTIL_GetNumLines(pCompPrv->hRemoteComp, nPortIndex, 1004 &nNumLines); 1005 PROXY_assert(eError == OMX_ErrorNone, eError, 1006 "Failed to get num of lines"); 1007 1008 if(pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == GrallocPointers) 1009 { 1010 ((OMX_TI_PLATFORMPRIVATE *) pBufferHeader->pPlatformPrivate)-> 1011 pAuxBuf1 = (OMX_U8 *)(((IMG_native_handle_t*)pBuffer)->fd[1]); 1012 } 1013 1014 if(pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == EncoderMetadataPointers) 1015 { 1016 ((OMX_TI_PLATFORMPRIVATE *) pBufferHeader->pPlatformPrivate)-> 1017 pAuxBuf1 = NULL; 1018 } 1019 if(pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == BufferDescriptorVirtual2D) 1020 { 1021 pAuxBuf0 = (OMX_U8 *)(((OMX_TI_BUFFERDESCRIPTOR_TYPE*)pBuffer)->pBuf[0]); 1022 1023 ((OMX_TI_PLATFORMPRIVATE *) pBufferHeader->pPlatformPrivate)-> 1024 pAuxBuf1 = (OMX_U8 *)(((OMX_TI_BUFFERDESCRIPTOR_TYPE*)pBuffer)->pBuf[1]); 1025 } 1026 } 1027 1028 /*Initializing Structure */ 1029 tMetaDataBuffer.nSize = sizeof(OMX_TI_PARAM_METADATABUFFERINFO); 1030 tMetaDataBuffer.nVersion.s.nVersionMajor = OMX_VER_MAJOR; 1031 tMetaDataBuffer.nVersion.s.nVersionMinor = OMX_VER_MINOR; 1032 tMetaDataBuffer.nVersion.s.nRevision = 0x0; 1033 tMetaDataBuffer.nVersion.s.nStep = 0x0; 1034 tMetaDataBuffer.nPortIndex = nPortIndex; 1035 eError = PROXY_GetParameter(hComponent, (OMX_INDEXTYPE)OMX_TI_IndexParamMetaDataBufferInfo, (OMX_PTR)&tMetaDataBuffer); 1036 PROXY_assert(eError == OMX_ErrorNone, eError, 1037 "Get Parameter for Metadata infor failed"); 1038 1039 DOMX_DEBUG("Metadata size = %d",tMetaDataBuffer.nMetaDataSize); 1040 1041 if(tMetaDataBuffer.bIsMetaDataEnabledOnPort) 1042 { 1043 #ifdef USE_ION 1044 ((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->nMetaDataSize = 1045 (tMetaDataBuffer.nMetaDataSize + LINUX_PAGE_SIZE - 1) & ~(LINUX_PAGE_SIZE -1); 1046 eError = PROXY_AllocateBufferIonCarveout(pCompPrv, ((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->nMetaDataSize, 1047 (struct ion_handle **)(&(((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->pMetaDataBuffer))); 1048 pCompPrv->tBufList[currentBuffer].pMetaDataBuffer = ((OMX_TI_PLATFORMPRIVATE *)pBufferHeader-> 1049 pPlatformPrivate)->pMetaDataBuffer; 1050 DOMX_DEBUG("Metadata buffer ion handle = %d",((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->pMetaDataBuffer); 1051 if (pCompPrv->bMapIonBuffers == OMX_TRUE) { 1052 if (ion_map(pCompPrv->ion_fd, pPlatformPrivate->pMetaDataBuffer, 1053 pPlatformPrivate->nMetaDataSize, 1054 PROT_READ | PROT_WRITE, MAP_SHARED, 0, 1055 &pMetadataBuffer, 1056 &(pCompPrv->tBufList[currentBuffer].mmap_fd_metadata_buff)) < 0) 1057 { 1058 DOMX_ERROR("userspace mapping of ION metadata buffers returned error"); 1059 eError = OMX_ErrorInsufficientResources; 1060 goto EXIT; 1061 } 1062 } 1063 #endif 1064 } 1065 1066 #ifdef USE_ION 1067 { 1068 // Need to register buffers when using ion and rpmsg 1069 eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, pAuxBuf0, 1070 &pCompPrv->tBufList[currentBuffer].pRegisteredAufBux0, 1071 &pCompPrv->tBufList[currentBuffer].pRegisteredAufBux1, 1072 pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType); 1073 PROXY_checkRpcError(); 1074 if (pCompPrv->tBufList[currentBuffer].pRegisteredAufBux0) 1075 pAuxBuf0 = pCompPrv->tBufList[currentBuffer].pRegisteredAufBux0; 1076 if (pCompPrv->tBufList[currentBuffer].pRegisteredAufBux1) 1077 pPlatformPrivate->pAuxBuf1 = pCompPrv->tBufList[currentBuffer].pRegisteredAufBux1; 1078 1079 if (pPlatformPrivate->pMetaDataBuffer != NULL) 1080 { 1081 int fd = -1; 1082 if (pCompPrv->bMapIonBuffers == OMX_TRUE) { 1083 fd = pCompPrv->tBufList[currentBuffer].mmap_fd_metadata_buff; 1084 } else { 1085 ion_share (pCompPrv->ion_fd, pPlatformPrivate->pMetaDataBuffer, &fd); 1086 pCompPrv->tBufList[currentBuffer].mmap_fd_metadata_buff = fd; 1087 } 1088 eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, fd, 1089 &pCompPrv->tBufList[currentBuffer].pRegisteredAufBux2, NULL, IONPointers); 1090 PROXY_checkRpcError(); 1091 if (pCompPrv->tBufList[currentBuffer].pRegisteredAufBux2) 1092 pPlatformPrivate->pMetaDataBuffer = pCompPrv->tBufList[currentBuffer].pRegisteredAufBux2; 1093 } 1094 } 1095 #endif 1096 1097 eRPCError = RPC_UseBuffer(pCompPrv->hRemoteComp, &pBufferHeader, nPortIndex, 1098 pAppPrivate, nSizeBytes, pAuxBuf0, &pBufHeaderRemote, &eCompReturn); 1099 1100 PROXY_checkRpcError(); 1101 1102 DOMX_DEBUG("Use Buffer Successful"); 1103 DOMX_DEBUG 1104 ("Value of pBufHeaderRemote: %p LocalBufferHdr :%p, LocalBuffer :%p", 1105 pBufHeaderRemote, pBufferHeader, pBufferHeader->pBuffer); 1106 1107 #ifdef USE_ION 1108 if (pCompPrv->bUseIon == OMX_TRUE && pCompPrv->bMapIonBuffers == OMX_TRUE && tMetaDataBuffer.bIsMetaDataEnabledOnPort) 1109 { 1110 ((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->pMetaDataBuffer = pMetadataBuffer; 1111 //ion_free(pCompPrv->ion_fd, handleToMap); 1112 memset(((OMX_TI_PLATFORMPRIVATE *)pBufferHeader->pPlatformPrivate)->pMetaDataBuffer, 1113 0x0, tMetaDataBuffer.nMetaDataSize); 1114 } 1115 #endif 1116 1117 //Storing details of pBufferHeader/Mapped/Actual buffer address locally. 1118 pCompPrv->tBufList[currentBuffer].pBufHeader = pBufferHeader; 1119 pCompPrv->tBufList[currentBuffer].pBufHeaderRemote = pBufHeaderRemote; 1120 1121 //keeping track of number of Buffers 1122 pCompPrv->nAllocatedBuffers++; 1123 if (pCompPrv->nTotalBuffers < pCompPrv->nAllocatedBuffers) 1124 pCompPrv->nTotalBuffers = pCompPrv->nAllocatedBuffers; 1125 1126 DOMX_DEBUG("Updating no. of buffer to %d", pCompPrv->nTotalBuffers); 1127 1128 *ppBufferHdr = pBufferHeader; 1129 1130 EXIT: 1131 if (eError != OMX_ErrorNone) 1132 { 1133 if (pPlatformPrivate) 1134 TIMM_OSAL_Free(pPlatformPrivate); 1135 if (pBufferHeader) 1136 TIMM_OSAL_Free(pBufferHeader); 1137 } 1138 DOMX_EXIT("eError: %d", eError); 1139 return eError; 1140 } 1141 1142 /* ===========================================================================*/ 1143 /** 1144 * @name PROXY_FreeBuffer() 1145 * @brief 1146 * @param void 1147 * @return OMX_ErrorNone = Successful 1148 * @sa TBD 1149 * 1150 */ 1151 /* ===========================================================================*/ 1152 OMX_ERRORTYPE PROXY_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent, 1153 OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_BUFFERHEADERTYPE * pBufferHdr) 1154 { 1155 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1156 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 1157 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1158 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone, eTmpRPCError = 1159 RPC_OMX_ErrorNone; 1160 OMX_U32 count = 0, nStride = 0; 1161 OMX_U32 pBuffer = 0; 1162 OMX_PTR pMetaDataBuffer = NULL; 1163 OMX_PTR pAuxBuf0 = NULL; 1164 OMX_TI_PLATFORMPRIVATE * pPlatformPrivate = NULL; 1165 1166 PROXY_require(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL); 1167 PROXY_require(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter, 1168 NULL); 1169 PROXY_CHK_VERSION(pBufferHdr, OMX_BUFFERHEADERTYPE); 1170 1171 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1172 1173 DOMX_ENTER 1174 ("hComponent = %p, pCompPrv = %p, nPortIndex = %p, pBufferHdr = %p, pBuffer = %p", 1175 hComponent, pCompPrv, nPortIndex, pBufferHdr, 1176 pBufferHdr->pBuffer); 1177 1178 for (count = 0; count < pCompPrv->nTotalBuffers; count++) 1179 { 1180 if (pCompPrv->tBufList[count].pBufHeader == pBufferHdr) 1181 { 1182 DOMX_DEBUG("Buffer Index of Match %d", count); 1183 break; 1184 } 1185 } 1186 PROXY_assert((count != pCompPrv->nTotalBuffers), 1187 OMX_ErrorBadParameter, 1188 "Could not find the mapped address in component private buffer list"); 1189 1190 pBuffer = (OMX_U32)pBufferHdr->pBuffer; 1191 pAuxBuf0 = (OMX_PTR) pBuffer; 1192 1193 #ifdef ENABLE_GRALLOC_BUFFERS 1194 if (pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == GrallocPointers) 1195 { 1196 //Extracting buffer pointer from the gralloc buffer 1197 pAuxBuf0 = (OMX_U8 *)(((IMG_native_handle_t*)pBuffer)->fd[0]); 1198 } 1199 #endif 1200 1201 /*To find whether buffer is 2D or 1D */ 1202 /*Not having asserts from this point since even if error occurs during 1203 unmapping/freeing, still trying to clean up as much as possible */ 1204 eError = 1205 RPC_UTIL_GetStride(pCompPrv->hRemoteComp, nPortIndex, &nStride); 1206 if (eError == OMX_ErrorNone && nStride == LINUX_PAGE_SIZE) 1207 { 1208 if (pCompPrv->proxyPortBuffers[nPortIndex].proxyBufferType == BufferDescriptorVirtual2D) 1209 { 1210 pAuxBuf0 = (OMX_U8 *)(((OMX_TI_BUFFERDESCRIPTOR_TYPE*)pBuffer)->pBuf[0]); 1211 } 1212 } 1213 1214 /*Not having asserts from this point since even if error occurs during 1215 unmapping/freeing, still trying to clean up as much as possible */ 1216 1217 if (pCompPrv->tBufList[count].pRegisteredAufBux0 != NULL) 1218 pAuxBuf0 = pCompPrv->tBufList[count].pRegisteredAufBux0; 1219 1220 eRPCError = 1221 RPC_FreeBuffer(pCompPrv->hRemoteComp, nPortIndex, 1222 pCompPrv->tBufList[count].pBufHeaderRemote, (OMX_U32) pAuxBuf0, 1223 &eCompReturn); 1224 1225 if (eRPCError != RPC_OMX_ErrorNone) 1226 eTmpRPCError = eRPCError; 1227 1228 pPlatformPrivate = (OMX_TI_PLATFORMPRIVATE *)(pCompPrv->tBufList[count].pBufHeader)-> 1229 pPlatformPrivate; 1230 1231 if (pCompPrv->tBufList[count].pBufHeader) 1232 { 1233 #ifdef ALLOCATE_TILER_BUFFER_IN_PROXY 1234 #ifdef USE_ION 1235 if(pCompPrv->tBufList[count].pYBuffer) 1236 { 1237 if (pCompPrv->bUseIon == OMX_TRUE) 1238 { 1239 if(pCompPrv->bMapIonBuffers == OMX_TRUE && pBufferHdr->pBuffer) 1240 { 1241 munmap(pBufferHdr->pBuffer, pBufferHdr->nAllocLen); 1242 close(pCompPrv->tBufList[count].mmap_fd); 1243 } 1244 ion_free(pCompPrv->ion_fd, pCompPrv->tBufList[count].pYBuffer); 1245 pCompPrv->tBufList[count].pYBuffer = NULL; 1246 } 1247 } 1248 #endif 1249 #endif 1250 pMetaDataBuffer = pPlatformPrivate->pMetaDataBuffer; 1251 if (pMetaDataBuffer) 1252 { 1253 #ifdef USE_ION 1254 if (pCompPrv->bUseIon == OMX_TRUE) 1255 { 1256 if(pCompPrv->bMapIonBuffers == OMX_TRUE) 1257 { 1258 munmap(pMetaDataBuffer, pPlatformPrivate->nMetaDataSize); 1259 } 1260 close(pCompPrv->tBufList[count].mmap_fd_metadata_buff); 1261 ion_free(pCompPrv->ion_fd, pCompPrv->tBufList[count].pMetaDataBuffer); 1262 pPlatformPrivate->pMetaDataBuffer = NULL; 1263 } 1264 #endif 1265 } 1266 1267 #ifdef USE_ION 1268 { 1269 // Need to unregister buffers when using ion and rpmsg 1270 if (pCompPrv->tBufList[count].pRegisteredAufBux0 != NULL) 1271 { 1272 eTmpRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, 1273 pCompPrv->tBufList[count].pRegisteredAufBux0); 1274 if (eTmpRPCError != RPC_OMX_ErrorNone) { 1275 eRPCError = eTmpRPCError; 1276 } 1277 } 1278 1279 if (pCompPrv->tBufList[count].pRegisteredAufBux1 != NULL) 1280 { 1281 eTmpRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, 1282 pCompPrv->tBufList[count].pRegisteredAufBux1); 1283 if (eTmpRPCError != RPC_OMX_ErrorNone) { 1284 eRPCError = eTmpRPCError; 1285 } 1286 } 1287 if (pCompPrv->tBufList[count].pRegisteredAufBux2 != NULL) 1288 { 1289 eTmpRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, 1290 pCompPrv->tBufList[count].pRegisteredAufBux2); 1291 if (eTmpRPCError != RPC_OMX_ErrorNone) { 1292 eRPCError = eTmpRPCError; 1293 } 1294 } 1295 } 1296 #endif 1297 if (pCompPrv->tBufList[count].pBufHeader->pPlatformPrivate) 1298 { 1299 TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader-> 1300 pPlatformPrivate); 1301 } 1302 TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader); 1303 TIMM_OSAL_Memset(&(pCompPrv->tBufList[count]), 0, 1304 sizeof(PROXY_BUFFER_INFO)); 1305 } 1306 pCompPrv->nAllocatedBuffers--; 1307 1308 PROXY_checkRpcError(); 1309 1310 EXIT: 1311 DOMX_EXIT("eError: %d", eError); 1312 return eError; 1313 } 1314 1315 1316 /* ===========================================================================*/ 1317 /** 1318 * @name PROXY_SetParameter() 1319 * @brief 1320 * @param void 1321 * @return OMX_ErrorNone = Successful 1322 * @sa TBD 1323 * 1324 */ 1325 /* ===========================================================================*/ 1326 OMX_ERRORTYPE __PROXY_SetParameter(OMX_IN OMX_HANDLETYPE hComponent, 1327 OMX_IN OMX_INDEXTYPE nParamIndex, OMX_IN OMX_PTR pParamStruct, 1328 OMX_PTR pLocBufNeedMap, OMX_U32 nNumOfLocalBuf) 1329 { 1330 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1331 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1332 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1333 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 1334 OMX_TI_PARAM_USEBUFFERDESCRIPTOR *ptBufDescParam = NULL; 1335 #ifdef ENABLE_GRALLOC_BUFFERS 1336 OMX_TI_PARAMUSENATIVEBUFFER *pParamNativeBuffer = NULL; 1337 #endif 1338 #ifdef USE_ION 1339 OMX_PTR *pAuxBuf = pLocBufNeedMap; 1340 OMX_PTR pRegistered = NULL; 1341 #endif 1342 1343 PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL); 1344 PROXY_require((hComp->pComponentPrivate != NULL), 1345 OMX_ErrorBadParameter, NULL); 1346 1347 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1348 1349 DOMX_ENTER 1350 ("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p", 1351 hComponent, pCompPrv, nParamIndex, pParamStruct); 1352 1353 switch(nParamIndex) 1354 { 1355 #ifdef ENABLE_GRALLOC_BUFFERS 1356 case OMX_TI_IndexUseNativeBuffers: 1357 { 1358 //Add check version. 1359 pParamNativeBuffer = (OMX_TI_PARAMUSENATIVEBUFFER* )pParamStruct; 1360 if(pParamNativeBuffer->bEnable == OMX_TRUE) 1361 { 1362 pCompPrv->proxyPortBuffers[pParamNativeBuffer->nPortIndex].proxyBufferType = GrallocPointers; 1363 pCompPrv->proxyPortBuffers[pParamNativeBuffer->nPortIndex].IsBuffer2D = OMX_TRUE; 1364 } else 1365 { 1366 /* Reset to defaults */ 1367 pCompPrv->proxyPortBuffers[pParamNativeBuffer->nPortIndex].proxyBufferType = VirtualPointers; 1368 pCompPrv->proxyPortBuffers[pParamNativeBuffer->nPortIndex].IsBuffer2D = OMX_FALSE; 1369 } 1370 1371 break; 1372 } 1373 #endif 1374 case OMX_TI_IndexUseBufferDescriptor: 1375 ptBufDescParam = (OMX_TI_PARAM_USEBUFFERDESCRIPTOR *) pParamStruct; 1376 if(ptBufDescParam->bEnabled == OMX_TRUE) 1377 { 1378 if(ptBufDescParam->eBufferType == OMX_TI_BufferTypeVirtual2D) 1379 { 1380 pCompPrv->proxyPortBuffers[ptBufDescParam->nPortIndex].proxyBufferType = BufferDescriptorVirtual2D; 1381 pCompPrv->proxyPortBuffers[ptBufDescParam->nPortIndex].IsBuffer2D = OMX_TRUE; 1382 } 1383 } 1384 else if(ptBufDescParam->bEnabled == OMX_FALSE) 1385 { 1386 /* Reset to defaults*/ 1387 pCompPrv->proxyPortBuffers[ptBufDescParam->nPortIndex].proxyBufferType = VirtualPointers; 1388 pCompPrv->proxyPortBuffers[ptBufDescParam->nPortIndex].IsBuffer2D = OMX_FALSE; 1389 } 1390 eRPCError = 1391 RPC_SetParameter(pCompPrv->hRemoteComp, nParamIndex, pParamStruct, 1392 pLocBufNeedMap, nNumOfLocalBuf, &eCompReturn); 1393 break; 1394 default: 1395 { 1396 #ifdef USE_ION 1397 if (pAuxBuf != NULL) { 1398 int fd = *((int*)pAuxBuf); 1399 if (fd > -1) { 1400 eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, *((int*)pAuxBuf), 1401 &pRegistered, NULL, IONPointers); 1402 PROXY_checkRpcError(); 1403 if (pRegistered) 1404 *pAuxBuf = pRegistered; 1405 } 1406 } 1407 #endif 1408 eRPCError = 1409 RPC_SetParameter(pCompPrv->hRemoteComp, nParamIndex, pParamStruct, 1410 pLocBufNeedMap, nNumOfLocalBuf, &eCompReturn); 1411 #ifdef USE_ION 1412 PROXY_checkRpcError(); 1413 if (pRegistered != NULL) { 1414 eRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, pRegistered); 1415 PROXY_checkRpcError(); 1416 } 1417 #endif 1418 } 1419 } 1420 1421 PROXY_checkRpcError(); 1422 1423 EXIT: 1424 DOMX_EXIT("eError: %d", eError); 1425 return eError; 1426 } 1427 1428 /* ===========================================================================*/ 1429 /** 1430 * @name PROXY_SetParameter() 1431 * @brief 1432 * @param void 1433 * @return OMX_ErrorNone = Successful 1434 * @sa TBD 1435 * 1436 */ 1437 /* ===========================================================================*/ 1438 OMX_ERRORTYPE PROXY_SetParameter(OMX_IN OMX_HANDLETYPE hComponent, 1439 OMX_IN OMX_INDEXTYPE nParamIndex, OMX_IN OMX_PTR pParamStruct) 1440 { 1441 return __PROXY_SetParameter(hComponent, nParamIndex, pParamStruct, NULL, 0); 1442 } 1443 1444 1445 /* ===========================================================================*/ 1446 /** 1447 * @name __PROXY_GetParameter() 1448 * @brief 1449 * @param void 1450 * @return OMX_ErrorNone = Successful 1451 * @sa TBD 1452 * 1453 */ 1454 /* ===========================================================================*/ 1455 OMX_ERRORTYPE __PROXY_GetParameter(OMX_IN OMX_HANDLETYPE hComponent, 1456 OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct, 1457 OMX_PTR pLocBufNeedMap) 1458 { 1459 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1460 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1461 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1462 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 1463 OMX_TI_PARAM_USEBUFFERDESCRIPTOR *ptBufDescParam = NULL; 1464 #ifdef USE_ION 1465 OMX_PTR *pAuxBuf = pLocBufNeedMap; 1466 OMX_PTR pRegistered = NULL; 1467 #endif 1468 1469 PROXY_require((pParamStruct != NULL), OMX_ErrorBadParameter, NULL); 1470 PROXY_assert((hComp->pComponentPrivate != NULL), 1471 OMX_ErrorBadParameter, NULL); 1472 1473 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1474 1475 DOMX_ENTER 1476 ("hComponent = %p, pCompPrv = %p, nParamIndex = %d, pParamStruct = %p", 1477 hComponent, pCompPrv, nParamIndex, pParamStruct); 1478 1479 switch(nParamIndex) 1480 { 1481 case OMX_TI_IndexUseBufferDescriptor: 1482 ptBufDescParam = (OMX_TI_PARAM_USEBUFFERDESCRIPTOR *) pParamStruct; 1483 if(pCompPrv->proxyPortBuffers[ptBufDescParam->nPortIndex].proxyBufferType == BufferDescriptorVirtual2D) 1484 { 1485 ptBufDescParam->bEnabled = OMX_TRUE; 1486 ptBufDescParam->eBufferType = OMX_TI_BufferTypeVirtual2D; 1487 } 1488 else 1489 { 1490 ptBufDescParam->bEnabled = OMX_FALSE; 1491 ptBufDescParam->eBufferType = OMX_TI_BufferTypeMax; 1492 } 1493 break; 1494 1495 default: 1496 { 1497 #ifdef USE_ION 1498 if (pAuxBuf != NULL) { 1499 int fd = *((int*)pAuxBuf); 1500 if (fd > -1) { 1501 eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, *((int*)pAuxBuf), 1502 &pRegistered, NULL, IONPointers); 1503 PROXY_checkRpcError(); 1504 if (pRegistered) 1505 *pAuxBuf = pRegistered; 1506 } 1507 } 1508 #endif 1509 eRPCError = RPC_GetParameter(pCompPrv->hRemoteComp, nParamIndex, pParamStruct, 1510 pLocBufNeedMap, &eCompReturn); 1511 #ifdef USE_ION 1512 PROXY_checkRpcError(); 1513 if (pRegistered != NULL) { 1514 eRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, pRegistered); 1515 PROXY_checkRpcError(); 1516 } 1517 #endif 1518 } 1519 } 1520 1521 PROXY_checkRpcError(); 1522 1523 EXIT: 1524 DOMX_EXIT("eError: %d index: 0x%x", eError, nParamIndex); 1525 return eError; 1526 } 1527 1528 /* ===========================================================================*/ 1529 /** 1530 * @name PROXY_GetParameter() 1531 * @brief 1532 * @param void 1533 * @return OMX_ErrorNone = Successful 1534 * @sa TBD 1535 * 1536 */ 1537 /* ===========================================================================*/ 1538 OMX_ERRORTYPE PROXY_GetParameter(OMX_IN OMX_HANDLETYPE hComponent, 1539 OMX_IN OMX_INDEXTYPE nParamIndex, OMX_INOUT OMX_PTR pParamStruct) 1540 { 1541 return __PROXY_GetParameter(hComponent, nParamIndex, pParamStruct, NULL); 1542 } 1543 1544 /* ===========================================================================*/ 1545 /** 1546 * @name __PROXY_GetConfig() 1547 * @brief 1548 * @param void 1549 * @return OMX_ErrorNone = Successful 1550 * @sa TBD 1551 * 1552 */ 1553 /* ===========================================================================*/ 1554 OMX_ERRORTYPE __PROXY_GetConfig(OMX_HANDLETYPE hComponent, 1555 OMX_INDEXTYPE nConfigIndex, OMX_PTR pConfigStruct, OMX_PTR pLocBufNeedMap) 1556 { 1557 #ifdef USE_ION 1558 OMX_PTR *pAuxBuf = pLocBufNeedMap; 1559 OMX_PTR pRegistered = NULL; 1560 #endif 1561 1562 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1563 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1564 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1565 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 1566 1567 PROXY_require((pConfigStruct != NULL), OMX_ErrorBadParameter, NULL); 1568 PROXY_require((hComp->pComponentPrivate != NULL), 1569 OMX_ErrorBadParameter, NULL); 1570 1571 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1572 1573 DOMX_ENTER("hComponent = %p, pCompPrv = %p, nConfigIndex = %d, " 1574 "pConfigStruct = %p", 1575 hComponent, pCompPrv, nConfigIndex, 1576 pConfigStruct); 1577 1578 #ifdef USE_ION 1579 if (pAuxBuf != NULL) { 1580 int fd = *((int*)pAuxBuf); 1581 if (fd > -1) { 1582 eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, *((int*)pAuxBuf), 1583 &pRegistered, NULL, IONPointers); 1584 PROXY_checkRpcError(); 1585 if (pRegistered) 1586 *pAuxBuf = pRegistered; 1587 } 1588 } 1589 #endif 1590 1591 eRPCError = 1592 RPC_GetConfig(pCompPrv->hRemoteComp, nConfigIndex, pConfigStruct, 1593 pLocBufNeedMap, &eCompReturn); 1594 #ifdef USE_ION 1595 PROXY_checkRpcError(); 1596 if (pRegistered != NULL) { 1597 eRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, pRegistered); 1598 PROXY_checkRpcError(); 1599 } 1600 #endif 1601 1602 PROXY_checkRpcError(); 1603 1604 EXIT: 1605 DOMX_EXIT("eError: %d", eError); 1606 return eError; 1607 } 1608 1609 /* ===========================================================================*/ 1610 /** 1611 * @name PROXY_GetConfig() 1612 * @brief 1613 * @param void 1614 * @return OMX_ErrorNone = Successful 1615 * @sa TBD 1616 * 1617 */ 1618 /* ===========================================================================*/ 1619 OMX_ERRORTYPE PROXY_GetConfig(OMX_HANDLETYPE hComponent, 1620 OMX_INDEXTYPE nConfigIndex, OMX_PTR pConfigStruct) 1621 { 1622 return __PROXY_GetConfig(hComponent, nConfigIndex, pConfigStruct, NULL); 1623 } 1624 1625 /* ===========================================================================*/ 1626 /** 1627 * @name __PROXY_SetConfig() 1628 * @brief 1629 * @param void 1630 * @return OMX_ErrorNone = Successful 1631 * @sa TBD 1632 * 1633 */ 1634 /* ===========================================================================*/ 1635 OMX_ERRORTYPE __PROXY_SetConfig(OMX_IN OMX_HANDLETYPE hComponent, 1636 OMX_IN OMX_INDEXTYPE nConfigIndex, OMX_IN OMX_PTR pConfigStruct, 1637 OMX_PTR pLocBufNeedMap) 1638 { 1639 #ifdef USE_ION 1640 OMX_PTR *pAuxBuf = pLocBufNeedMap; 1641 OMX_PTR pRegistered = NULL; 1642 #endif 1643 1644 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1645 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1646 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1647 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 1648 1649 PROXY_require((pConfigStruct != NULL), OMX_ErrorBadParameter, NULL); 1650 1651 PROXY_assert((hComp->pComponentPrivate != NULL), 1652 OMX_ErrorBadParameter, NULL); 1653 1654 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1655 1656 DOMX_ENTER("hComponent = %p, pCompPrv = %p, nConfigIndex = %d, " 1657 "pConfigStruct = %p", 1658 hComponent, pCompPrv, nConfigIndex, 1659 pConfigStruct); 1660 1661 #ifdef USE_ION 1662 if (pAuxBuf != NULL) { 1663 int fd = *((int*)pAuxBuf); 1664 if (fd > -1) { 1665 eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, *((int*)pAuxBuf), 1666 &pRegistered, NULL, IONPointers); 1667 PROXY_checkRpcError(); 1668 if (pRegistered) 1669 *pAuxBuf = pRegistered; 1670 } 1671 } 1672 #endif 1673 1674 eRPCError = 1675 RPC_SetConfig(pCompPrv->hRemoteComp, nConfigIndex, pConfigStruct, 1676 pLocBufNeedMap, &eCompReturn); 1677 1678 #ifdef USE_ION 1679 PROXY_checkRpcError(); 1680 if (pRegistered != NULL) { 1681 eRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, pRegistered); 1682 PROXY_checkRpcError(); 1683 } 1684 #endif 1685 1686 PROXY_checkRpcError(); 1687 1688 EXIT: 1689 DOMX_EXIT("eError: %d", eError); 1690 return eError; 1691 } 1692 1693 /* ===========================================================================*/ 1694 /** 1695 * @name PROXY_SetConfig() 1696 * @brief 1697 * @param void 1698 * @return OMX_ErrorNone = Successful 1699 * @sa TBD 1700 * 1701 */ 1702 /* ===========================================================================*/ 1703 OMX_ERRORTYPE PROXY_SetConfig(OMX_IN OMX_HANDLETYPE hComponent, 1704 OMX_IN OMX_INDEXTYPE nConfigIndex, OMX_IN OMX_PTR pConfigStruct) 1705 { 1706 return __PROXY_SetConfig(hComponent, nConfigIndex, pConfigStruct, NULL); 1707 } 1708 1709 1710 /* ===========================================================================*/ 1711 /** 1712 * @name PROXY_GetState() 1713 * @brief 1714 * @param void 1715 * @return OMX_ErrorNone = Successful 1716 * @sa TBD 1717 * 1718 */ 1719 /* ===========================================================================*/ 1720 static OMX_ERRORTYPE PROXY_GetState(OMX_IN OMX_HANDLETYPE hComponent, 1721 OMX_OUT OMX_STATETYPE * pState) 1722 { 1723 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1724 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1725 OMX_COMPONENTTYPE *hComp = hComponent; 1726 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1727 1728 PROXY_require((pState != NULL), OMX_ErrorBadParameter, NULL); 1729 PROXY_require((hComp->pComponentPrivate != NULL), 1730 OMX_ErrorBadParameter, NULL); 1731 1732 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1733 1734 DOMX_ENTER("hComponent = %p, pCompPrv = %p", hComponent, pCompPrv); 1735 1736 eRPCError = RPC_GetState(pCompPrv->hRemoteComp, pState, &eCompReturn); 1737 1738 DOMX_DEBUG("Returned from RPC_GetState, state: = %x", *pState); 1739 1740 PROXY_checkRpcError(); 1741 1742 EXIT: 1743 if (eError == OMX_ErrorHardware) 1744 { 1745 *pState = OMX_StateInvalid; 1746 eError = OMX_ErrorNone; 1747 DOMX_DEBUG("Invalid state returned from RPC_GetState, state due to ducati in faulty state"); 1748 } 1749 DOMX_EXIT("eError: %d", eError); 1750 return eError; 1751 } 1752 1753 1754 1755 /* ===========================================================================*/ 1756 /** 1757 * @name PROXY_SendCommand() 1758 * @brief 1759 * @param void 1760 * @return OMX_ErrorNone = Successful 1761 * @sa TBD 1762 * 1763 */ 1764 /* ===========================================================================*/ 1765 OMX_ERRORTYPE PROXY_SendCommand(OMX_IN OMX_HANDLETYPE hComponent, 1766 OMX_IN OMX_COMMANDTYPE eCmd, 1767 OMX_IN OMX_U32 nParam, OMX_IN OMX_PTR pCmdData) 1768 { 1769 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1770 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1771 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1772 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 1773 OMX_COMPONENTTYPE *pMarkComp = NULL; 1774 PROXY_COMPONENT_PRIVATE *pMarkCompPrv = NULL; 1775 OMX_PTR pMarkData = NULL, pMarkToBeFreedIfError = NULL; 1776 OMX_BOOL bIsProxy = OMX_FALSE; 1777 1778 PROXY_require((hComp->pComponentPrivate != NULL), 1779 OMX_ErrorBadParameter, NULL); 1780 1781 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1782 1783 DOMX_ENTER 1784 ("hComponent = %p, pCompPrv = %p, eCmd = %d, nParam = %d, pCmdData = %p", 1785 hComponent, pCompPrv, eCmd, nParam, pCmdData); 1786 1787 if (eCmd == OMX_CommandMarkBuffer) 1788 { 1789 PROXY_require(pCmdData != NULL, OMX_ErrorBadParameter, NULL); 1790 pMarkComp = (OMX_COMPONENTTYPE *) 1791 (((OMX_MARKTYPE *) pCmdData)->hMarkTargetComponent); 1792 PROXY_require(pMarkComp != NULL, OMX_ErrorBadParameter, NULL); 1793 1794 /* To check if mark comp is a proxy or a real component */ 1795 eError = _RPC_IsProxyComponent(pMarkComp, &bIsProxy); 1796 PROXY_assert(eError == OMX_ErrorNone, eError, ""); 1797 1798 /*Replacing original mark data with proxy specific structure */ 1799 pMarkData = ((OMX_MARKTYPE *) pCmdData)->pMarkData; 1800 ((OMX_MARKTYPE *) pCmdData)->pMarkData = 1801 TIMM_OSAL_Malloc(sizeof(PROXY_MARK_DATA), TIMM_OSAL_TRUE, 1802 0, TIMMOSAL_MEM_SEGMENT_INT); 1803 PROXY_assert(((OMX_MARKTYPE *) pCmdData)->pMarkData != NULL, 1804 OMX_ErrorInsufficientResources, "Malloc failed"); 1805 pMarkToBeFreedIfError = 1806 ((OMX_MARKTYPE *) pCmdData)->pMarkData; 1807 ((PROXY_MARK_DATA *) (((OMX_MARKTYPE *) 1808 pCmdData)->pMarkData))->hComponentActual = 1809 pMarkComp; 1810 ((PROXY_MARK_DATA *) (((OMX_MARKTYPE *) 1811 pCmdData)->pMarkData))->pMarkDataActual = 1812 pMarkData; 1813 1814 /* If it is proxy component then replace hMarkTargetComponent 1815 with remote handle */ 1816 if (bIsProxy) 1817 { 1818 pMarkCompPrv = pMarkComp->pComponentPrivate; 1819 PROXY_assert(pMarkCompPrv != NULL, 1820 OMX_ErrorBadParameter, NULL); 1821 1822 /* Replacing with remote component handle */ 1823 ((OMX_MARKTYPE *) pCmdData)->hMarkTargetComponent = 1824 ((RPC_OMX_CONTEXT *) pMarkCompPrv->hRemoteComp)-> 1825 hActualRemoteCompHandle; 1826 } 1827 } 1828 1829 eRPCError = 1830 RPC_SendCommand(pCompPrv->hRemoteComp, eCmd, nParam, pCmdData, 1831 &eCompReturn); 1832 1833 if (eCmd == OMX_CommandMarkBuffer && bIsProxy) 1834 { 1835 /*Resetting to original values */ 1836 ((OMX_MARKTYPE *) pCmdData)->hMarkTargetComponent = pMarkComp; 1837 ((OMX_MARKTYPE *) pCmdData)->pMarkData = pMarkData; 1838 } 1839 1840 PROXY_checkRpcError(); 1841 1842 EXIT: 1843 /*If SendCommand is about to return an error then this means that the 1844 command has not been accepted by the component. Thus the allocated mark data 1845 will be lost so free it here */ 1846 if ((eError != OMX_ErrorNone) && pMarkToBeFreedIfError) 1847 { 1848 TIMM_OSAL_Free(pMarkToBeFreedIfError); 1849 } 1850 DOMX_EXIT("eError: %d", eError); 1851 return eError; 1852 } 1853 1854 1855 1856 /* ===========================================================================*/ 1857 /** 1858 * @name PROXY_GetComponentVersion() 1859 * @brief 1860 * @param void 1861 * @return OMX_ErrorNone = Successful 1862 * @sa TBD 1863 * 1864 */ 1865 /* ===========================================================================*/ 1866 static OMX_ERRORTYPE PROXY_GetComponentVersion(OMX_IN OMX_HANDLETYPE 1867 hComponent, OMX_OUT OMX_STRING pComponentName, 1868 OMX_OUT OMX_VERSIONTYPE * pComponentVersion, 1869 OMX_OUT OMX_VERSIONTYPE * pSpecVersion, 1870 OMX_OUT OMX_UUIDTYPE * pComponentUUID) 1871 { 1872 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1873 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1874 OMX_COMPONENTTYPE *hComp = hComponent; 1875 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1876 1877 DOMX_ENTER("hComponent = %p, pCompPrv = %p", hComponent, pCompPrv); 1878 1879 PROXY_require((hComp->pComponentPrivate != NULL), 1880 OMX_ErrorBadParameter, NULL); 1881 PROXY_require(pComponentName != NULL, OMX_ErrorBadParameter, NULL); 1882 PROXY_require(pComponentVersion != NULL, OMX_ErrorBadParameter, NULL); 1883 PROXY_require(pSpecVersion != NULL, OMX_ErrorBadParameter, NULL); 1884 PROXY_require(pComponentUUID != NULL, OMX_ErrorBadParameter, NULL); 1885 1886 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1887 1888 eRPCError = RPC_GetComponentVersion(pCompPrv->hRemoteComp, 1889 pComponentName, 1890 pComponentVersion, pSpecVersion, pComponentUUID, &eCompReturn); 1891 1892 PROXY_checkRpcError(); 1893 1894 EXIT: 1895 DOMX_EXIT("eError: %d", eError); 1896 return eError; 1897 } 1898 1899 1900 1901 /* ===========================================================================*/ 1902 /** 1903 * @name PROXY_GetExtensionIndex() 1904 * @brief 1905 * @param void 1906 * @return OMX_ErrorNone = Successful 1907 * @sa TBD 1908 * 1909 */ 1910 /* ===========================================================================*/ 1911 OMX_ERRORTYPE PROXY_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent, 1912 OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE * pIndexType) 1913 { 1914 1915 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 1916 PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; 1917 OMX_COMPONENTTYPE *hComp = hComponent; 1918 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1919 1920 PROXY_require((hComp->pComponentPrivate != NULL), 1921 OMX_ErrorBadParameter, NULL); 1922 PROXY_require(cParameterName != NULL, OMX_ErrorBadParameter, NULL); 1923 PROXY_require(pIndexType != NULL, OMX_ErrorBadParameter, NULL); 1924 1925 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 1926 1927 DOMX_ENTER("hComponent = %p, pCompPrv = %p, cParameterName = %s", 1928 hComponent, pCompPrv, cParameterName); 1929 1930 1931 #ifdef ENABLE_GRALLOC_BUFFERS 1932 // Check for NULL Parameters 1933 PROXY_require((cParameterName != NULL && pIndexType != NULL), 1934 OMX_ErrorBadParameter, NULL); 1935 1936 // Ensure that String length is not greater than Max allowed length 1937 PROXY_require(strlen(cParameterName) <= 127, OMX_ErrorBadParameter, NULL); 1938 1939 if(strcmp(cParameterName, "OMX.google.android.index.enableAndroidNativeBuffers") == 0) 1940 { 1941 // If Index type is 2D Buffer Allocated Dimension 1942 *pIndexType = (OMX_INDEXTYPE) OMX_TI_IndexUseNativeBuffers; 1943 goto EXIT; 1944 } 1945 else if (strcmp(cParameterName, "OMX.google.android.index.useAndroidNativeBuffer2") == 0) 1946 { 1947 //This is call just a dummy for android to support backward compatibility 1948 *pIndexType = (OMX_INDEXTYPE) NULL; 1949 goto EXIT; 1950 } 1951 else 1952 { 1953 eRPCError = RPC_GetExtensionIndex(pCompPrv->hRemoteComp, 1954 cParameterName, pIndexType, &eCompReturn); 1955 1956 PROXY_checkRpcError(); 1957 } 1958 #else 1959 eRPCError = RPC_GetExtensionIndex(pCompPrv->hRemoteComp, 1960 cParameterName, pIndexType, &eCompReturn); 1961 1962 PROXY_checkRpcError(); 1963 #endif 1964 1965 EXIT: 1966 DOMX_EXIT("eError: %d", eError); 1967 return eError; 1968 } 1969 1970 1971 1972 1973 /* ===========================================================================*/ 1974 /** 1975 * @name PROXY_ComponentRoleEnum() 1976 * @brief 1977 * @param void 1978 * @return OMX_ErrorNone = Successful 1979 * @sa TBD 1980 * 1981 */ 1982 /* ===========================================================================*/ 1983 static OMX_ERRORTYPE PROXY_ComponentRoleEnum(OMX_IN OMX_HANDLETYPE hComponent, 1984 OMX_OUT OMX_U8 * cRole, OMX_IN OMX_U32 nIndex) 1985 { 1986 OMX_ERRORTYPE eError = OMX_ErrorNone; 1987 1988 DOMX_ENTER("hComponent = %p", hComponent); 1989 DOMX_DEBUG(" EMPTY IMPLEMENTATION "); 1990 1991 DOMX_EXIT("eError: %d", eError); 1992 return eError; 1993 } 1994 1995 1996 /* ===========================================================================*/ 1997 /** 1998 * @name PROXY_ComponentTunnelRequest() 1999 * @brief 2000 * @param void 2001 * @return OMX_ErrorNone = Successful 2002 * @sa TBD 2003 * 2004 */ 2005 /* ===========================================================================*/ 2006 static OMX_ERRORTYPE PROXY_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE 2007 hComponent, OMX_IN OMX_U32 nPort, OMX_IN OMX_HANDLETYPE hTunneledComp, 2008 OMX_IN OMX_U32 nTunneledPort, 2009 OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup) 2010 { 2011 OMX_ERRORTYPE eError = OMX_ErrorNone; 2012 2013 DOMX_ENTER("hComponent = %p", hComponent); 2014 DOMX_DEBUG(" EMPTY IMPLEMENTATION "); 2015 PROXY_COMPONENT_PRIVATE *pOutCompPrv = NULL; 2016 PROXY_COMPONENT_PRIVATE *pInCompPrv = NULL; 2017 OMX_COMPONENTTYPE *hOutComp = hComponent; 2018 OMX_COMPONENTTYPE *hInComp = hTunneledComp; 2019 OMX_ERRORTYPE eCompReturn = OMX_ErrorNone; 2020 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 2021 PROXY_assert((hOutComp->pComponentPrivate != NULL), 2022 OMX_ErrorBadParameter, NULL); 2023 PROXY_assert((hInComp->pComponentPrivate != NULL), 2024 OMX_ErrorBadParameter, NULL); 2025 2026 //TBD 2027 //PROXY_assert(nPort != 1, OMX_ErrorBadParameter, NULL); 2028 //PROXY_assert(nTunnelPort != 0, OMX_ErrorBadParameter, NULL); 2029 pOutCompPrv = (PROXY_COMPONENT_PRIVATE *) hOutComp->pComponentPrivate; 2030 pInCompPrv = (PROXY_COMPONENT_PRIVATE *) hInComp->pComponentPrivate; 2031 DOMX_ENTER("hOutComp=%p, pOutCompPrv=%p, hInComp=%p, pInCompPrv=%p, nOutPort=%d, nInPort=%d \n", 2032 hOutComp, pOutCompPrv, hInComp, pInCompPrv, nPort, nTunneledPort); 2033 2034 DOMX_INFO("PROXY_ComponentTunnelRequest:: hOutComp=%p, pOutCompPrv=%p, hInComp=%p, pInCompPrv=%p, nOutPort=%d, nInPort=%d \n ", 2035 hOutComp, pOutCompPrv, hInComp, pInCompPrv, nPort, nTunneledPort); 2036 eRPCError = RPC_ComponentTunnelRequest(pOutCompPrv->hRemoteComp, nPort, 2037 pInCompPrv->hRemoteComp, nTunneledPort, pTunnelSetup, &eCompReturn); 2038 DOMX_INFO("\nafter: RPC_ComponentTunnelRequest = 0x%x\n ", eRPCError); 2039 PROXY_checkRpcError(); 2040 2041 EXIT: 2042 DOMX_EXIT("eError: %d", eError); 2043 return eError; 2044 } 2045 2046 2047 /* ===========================================================================*/ 2048 /** 2049 * @name PROXY_SetCallbacks() 2050 * @brief 2051 * @param void 2052 * @return OMX_ErrorNone = Successful 2053 * @sa TBD 2054 * 2055 */ 2056 /* ===========================================================================*/ 2057 static OMX_ERRORTYPE PROXY_SetCallbacks(OMX_HANDLETYPE hComponent, 2058 OMX_CALLBACKTYPE * pCallBacks, OMX_PTR pAppData) 2059 { 2060 OMX_ERRORTYPE eError = OMX_ErrorNone; 2061 PROXY_COMPONENT_PRIVATE *pCompPrv; 2062 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 2063 2064 PROXY_require((pCallBacks != NULL), OMX_ErrorBadParameter, NULL); 2065 2066 PROXY_assert((hComp->pComponentPrivate != NULL), 2067 OMX_ErrorBadParameter, NULL); 2068 2069 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 2070 2071 DOMX_ENTER("hComponent = %p, pCompPrv = %p", hComponent, pCompPrv); 2072 2073 /*Store App callback and data to proxy- managed by proxy */ 2074 pCompPrv->tCBFunc = *pCallBacks; 2075 pCompPrv->pILAppData = pAppData; 2076 2077 EXIT: 2078 DOMX_EXIT("eError: %d", eError); 2079 return eError; 2080 } 2081 2082 2083 /* ===========================================================================*/ 2084 /** 2085 * @name PROXY_UseEGLImage() 2086 * @brief : This returns error not implemented by default as no component 2087 * implements this. In case there is a requiremet, support for this 2088 * can be added later. 2089 * 2090 */ 2091 /* ===========================================================================*/ 2092 static OMX_ERRORTYPE PROXY_UseEGLImage(OMX_HANDLETYPE hComponent, 2093 OMX_BUFFERHEADERTYPE ** ppBufferHdr, 2094 OMX_U32 nPortIndex, OMX_PTR pAppPrivate, void *pBuffer) 2095 { 2096 return OMX_ErrorNotImplemented; 2097 } 2098 2099 2100 /* ===========================================================================*/ 2101 /** 2102 * @name PROXY_ComponentDeInit() 2103 * @brief 2104 * @param void 2105 * @return OMX_ErrorNone = Successful 2106 * @sa TBD 2107 * 2108 */ 2109 /* ===========================================================================*/ 2110 OMX_ERRORTYPE PROXY_ComponentDeInit(OMX_HANDLETYPE hComponent) 2111 { 2112 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 2113 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone, eTmpRPCError = 2114 RPC_OMX_ErrorNone; 2115 PROXY_COMPONENT_PRIVATE *pCompPrv; 2116 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 2117 OMX_U32 count = 0, nStride = 0; 2118 OMX_PTR pMetaDataBuffer = NULL; 2119 2120 DOMX_ENTER("hComponent = %p", hComponent); 2121 2122 PROXY_assert((hComp->pComponentPrivate != NULL), 2123 OMX_ErrorBadParameter, NULL); 2124 2125 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 2126 2127 ion_close(pCompPrv->ion_fd); 2128 2129 for (count = 0; count < pCompPrv->nTotalBuffers; count++) 2130 { 2131 if (pCompPrv->tBufList[count].pBufHeader) 2132 { 2133 #ifdef ALLOCATE_TILER_BUFFER_IN_PROXY 2134 if(pCompPrv->tBufList[count].pYBuffer) 2135 { 2136 #ifdef USE_ION 2137 if(pCompPrv->tBufList[count].pYBuffer) 2138 { 2139 if (pCompPrv->bUseIon == OMX_TRUE) 2140 { 2141 if(pCompPrv->bMapIonBuffers == OMX_TRUE) 2142 { 2143 munmap(pCompPrv->tBufList[count].pBufHeader->pBuffer, pCompPrv->tBufList[count].pBufHeader->nAllocLen); 2144 close(pCompPrv->tBufList[count].mmap_fd); 2145 } 2146 ion_free(pCompPrv->ion_fd, pCompPrv->tBufList[count].pYBuffer); 2147 pCompPrv->tBufList[count].pYBuffer = NULL; 2148 } 2149 } 2150 #endif 2151 } 2152 #endif 2153 pMetaDataBuffer = ((OMX_TI_PLATFORMPRIVATE *)(pCompPrv->tBufList[count].pBufHeader)-> 2154 pPlatformPrivate)->pMetaDataBuffer; 2155 if (pMetaDataBuffer) 2156 { 2157 #ifdef USE_ION 2158 if (pCompPrv->bUseIon == OMX_TRUE) 2159 { 2160 if(pCompPrv->bMapIonBuffers == OMX_TRUE) 2161 { 2162 munmap(pMetaDataBuffer, ((OMX_TI_PLATFORMPRIVATE *)(pCompPrv->tBufList[count].pBufHeader)-> 2163 pPlatformPrivate)->nMetaDataSize); 2164 } 2165 close(pCompPrv->tBufList[count].mmap_fd_metadata_buff); 2166 ion_free(pCompPrv->ion_fd, pMetaDataBuffer); 2167 ((OMX_TI_PLATFORMPRIVATE *)(pCompPrv->tBufList[count].pBufHeader)-> 2168 pPlatformPrivate)->pMetaDataBuffer = NULL; 2169 } 2170 #endif 2171 } 2172 if (pCompPrv->tBufList[count].pBufHeader->pPlatformPrivate) 2173 { 2174 TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader-> 2175 pPlatformPrivate); 2176 } 2177 TIMM_OSAL_Free(pCompPrv->tBufList[count].pBufHeader); 2178 TIMM_OSAL_Memset(&(pCompPrv->tBufList[count]), 0, 2179 sizeof(PROXY_BUFFER_INFO)); 2180 } 2181 } 2182 2183 KPI_OmxCompDeinit(hComponent); 2184 2185 eRPCError = RPC_FreeHandle(pCompPrv->hRemoteComp, &eCompReturn); 2186 if (eRPCError != RPC_OMX_ErrorNone) 2187 eTmpRPCError = eRPCError; 2188 2189 eRPCError = RPC_InstanceDeInit(pCompPrv->hRemoteComp); 2190 if (eRPCError != RPC_OMX_ErrorNone) 2191 eTmpRPCError = eRPCError; 2192 2193 if (pCompPrv->cCompName) 2194 { 2195 TIMM_OSAL_Free(pCompPrv->cCompName); 2196 } 2197 2198 if (pCompPrv) 2199 { 2200 TIMM_OSAL_Free(pCompPrv); 2201 } 2202 2203 eRPCError = eTmpRPCError; 2204 PROXY_checkRpcError(); 2205 2206 EXIT: 2207 DOMX_EXIT("eError: %d", eError); 2208 return eError; 2209 } 2210 2211 2212 /* ===========================================================================*/ 2213 /** 2214 * @name OMX_ProxyCommonInit() 2215 * @brief 2216 * @param void 2217 * @return OMX_ErrorNone = Successful 2218 * @sa TBD 2219 * 2220 */ 2221 /* ===========================================================================*/ 2222 OMX_ERRORTYPE OMX_ProxyCommonInit(OMX_HANDLETYPE hComponent) 2223 { 2224 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 2225 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 2226 PROXY_COMPONENT_PRIVATE *pCompPrv; 2227 OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; 2228 OMX_HANDLETYPE hRemoteComp = NULL; 2229 OMX_U32 i = 0; 2230 2231 DOMX_ENTER("hComponent = %p", hComponent); 2232 2233 TIMM_OSAL_UpdateTraceLevel(); 2234 2235 PROXY_require((hComp->pComponentPrivate != NULL), 2236 OMX_ErrorBadParameter, NULL); 2237 2238 pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; 2239 2240 pCompPrv->nTotalBuffers = 0; 2241 pCompPrv->nAllocatedBuffers = 0; 2242 pCompPrv->proxyEmptyBufferDone = PROXY_EmptyBufferDone; 2243 pCompPrv->proxyFillBufferDone = PROXY_FillBufferDone; 2244 pCompPrv->proxyEventHandler = PROXY_EventHandler; 2245 2246 for (i=0; i<PROXY_MAXNUMOFPORTS ; i++) 2247 { 2248 pCompPrv->proxyPortBuffers[i].proxyBufferType = VirtualPointers; 2249 } 2250 2251 eRPCError = RPC_InstanceInit(pCompPrv->cCompName, &hRemoteComp); 2252 PROXY_assert(eRPCError == RPC_OMX_ErrorNone, 2253 OMX_ErrorUndefined, "Error initializing RPC"); 2254 PROXY_assert(hRemoteComp != NULL, 2255 OMX_ErrorUndefined, "Error initializing RPC"); 2256 2257 //Send the proxy component handle for pAppData 2258 eRPCError = 2259 RPC_GetHandle(hRemoteComp, pCompPrv->cCompName, 2260 (OMX_PTR) hComponent, NULL, &eCompReturn); 2261 2262 PROXY_checkRpcError(); 2263 2264 hComp->SetCallbacks = PROXY_SetCallbacks; 2265 hComp->ComponentDeInit = PROXY_ComponentDeInit; 2266 hComp->UseBuffer = PROXY_UseBuffer; 2267 hComp->GetParameter = PROXY_GetParameter; 2268 hComp->SetParameter = PROXY_SetParameter; 2269 hComp->EmptyThisBuffer = PROXY_EmptyThisBuffer; 2270 hComp->FillThisBuffer = PROXY_FillThisBuffer; 2271 hComp->GetComponentVersion = PROXY_GetComponentVersion; 2272 hComp->SendCommand = PROXY_SendCommand; 2273 hComp->GetConfig = PROXY_GetConfig; 2274 hComp->SetConfig = PROXY_SetConfig; 2275 hComp->GetState = PROXY_GetState; 2276 hComp->GetExtensionIndex = PROXY_GetExtensionIndex; 2277 hComp->FreeBuffer = PROXY_FreeBuffer; 2278 hComp->ComponentRoleEnum = PROXY_ComponentRoleEnum; 2279 hComp->AllocateBuffer = PROXY_AllocateBuffer; 2280 hComp->ComponentTunnelRequest = PROXY_ComponentTunnelRequest; 2281 hComp->UseEGLImage = PROXY_UseEGLImage; 2282 2283 pCompPrv->hRemoteComp = hRemoteComp; 2284 2285 #ifdef USE_ION 2286 pCompPrv->bUseIon = OMX_TRUE; 2287 pCompPrv->bMapIonBuffers = OMX_TRUE; 2288 2289 pCompPrv->ion_fd = ion_open(); 2290 if(pCompPrv->ion_fd == 0) 2291 { 2292 DOMX_ERROR("ion_open failed!!!"); 2293 return OMX_ErrorInsufficientResources; 2294 } 2295 #endif 2296 2297 KPI_OmxCompInit(hComponent); 2298 2299 EXIT: 2300 if (eError != OMX_ErrorNone) 2301 RPC_InstanceDeInit(hRemoteComp); 2302 DOMX_EXIT("eError: %d", eError); 2303 2304 return eError; 2305 } 2306 2307 2308 2309 /* ===========================================================================*/ 2310 /** 2311 * @name RPC_UTIL_GetStride() 2312 * @brief Gets stride on this port. Used to determine whether buffer is 1D or 2D 2313 * @param hRemoteComp [IN] : Remote component handle. 2314 * @param nPortIndex [IN] : Port index. 2315 * @param nStride [OUT] : Stride returned by the component. 2316 * @return OMX_ErrorNone = Successful 2317 */ 2318 /* ===========================================================================*/ 2319 OMX_ERRORTYPE RPC_UTIL_GetStride(OMX_COMPONENTTYPE * hRemoteComp, 2320 OMX_U32 nPortIndex, OMX_U32 * nStride) 2321 { 2322 OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone; 2323 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 2324 OMX_PARAM_PORTDEFINITIONTYPE sPortDef; 2325 2326 /*Initializing Structure */ 2327 sPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE); 2328 sPortDef.nVersion.s.nVersionMajor = OMX_VER_MAJOR; 2329 sPortDef.nVersion.s.nVersionMinor = OMX_VER_MINOR; 2330 sPortDef.nVersion.s.nRevision = 0x0; 2331 sPortDef.nVersion.s.nStep = 0x0; 2332 sPortDef.nPortIndex = nPortIndex; 2333 2334 eRPCError = 2335 RPC_GetParameter(hRemoteComp, OMX_IndexParamPortDefinition, 2336 (OMX_PTR) (&sPortDef), NULL, &eCompReturn); 2337 PROXY_checkRpcError(); 2338 2339 if (sPortDef.eDomain == OMX_PortDomainVideo) 2340 { 2341 *nStride = sPortDef.format.video.nStride; 2342 } else if (sPortDef.eDomain == OMX_PortDomainImage) 2343 { 2344 *nStride = sPortDef.format.image.nStride; 2345 } else if (sPortDef.eDomain == OMX_PortDomainMax && nPortIndex == 0) 2346 { 2347 /*Temp - just for testing sample */ 2348 *nStride = LINUX_PAGE_SIZE; 2349 } else 2350 { 2351 *nStride = 0; 2352 } 2353 2354 EXIT: 2355 return eError; 2356 } 2357 2358 2359 2360 /* ===========================================================================*/ 2361 /** 2362 * @name RPC_UTIL_GetNumLines() 2363 * @brief 2364 * @param void 2365 * @return OMX_ErrorNone = Successful 2366 * @sa TBD 2367 * 2368 */ 2369 /* ===========================================================================*/ 2370 OMX_ERRORTYPE RPC_UTIL_GetNumLines(OMX_COMPONENTTYPE * hRemoteComp, 2371 OMX_U32 nPortIndex, OMX_U32 * nNumOfLines) 2372 { 2373 OMX_ERRORTYPE eError = OMX_ErrorNone; 2374 OMX_ERRORTYPE eCompReturn; 2375 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 2376 OMX_BOOL bUseEnhancedPortReconfig = OMX_FALSE; 2377 2378 OMX_PARAM_PORTDEFINITIONTYPE portDef; 2379 OMX_CONFIG_RECTTYPE sRect; 2380 2381 DOMX_ENTER(""); 2382 2383 /*initializing Structure */ 2384 portDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE); 2385 portDef.nVersion.s.nVersionMajor = 0x1; 2386 portDef.nVersion.s.nVersionMinor = 0x1; 2387 portDef.nVersion.s.nRevision = 0x0; 2388 portDef.nVersion.s.nStep = 0x0; 2389 2390 portDef.nPortIndex = nPortIndex; 2391 2392 sRect.nSize = sizeof(OMX_CONFIG_RECTTYPE); 2393 sRect.nVersion.s.nVersionMajor = 0x1; 2394 sRect.nVersion.s.nVersionMinor = 0x1; 2395 sRect.nVersion.s.nRevision = 0x0; 2396 sRect.nVersion.s.nStep = 0x0; 2397 2398 sRect.nPortIndex = nPortIndex; 2399 sRect.nLeft = 0; 2400 sRect.nTop = 0; 2401 sRect.nHeight = 0; 2402 sRect.nWidth = 0; 2403 2404 #ifdef USE_ENHANCED_PORTRECONFIG 2405 bUseEnhancedPortReconfig = OMX_TRUE; 2406 #endif 2407 eRPCError = RPC_GetParameter(hRemoteComp, 2408 OMX_TI_IndexParam2DBufferAllocDimension, 2409 (OMX_PTR) & sRect, NULL, &eCompReturn); 2410 if (eRPCError == RPC_OMX_ErrorNone) 2411 { 2412 DOMX_DEBUG(" PROXY_UTIL Get Parameter Successful"); 2413 eError = eCompReturn; 2414 } else 2415 { 2416 DOMX_ERROR("RPC_GetParameter returned error 0x%x", eRPCError); 2417 eError = OMX_ErrorUndefined; 2418 goto EXIT; 2419 } 2420 2421 if (eCompReturn == OMX_ErrorNone && bUseEnhancedPortReconfig == OMX_FALSE) 2422 { 2423 *nNumOfLines = sRect.nHeight; 2424 } else if (eCompReturn == OMX_ErrorUnsupportedIndex || bUseEnhancedPortReconfig == OMX_TRUE) 2425 { 2426 eRPCError = 2427 RPC_GetParameter(hRemoteComp, 2428 OMX_IndexParamPortDefinition, (OMX_PTR) & portDef, 2429 NULL, &eCompReturn); 2430 2431 if (eRPCError == RPC_OMX_ErrorNone) 2432 { 2433 DOMX_DEBUG(" PROXY_UTIL Get Parameter Successful"); 2434 eError = eCompReturn; 2435 } else 2436 { 2437 DOMX_ERROR("RPC_GetParameter returned error 0x%x", 2438 eRPCError); 2439 eError = OMX_ErrorUndefined; 2440 goto EXIT; 2441 } 2442 2443 if (eCompReturn == OMX_ErrorNone) 2444 { 2445 2446 //start with 1 meaning 1D buffer 2447 *nNumOfLines = 1; 2448 2449 if (portDef.eDomain == OMX_PortDomainVideo) 2450 { 2451 *nNumOfLines = 2452 portDef.format.video.nFrameHeight; 2453 //DOMX_DEBUG("Port definition Type is video..."); 2454 //DOMX_DEBUG("&&Colorformat is:%p", portDef.format.video.eColorFormat); 2455 //DOMX_DEBUG("nFrameHeight is:%d", portDef.format.video.nFrameHeight); 2456 //*nNumOfLines = portDef.format.video.nFrameHeight; 2457 2458 //if((portDef.format.video.eColorFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar) || 2459 // (portDef.format.video.eColorFormat == OMX_COLOR_FormatYUV420Planar)) 2460 //{ 2461 //DOMX_DEBUG("Setting FrameHeight as Number of lines..."); 2462 //*nNumOfLines = portDef.format.video.nFrameHeight; 2463 //} 2464 } else if (portDef.eDomain == OMX_PortDomainImage) 2465 { 2466 DOMX_DEBUG 2467 ("Image DOMAIN TILER SUPPORT for NV12 format only"); 2468 *nNumOfLines = 2469 portDef.format.image.nFrameHeight; 2470 } else if (portDef.eDomain == OMX_PortDomainAudio) 2471 { 2472 DOMX_DEBUG("Audio DOMAIN TILER SUPPORT"); 2473 } else if (portDef.eDomain == OMX_PortDomainOther) 2474 { 2475 DOMX_DEBUG("Other DOMAIN TILER SUPPORT"); 2476 } else 2477 { //this is the sample component test 2478 //Temporary - just to get check functionality 2479 DOMX_DEBUG("Sample component TILER SUPPORT"); 2480 *nNumOfLines = 4; 2481 } 2482 } else 2483 { 2484 DOMX_ERROR(" ERROR IN RECOVERING UV POINTER"); 2485 } 2486 } else 2487 { 2488 DOMX_ERROR(" ERROR IN RECOVERING UV POINTER"); 2489 } 2490 2491 DOMX_DEBUG("Port Number: %d :: NumOfLines %d", nPortIndex, 2492 *nNumOfLines); 2493 2494 EXIT: 2495 DOMX_EXIT("eError: %d", eError); 2496 return eError; 2497 } 2498 2499 2500 /* ===========================================================================*/ 2501 /** 2502 * @name _RPC_IsProxyComponent() 2503 * @brief This function calls GetComponentVersion API on the component and 2504 * based on the component name decidec whether the component is a proxy 2505 * or real component. The naming component convention assumed is 2506 * <OMX>.<Company Name>.<Core Name>.<Domain>.<Component Details> with 2507 * all characters in upper case for e.g. OMX.TI.DUCATI1.VIDEO.H264E 2508 * @param hComponent [IN] : The component handle 2509 * bIsProxy [OUT] : Set to true is handle is for a proxy component 2510 * @return OMX_ErrorNone = Successful 2511 * 2512 **/ 2513 /* ===========================================================================*/ 2514 OMX_ERRORTYPE _RPC_IsProxyComponent(OMX_HANDLETYPE hComponent, 2515 OMX_BOOL * bIsProxy) 2516 { 2517 OMX_ERRORTYPE eError = OMX_ErrorNone; 2518 OMX_S8 cComponentName[MAXNAMESIZE] = { 0 } 2519 , cCoreName[32] = 2520 { 2521 0}; 2522 OMX_VERSIONTYPE sCompVer, sSpecVer; 2523 OMX_UUIDTYPE sCompUUID; 2524 OMX_U32 i = 0, ret = 0; 2525 2526 eError = 2527 OMX_GetComponentVersion(hComponent, (OMX_STRING) cComponentName, 2528 &sCompVer, &sSpecVer, &sCompUUID); 2529 PROXY_assert(eError == OMX_ErrorNone, eError, ""); 2530 ret = 2531 sscanf((char *)cComponentName, "%*[^'.'].%*[^'.'].%[^'.'].%*s", 2532 cCoreName); 2533 PROXY_assert(ret == 1, OMX_ErrorBadParameter, 2534 "Incorrect component name"); 2535 for (i = 0; i < CORE_MAX; i++) 2536 { 2537 if (strcmp((char *)cCoreName, Core_Array[i]) == 0) 2538 break; 2539 } 2540 PROXY_assert(i < CORE_MAX, OMX_ErrorBadParameter, 2541 "Unknown core name"); 2542 2543 /* If component name indicates remote core, it means proxy 2544 component */ 2545 if ((i == CORE_SYSM3) || (i == CORE_APPM3) || (i == CORE_TESLA)) 2546 *bIsProxy = OMX_TRUE; 2547 else 2548 *bIsProxy = OMX_FALSE; 2549 2550 EXIT: 2551 return eError; 2552 } 2553
