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_rpc_stub.c 35 * This file contains methods that provides the functionality for 36 * the OpenMAX1.1 DOMX Framework RPC Stub implementations. 37 * 38 * @path \WTSD_DucatiMMSW\framework\domx\omx_rpc\src 39 * 40 * @rev 1.0 41 */ 42 43/*============================================================== 44 *! Revision History 45 *! ============================ 46 *! 30-Apr-2010 Abhishek Ranka : Fixed GetExtension issue 47 *! 48 *! 29-Mar-2010 Abhishek Ranka : Revamped DOMX implementation 49 *! 50 *! 19-August-2009 B Ravi Kiran ravi.kiran@ti.com: Initial Version 51 *================================================================*/ 52/****************************************************************** 53 * INCLUDE FILES 54 ******************************************************************/ 55#include <errno.h> 56#include <string.h> 57#include <stdio.h> 58#include <unistd.h> 59 60#include "omx_rpc.h" 61#include "omx_rpc_utils.h" 62#include "omx_proxy_common.h" 63#include "omx_rpc_stub.h" 64#include <OMX_TI_Common.h> 65#include <timm_osal_interfaces.h> 66 67#include <linux/rpmsg_omx.h> 68#include "rpmsg_omx_defs.h" 69 70/****************************************************************** 71 * EXTERNS 72 ******************************************************************/ 73 74/****************************************************************** 75 * MACROS - LOCAL 76 ******************************************************************/ 77 78//#define RPC_MSGPIPE_SIZE (4) 79#define RPC_MSG_SIZE_FOR_PIPE (sizeof(OMX_PTR)) 80 81/* When this is defined ETB/FTB calls are made in sync mode. Undefining will 82 * result in these calls being sent via async mode. Sync mode leads to correct 83 * functionality as per OMX spec but has a slight performance penalty. Async 84 * mode sacrifices strict adherence to spec for some gain in performance. */ 85#define RPC_SYNC_MODE 86 87 88#define RPC_getPacket(nPacketSize, pPacket) do { \ 89 pPacket = TIMM_OSAL_Malloc(nPacketSize, TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT); \ 90 RPC_assert(pPacket != NULL, RPC_OMX_ErrorInsufficientResources, \ 91 "Error Allocating RCM Message Frame"); \ 92 TIMM_OSAL_Memset(pPacket, 0, nPacketSize); \ 93 } while(0) 94 95#define RPC_freePacket(pPacket) do { \ 96 if(pPacket != NULL) TIMM_OSAL_Free(pPacket); \ 97 } while(0) 98 99#define RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, nSize) do { \ 100 status = write(hCtx->fd_omx, pPacket, nPacketSize); \ 101 RPC_freePacket(pPacket); \ 102 pPacket = NULL; \ 103 if(status < 0 && errno == ENXIO) { \ 104 RPC_assert(0, RPC_OMX_ErrorHardware, "Write failed - Ducati in faulty state"); \ 105 } \ 106 if(status != (signed)nPacketSize) { \ 107 DOMX_ERROR("Write failed returning status = 0x%x",status); \ 108 RPC_assert(0, RPC_OMX_ErrorUndefined, "Write failed"); \ 109 } \ 110 eError = TIMM_OSAL_ReadFromPipe(hCtx->pMsgPipe[nFxnIdx], &pRetPacket, \ 111 RPC_MSG_SIZE_FOR_PIPE, (TIMM_OSAL_U32 *)(&nSize), TIMM_OSAL_SUSPEND); \ 112 RPC_assert(eError == TIMM_OSAL_ERR_NONE, eError, \ 113 "Read failed"); \ 114 } while(0) 115 116/*Set bit 31 on fxn idx as it is static function*/ 117#define RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize) do { \ 118 pOmxPacket = (struct omx_packet *)pPacket; \ 119 pData = pOmxPacket->data; \ 120 pOmxPacket->desc |= OMX_DESC_MSG << OMX_DESC_TYPE_SHIFT; \ 121 pOmxPacket->msg_id = 0; \ 122 pOmxPacket->flags = OMX_POOLID_JOBID_DEFAULT; \ 123 pOmxPacket->fxn_idx = (nFxnIdx | 0x80000000); \ 124 pOmxPacket->result = 0; \ 125 pOmxPacket->data_size = nPacketSize; \ 126 } while(0) 127 128//Async to be checked later - most probably same as sync but without the read 129#if 0 130 131#define RPC_sendPacket_async(HRCM, pPacket, nFxnIdx) do { \ 132 pPacket->nFxnIdx = nFxnIdx; \ 133 status = RcmClient_execCmd(HRCM, pPacket); \ 134 if(status < 0) { \ 135 RPC_freePacket(HRCM, pPacket); \ 136 pPacket = NULL; \ 137 RPC_assert(0, RPC_OMX_RCM_ErrorExecFail, \ 138 "RcmClient_exec failed"); \ 139 } \ 140 } while(0) 141 142#define RPC_checkAsyncErrors(rcmHndl, pPacket) do { \ 143 status = RcmClient_checkForError(rcmHndl, &pPacket); \ 144 if(status < 0) { \ 145 RPC_freePacket(rcmHndl, pPacket); \ 146 pPacket = NULL; \ 147 } \ 148 RPC_assert(status >= 0, RPC_OMX_RCM_ClientFail, \ 149 "Async error check returned error"); \ 150 } while(0) 151 152#endif 153/* ===========================================================================*/ 154/** 155 * @name RPC_GetHandle() 156 * @brief Remote invocation stub for OMX_GetHandle 157 * @param hRPCCtx [OUT] : The RPC context handle. 158 * @param cComponentName [IN] : Name of the component that is to be created 159 * on Remote core. 160 * @param pAppData [IN] : The AppData passed by the user. 161 * @param pCallBacks [IN] : The callback pointers passed by the caller. 162 * @param eCompReturn [OUT] : This is return value returned by the remote 163 * component. 164 * @return RPC_OMX_ErrorNone = Successful 165 */ 166/* ===========================================================================*/ 167RPC_OMX_ERRORTYPE RPC_GetHandle(OMX_HANDLETYPE hRPCCtx, 168 OMX_STRING cComponentName, OMX_PTR pAppData, 169 OMX_CALLBACKTYPE * pCallBacks, OMX_ERRORTYPE * eCompReturn) 170{ 171 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 172 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 173 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 174 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 175 NULL, pRetData = NULL; 176 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 177 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 178 OMX_HANDLETYPE hComp = NULL; 179 OMX_HANDLETYPE hActualComp = NULL; 180 OMX_S32 status = 0; 181 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 182 struct omx_packet *pOmxPacket = NULL; 183 184 DOMX_ENTER(""); 185 DOMX_DEBUG("RPC_GetHandle: Recieved GetHandle request from %s", 186 cComponentName); 187 188 nFxnIdx = RPC_OMX_FXN_IDX_GET_HANDLE; 189 RPC_getPacket(nPacketSize, pPacket); 190 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 191 192 DOMX_DEBUG("Packing data"); 193 /*No buffer mapping required */ 194 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 195 RPC_OMX_MAP_INFO_TYPE); 196 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 197 198 RPC_SETFIELDCOPYGEN(pData, nPos, cComponentName, 199 OMX_MAX_STRINGNAME_SIZE); 200 RPC_SETFIELDVALUE(pData, nPos, pAppData, OMX_PTR); 201 202 DOMX_DEBUG("Sending data"); 203 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 204 nSize); 205 206 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 207 208 if (*eCompReturn == OMX_ErrorNone) 209 { 210 pRetData = ((struct omx_packet *) pRetPacket)->data; 211 RPC_GETFIELDVALUE(pRetData, nPos, hComp, OMX_HANDLETYPE); 212 DOMX_DEBUG("Remote Handle 0x%x", hComp); 213 hCtx->hRemoteHandle = hComp; 214 /* The handle received above is used for all communications 215 with the remote component but is not the actual component 216 handle (it is actually the rpc context handle which 217 contains lot of other info). The handle recd. below is the 218 actual remote component handle. This is used at present for 219 mark buffer implementation since in that case it is not 220 feasible to send the context handle */ 221 RPC_GETFIELDVALUE(pRetData, nPos, hActualComp, 222 OMX_HANDLETYPE); 223 DOMX_DEBUG("Actual Remote Comp Handle 0x%x", hActualComp); 224 hCtx->hActualRemoteCompHandle = hActualComp; 225 } 226 227 /* Save context information */ 228 hCtx->pAppData = pAppData; 229 230 EXIT: 231 if (pPacket) 232 RPC_freePacket(pPacket); 233 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 234 RPC_freePacket(pRetPacket); 235 236 DOMX_EXIT(""); 237 return eRPCError; 238} 239 240 241 242/* ===========================================================================*/ 243/** 244 * @name RPC_FreeHandle() 245 * @brief Remote invocation stub for OMX_FreeHandle 246 * @param hRPCCtx [IN] : The RPC context handle. 247 * @param eCompReturn [OUT] : Return value returned by the remote component. 248 * @return RPC_OMX_ErrorNone = Successful 249 */ 250/* ===========================================================================*/ 251RPC_OMX_ERRORTYPE RPC_FreeHandle(OMX_HANDLETYPE hRPCCtx, 252 OMX_ERRORTYPE * eCompReturn) 253{ 254 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 255 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 256 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 257 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 258 OMX_S32 status = 0; 259 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 260 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 261 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 262 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 263 struct omx_packet *pOmxPacket = NULL; 264 265 DOMX_ENTER(""); 266 267 nFxnIdx = RPC_OMX_FXN_IDX_FREE_HANDLE; 268 RPC_getPacket(nPacketSize, pPacket); 269 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 270 271 /*No buffer mapping required */ 272 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 273 RPC_OMX_MAP_INFO_TYPE); 274 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 275 276 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 277 278 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 279 nSize); 280 281 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 282 283 EXIT: 284 if (pPacket) 285 RPC_freePacket(pPacket); 286 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 287 RPC_freePacket(pRetPacket); 288 289 DOMX_EXIT(""); 290 return eRPCError; 291 292} 293 294 295 296/* ===========================================================================*/ 297/** 298 * @name RPC_SetParameter() 299 * @brief Remote invocation stub for OMX_SetParameter 300 * @param hRPCCtx [IN] : The RPC context handle. 301 * @param nParamIndex [IN] : Same as nParamIndex received at the proxy. 302 * @param pCompParam [IN] : Same as pCompParam recieved at the proxy. 303 * @param eCompReturn [OUT] : Return value returned by the remote component. 304 * @return RPC_OMX_ErrorNone = Successful 305 */ 306/* ===========================================================================*/ 307RPC_OMX_ERRORTYPE RPC_SetParameter(OMX_HANDLETYPE hRPCCtx, 308 OMX_INDEXTYPE nParamIndex, OMX_PTR pCompParam, 309 OMX_PTR pLocBufNeedMap, OMX_U32 nNumOfLocalBuf, OMX_ERRORTYPE * eCompReturn) 310{ 311 312 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 313 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 314 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 315 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 316 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 317 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 318 OMX_S32 status = 0; 319 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 320 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 321 OMX_U32 structSize = 0; 322 struct omx_packet *pOmxPacket = NULL; 323 324 nFxnIdx = RPC_OMX_FXN_IDX_SET_PARAMETER; 325 RPC_getPacket(nPacketSize, pPacket); 326 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 327 328 if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompParam) >= 0 ) { 329 if (nNumOfLocalBuf == 1) { 330 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF, 331 RPC_OMX_MAP_INFO_TYPE); 332 } 333 else if (nNumOfLocalBuf == 2) { 334 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_TWO_BUF, 335 RPC_OMX_MAP_INFO_TYPE); 336 } 337 nOffset = (pLocBufNeedMap - pCompParam) + 338 sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) + 339 sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE); 340 } else { 341 /*No buffer mapping required */ 342 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 343 RPC_OMX_MAP_INFO_TYPE); 344 } 345 346 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 347 348 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 349 RPC_SETFIELDVALUE(pData, nPos, nParamIndex, OMX_INDEXTYPE); 350 structSize = RPC_UTIL_GETSTRUCTSIZE(pCompParam); 351 RPC_SETFIELDCOPYGEN(pData, nPos, pCompParam, structSize); 352 353 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 354 nSize); 355 356 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 357 358 EXIT: 359 if (pPacket) 360 RPC_freePacket(pPacket); 361 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 362 RPC_freePacket(pRetPacket); 363 364 DOMX_EXIT(""); 365 return eRPCError; 366} 367 368 369 370/* ===========================================================================*/ 371/** 372 * @name RPC_GetParameter() 373 * @brief Remote invocation stub for OMX_GetParameter 374 * @param hRPCCtx [IN] : The RPC context handle. 375 * @param nParamIndex [IN] : Same as nParamIndex received at the proxy. 376 * @param pCompParam [IN] : Same as pCompParam recieved at the proxy. 377 * @param eCompReturn [OUT] : Return value returned by the remote component. 378 * @return RPC_OMX_ErrorNone = Successful 379 */ 380/* ===========================================================================*/ 381RPC_OMX_ERRORTYPE RPC_GetParameter(OMX_HANDLETYPE hRPCCtx, 382 OMX_INDEXTYPE nParamIndex, OMX_PTR pCompParam, 383 OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * eCompReturn) 384{ 385 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 386 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 387 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 388 NULL, pRetData = NULL; 389 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 390 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 391 OMX_U32 nPos = 0, nSize = 0, nDataOffset = 0, nOffset = 0; 392 OMX_S32 status = 0; 393 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 394 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 395 OMX_U32 structSize = 0; 396 struct omx_packet *pOmxPacket = NULL; 397 398 DOMX_ENTER(""); 399 400 nFxnIdx = RPC_OMX_FXN_IDX_GET_PARAMETER; 401 RPC_getPacket(nPacketSize, pPacket); 402 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 403 404 if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompParam) >= 0 ) { 405 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF, 406 RPC_OMX_MAP_INFO_TYPE); 407 nOffset = (pLocBufNeedMap - pCompParam) + 408 sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) + 409 sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE); 410 } else { 411 /*No buffer mapping required */ 412 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 413 RPC_OMX_MAP_INFO_TYPE); 414 } 415 416 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 417 418 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 419 RPC_SETFIELDVALUE(pData, nPos, nParamIndex, OMX_INDEXTYPE); 420 nDataOffset = nPos; 421 structSize = RPC_UTIL_GETSTRUCTSIZE(pCompParam); 422 RPC_SETFIELDCOPYGEN(pData, nPos, pCompParam, structSize); 423 424 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 425 nSize); 426 427 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 428 429 if (*eCompReturn == OMX_ErrorNone) 430 { 431 pRetData = ((struct omx_packet *) pRetPacket)->data; 432 /*pCompParam is returned in the same location in which it was sent */ 433 RPC_GETFIELDCOPYGEN(pRetData, nDataOffset, pCompParam, 434 structSize); 435 } 436 437 EXIT: 438 if (pPacket) 439 RPC_freePacket(pPacket); 440 //In case of Error Hardware this packet gets freed in omx_rpc.c 441 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 442 RPC_freePacket(pRetPacket); 443 444 DOMX_EXIT(""); 445 return eRPCError; 446} 447 448 449 450/* ===========================================================================*/ 451/** 452 * @name RPC_SetConfig() 453 * @brief Remote invocation stub for OMX_SetConfig 454 * @param hRPCCtx [IN] : The RPC context handle. 455 * @param nConfigIndex [IN] : Same as nConfigIndex received at the proxy. 456 * @param pCompConfig [IN] : Same as pCompConfig recieved at the proxy. 457 * @param eCompReturn [OUT] : Return value returned by the remote component. 458 * @return RPC_OMX_ErrorNone = Successful 459 */ 460/* ===========================================================================*/ 461RPC_OMX_ERRORTYPE RPC_SetConfig(OMX_HANDLETYPE hRPCCtx, 462 OMX_INDEXTYPE nConfigIndex, OMX_PTR pCompConfig, 463 OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * eCompReturn) 464{ 465 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 466 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 467 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 468 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 469 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 470 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 471 OMX_S32 status = 0; 472 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 473 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 474 OMX_U32 structSize = 0; 475 struct omx_packet *pOmxPacket = NULL; 476 477 DOMX_ENTER(""); 478 479 nFxnIdx = RPC_OMX_FXN_IDX_SET_CONFIG; 480 RPC_getPacket(nPacketSize, pPacket); 481 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 482 483 if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompConfig) >= 0 ) { 484 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF, 485 RPC_OMX_MAP_INFO_TYPE); 486 nOffset = (pLocBufNeedMap - pCompConfig) + 487 sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) + 488 sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE); 489 } else { 490 /*No buffer mapping required */ 491 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 492 RPC_OMX_MAP_INFO_TYPE); 493 } 494 495 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 496 497 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 498 RPC_SETFIELDVALUE(pData, nPos, nConfigIndex, OMX_INDEXTYPE); 499 structSize = RPC_UTIL_GETSTRUCTSIZE(pCompConfig); 500 RPC_SETFIELDCOPYGEN(pData, nPos, pCompConfig, structSize); 501 502 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 503 nSize); 504 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 505 506 EXIT: 507 if (pPacket) 508 RPC_freePacket(pPacket); 509 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 510 RPC_freePacket(pRetPacket); 511 512 DOMX_EXIT(""); 513 return eRPCError; 514} 515 516/* ===========================================================================*/ 517/** 518 * @name RPC_GetConfig() 519 * @brief Remote invocation stub for OMX_GetConfig 520 * @param hRPCCtx [IN] : The RPC context handle. 521 * @param nConfigIndex [IN] : Same as nConfigIndex received at the proxy. 522 * @param pCompConfig [IN] : Same as pCompConfig recieved at the proxy. 523 * @param eCompReturn [OUT] : Return value returned by the remote component. 524 * @return RPC_OMX_ErrorNone = Successful 525 */ 526/* ===========================================================================*/ 527RPC_OMX_ERRORTYPE RPC_GetConfig(OMX_HANDLETYPE hRPCCtx, 528 OMX_INDEXTYPE nConfigIndex, OMX_PTR pCompConfig, 529 OMX_PTR pLocBufNeedMap, OMX_ERRORTYPE * eCompReturn) 530{ 531 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 532 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 533 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 534 NULL, pRetData = NULL; 535 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 536 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 537 OMX_U32 nPos = 0, nSize = 0, nOffset = 0, nDataOffset = 0; 538 OMX_S32 status = 0; 539 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 540 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 541 OMX_U32 structSize = 0; 542 struct omx_packet *pOmxPacket = NULL; 543 544 DOMX_ENTER(""); 545 546 nFxnIdx = RPC_OMX_FXN_IDX_GET_CONFIG; 547 RPC_getPacket(nPacketSize, pPacket); 548 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 549 550 if (pLocBufNeedMap != NULL && (pLocBufNeedMap - pCompConfig) >= 0 ) { 551 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF, 552 RPC_OMX_MAP_INFO_TYPE); 553 nOffset = (pLocBufNeedMap - pCompConfig) + 554 sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) + 555 sizeof(OMX_HANDLETYPE) + sizeof(OMX_INDEXTYPE); 556 } else { 557 /*No buffer mapping required */ 558 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 559 RPC_OMX_MAP_INFO_TYPE); 560 } 561 562 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 563 564 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 565 RPC_SETFIELDVALUE(pData, nPos, nConfigIndex, OMX_INDEXTYPE); 566 nDataOffset = nPos; 567 structSize = RPC_UTIL_GETSTRUCTSIZE(pCompConfig); 568 RPC_SETFIELDCOPYGEN(pData, nPos, pCompConfig, structSize); 569 570 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 571 nSize); 572 573 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 574 575 if (*eCompReturn == RPC_OMX_ErrorNone) 576 { 577 pRetData = ((struct omx_packet *) pRetPacket)->data; 578 /*pCompParam is returned in the same location in which it was sent */ 579 RPC_GETFIELDCOPYGEN(pRetData, nDataOffset, pCompConfig, 580 structSize); 581 } 582 583 EXIT: 584 if (pPacket) 585 RPC_freePacket(pPacket); 586 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 587 RPC_freePacket(pRetPacket); 588 589 DOMX_EXIT(""); 590 return eRPCError; 591} 592 593 594 595/* ===========================================================================*/ 596/** 597 * @name RPC_SendCommand() 598 * @brief Remote invocation stub for OMX_SendCommand 599 * @param hRPCCtx [IN] : The RPC context handle. 600 * @param eCmd [IN] : Same as eCmd received at the proxy. 601 * @param nParam [IN] : Same as nParam recieved at the proxy. 602 * @param pCmdData [IN] : Same as pCmdData recieved at the proxy. 603 * @param eCompReturn [OUT] : Return value returned by the remote component. 604 * @return RPC_OMX_ErrorNone = Successful 605 */ 606/* ===========================================================================*/ 607RPC_OMX_ERRORTYPE RPC_SendCommand(OMX_HANDLETYPE hRPCCtx, 608 OMX_COMMANDTYPE eCmd, OMX_U32 nParam, OMX_PTR pCmdData, 609 OMX_ERRORTYPE * eCompReturn) 610{ 611 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 612 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 613 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 614 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 615 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 616 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 617 OMX_S32 status = 0; 618 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 619 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 620 OMX_U32 structSize = 0; 621 struct omx_packet *pOmxPacket = NULL; 622 623 DOMX_ENTER(""); 624 625 nFxnIdx = RPC_OMX_FXN_IDX_SEND_CMD; 626 RPC_getPacket(nPacketSize, pPacket); 627 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 628 629 /*No buffer mapping required */ 630 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 631 RPC_OMX_MAP_INFO_TYPE); 632 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 633 634 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 635 RPC_SETFIELDVALUE(pData, nPos, eCmd, OMX_COMMANDTYPE); 636 RPC_SETFIELDVALUE(pData, nPos, nParam, OMX_U32); 637 638 if (pCmdData != NULL && eCmd == OMX_CommandMarkBuffer) 639 { 640 /*The RPC_UTIL_GETSTRUCTSIZE will not work here since OMX_MARKTYPE structure 641 does not have nSize field */ 642 structSize = sizeof(OMX_MARKTYPE); 643 RPC_SETFIELDCOPYGEN(pData, nPos, pCmdData, structSize); 644 } else if (pCmdData != NULL) 645 { 646 structSize = RPC_UTIL_GETSTRUCTSIZE(pCmdData); 647 RPC_SETFIELDCOPYGEN(pData, nPos, pCmdData, structSize); 648 } 649 650 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 651 nSize); 652 653 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 654 655 EXIT: 656 if (pPacket) 657 RPC_freePacket(pPacket); 658 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 659 RPC_freePacket(pRetPacket); 660 661 DOMX_EXIT(""); 662 return eRPCError; 663} 664 665 666 667/* ===========================================================================*/ 668/** 669 * @name RPC_GetState() 670 * @brief Remote invocation stub for OMX_GetState 671 * @param hRPCCtx [IN] : The RPC context handle. 672 * @param pState [OUT] : State variable, to be filled in and returned by 673 * the remote component.. 674 * @param eCompReturn [OUT] : Return value returned by the remote component. 675 * @return RPC_OMX_ErrorNone = Successful 676 */ 677/* ===========================================================================*/ 678RPC_OMX_ERRORTYPE RPC_GetState(OMX_HANDLETYPE hRPCCtx, OMX_STATETYPE * pState, 679 OMX_ERRORTYPE * eCompReturn) 680{ 681 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 682 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 683 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 684 NULL, pRetData = NULL; 685 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 686 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 687 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 688 OMX_S32 status = 0; 689 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 690 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 691 struct omx_packet *pOmxPacket = NULL; 692 693 DOMX_ENTER(""); 694 695 nFxnIdx = RPC_OMX_FXN_IDX_GET_STATE; 696 RPC_getPacket(nPacketSize, pPacket); 697 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 698 699 /*No buffer mapping required */ 700 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 701 RPC_OMX_MAP_INFO_TYPE); 702 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 703 704 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 705 706 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 707 nSize); 708 709 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 710 711 if (*eCompReturn == OMX_ErrorNone) 712 { 713 pRetData = ((struct omx_packet *) pRetPacket)->data; 714 RPC_GETFIELDCOPYTYPE(pRetData, nPos, pState, OMX_STATETYPE); 715 } 716 717 EXIT: 718 if (pPacket) 719 RPC_freePacket(pPacket); 720 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 721 RPC_freePacket(pRetPacket); 722 723 DOMX_EXIT(""); 724 return eRPCError; 725} 726 727 728 729/* ===========================================================================*/ 730/** 731 * @name RPC_GetComponentVersion() 732 * @brief Remote invocation stub for OMX_GetComponentVersion 733 * @param hRPCCtx [IN] : The RPC context handle. 734 * @param pComponentName [OUT] : Component name, to be filled in and returned 735 * by the remote component. 736 * @param pComponentVersion [OUT] : Component version info, to be filled in and 737 * returned by the remote component. 738 * @param pSpecVersion [OUT] : Spec version info, to be filled in and 739 * returned by the remote component. 740 * @param pComponentUUID [OUT] : Component UUID info, to be filled in and 741 * returned by the remote component (optional). 742 * @param eCompReturn [OUT] : Return value returned by the remote 743 * component. 744 * @return RPC_OMX_ErrorNone = Successful 745 */ 746/* ===========================================================================*/ 747RPC_OMX_ERRORTYPE RPC_GetComponentVersion(OMX_HANDLETYPE hRPCCtx, 748 OMX_STRING pComponentName, OMX_VERSIONTYPE * pComponentVersion, 749 OMX_VERSIONTYPE * pSpecVersion, OMX_UUIDTYPE * pComponentUUID, 750 OMX_ERRORTYPE * eCompReturn) 751{ 752 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 753 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 754 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 755 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 756 NULL, pRetData = NULL; 757 OMX_S32 status = 0; 758 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 759 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 760 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 761 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 762 struct omx_packet *pOmxPacket = NULL; 763 764 DOMX_ENTER(""); 765 766 nFxnIdx = RPC_OMX_FXN_IDX_GET_VERSION; 767 RPC_getPacket(nPacketSize, pPacket); 768 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 769 770 /*No buffer mapping required */ 771 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 772 RPC_OMX_MAP_INFO_TYPE); 773 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 774 775 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 776 777 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 778 nSize); 779 780 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 781 782 if (*eCompReturn == OMX_ErrorNone) 783 { 784 pRetData = ((struct omx_packet *) pRetPacket)->data; 785 RPC_GETFIELDCOPYGEN(pRetData, nPos, pComponentName, 786 OMX_MAX_STRINGNAME_SIZE); 787 RPC_GETFIELDCOPYTYPE(pRetData, nPos, pComponentVersion, 788 OMX_VERSIONTYPE); 789 RPC_GETFIELDCOPYTYPE(pRetData, nPos, pSpecVersion, 790 OMX_VERSIONTYPE); 791 memcpy(pComponentUUID,(OMX_UUIDTYPE *)( (OMX_U32)pRetData + nPos), sizeof(OMX_UUIDTYPE)); 792 } 793 794 EXIT: 795 if (pPacket) 796 RPC_freePacket(pPacket); 797 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 798 RPC_freePacket(pRetPacket); 799 800 return eRPCError; 801} 802 803 804 805/* ===========================================================================*/ 806/** 807 * @name RPC_GetExtensionIndex() 808 * @brief Remote invocation stub for OMX_GetExtensionIndex 809 * @param hRPCCtx [IN] : The RPC context handle. 810 * @param cParameterName [IN] : The parameter name sent by the user. 811 * @param pIndexType [OUT] : Index type returned by the remote component. 812 * @param eCompReturn [OUT] : Return value returned by the remote component. 813 * @return RPC_OMX_ErrorNone = Successful 814 */ 815/* ===========================================================================*/ 816RPC_OMX_ERRORTYPE RPC_GetExtensionIndex(OMX_HANDLETYPE hRPCCtx, 817 OMX_STRING cParameterName, OMX_INDEXTYPE * pIndexType, 818 OMX_ERRORTYPE * eCompReturn) 819{ 820 821 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 822 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 823 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 824 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 825 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 826 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 827 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 828 NULL, pRetData = NULL; 829 OMX_S32 status = 0; 830 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 831 struct omx_packet *pOmxPacket = NULL; 832 833 nFxnIdx = RPC_OMX_FXN_IDX_GET_EXT_INDEX; 834 835 RPC_getPacket(nPacketSize, pPacket); 836 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 837 838 /*No buffer mapping required */ 839 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 840 RPC_OMX_MAP_INFO_TYPE); 841 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 842 843 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 844 RPC_SETFIELDCOPYGEN(pData, nPos, cParameterName, 845 OMX_MAX_STRINGNAME_SIZE); 846 847 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 848 nSize); 849 850 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 851 852 if (*eCompReturn == OMX_ErrorNone) 853 { 854 pRetData = ((struct omx_packet *) pRetPacket)->data; 855 RPC_GETFIELDCOPYTYPE(pRetData, nPos, pIndexType, 856 OMX_INDEXTYPE); 857 } 858 859 EXIT: 860 if (pPacket) 861 RPC_freePacket(pPacket); 862 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 863 RPC_freePacket(pRetPacket); 864 865 return eRPCError; 866 867} 868 869/* ***************************** DATA APIs ******************************** */ 870 871/* ===========================================================================*/ 872/** 873 * @name RPC_AllocateBuffer() 874 * @brief Remote invocation stub for OMX_AllcateBuffer() 875 * @param size : Size of the incoming RCM message (parameter used in the RCM alloc call) 876 * @param *data : Pointer to the RCM message/buffer received 877 * @return RPC_OMX_ErrorNone = Successful 878 * @sa TBD 879 * 880 */ 881/* ===========================================================================*/ 882RPC_OMX_ERRORTYPE RPC_AllocateBuffer(OMX_HANDLETYPE hRPCCtx, 883 OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, OMX_IN OMX_U32 nPortIndex, 884 OMX_U32 * pBufHeaderRemote, OMX_PTR pAppPrivate, OMX_U32 nSizeBytes, 885 OMX_ERRORTYPE * eCompReturn) 886{ 887 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 888 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 889 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 890 NULL, pRetData = NULL; 891 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 892 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 893 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 894 OMX_S32 status = 0; 895 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 896 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 897 OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL; 898 OMX_BUFFERHEADERTYPE *pBufferHdr = *ppBufferHdr; 899 struct omx_packet *pOmxPacket = NULL; 900 901 DOMX_ENTER(""); 902 903 nFxnIdx = RPC_OMX_FXN_IDX_ALLOCATE_BUFFER; 904 RPC_getPacket(nPacketSize, pPacket); 905 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 906 907 /*No buffer mapping required */ 908 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 909 RPC_OMX_MAP_INFO_TYPE); 910 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 911 912 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 913 RPC_SETFIELDVALUE(pData, nPos, nPortIndex, OMX_U32); 914 RPC_SETFIELDVALUE(pData, nPos, pAppPrivate, OMX_PTR); 915 RPC_SETFIELDVALUE(pData, nPos, nSizeBytes, OMX_U32); 916 917 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 918 nSize); 919 920 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 921 922 if (*eCompReturn == OMX_ErrorNone) 923 { 924 pRetData = ((struct omx_packet *) pRetPacket)->data; 925 RPC_GETFIELDVALUE(pRetData, nPos, *pBufHeaderRemote, OMX_U32); 926 //save platform private before overwriting 927 pPlatformPrivate = (*ppBufferHdr)->pPlatformPrivate; 928 //RPC_GETFIELDCOPYTYPE(pData, nPos, pBufferHdr, OMX_BUFFERHEADERTYPE); 929 /*Copying each field of the header separately due to padding issues in 930 the buffer header structure */ 931 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nSize, OMX_U32); 932 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nVersion, 933 OMX_VERSIONTYPE); 934 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pBuffer, 935 OMX_U8 *); 936 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nAllocLen, 937 OMX_U32); 938 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFilledLen, 939 OMX_U32); 940 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nOffset, 941 OMX_U32); 942 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pAppPrivate, 943 OMX_PTR); 944 RPC_GETFIELDVALUE(pRetData, nPos, 945 pBufferHdr->pPlatformPrivate, OMX_PTR); 946 RPC_GETFIELDVALUE(pRetData, nPos, 947 pBufferHdr->pInputPortPrivate, OMX_PTR); 948 RPC_GETFIELDVALUE(pRetData, nPos, 949 pBufferHdr->pOutputPortPrivate, OMX_PTR); 950 RPC_GETFIELDVALUE(pRetData, nPos, 951 pBufferHdr->hMarkTargetComponent, OMX_HANDLETYPE); 952 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pMarkData, 953 OMX_PTR); 954 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTickCount, 955 OMX_U32); 956 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTimeStamp, 957 OMX_TICKS); 958 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFlags, 959 OMX_U32); 960 RPC_GETFIELDVALUE(pRetData, nPos, 961 pBufferHdr->nInputPortIndex, OMX_U32); 962 RPC_GETFIELDVALUE(pRetData, nPos, 963 pBufferHdr->nOutputPortIndex, OMX_U32); 964 965 (*ppBufferHdr)->pPlatformPrivate = pPlatformPrivate; 966 967#ifdef TILER_BUFF 968 DOMX_DEBUG(" Copying plat pvt. "); 969 //if (offset != 0) 970 { 971 RPC_GETFIELDCOPYTYPE(pRetData, nPos, 972 (OMX_TI_PLATFORMPRIVATE 973 *) ((*ppBufferHdr)->pPlatformPrivate), 974 OMX_TI_PLATFORMPRIVATE); 975 DOMX_DEBUG("Done copying plat pvt., aux buf = 0x%x", 976 ((OMX_TI_PLATFORMPRIVATE 977 *) ((*ppBufferHdr)->pPlatformPrivate))-> 978 pAuxBuf1); 979 } 980#endif 981 982 } else 983 { 984 //DOMX_DEBUG("OMX Error received: 0x%x", 985 // pRPCMsg->msgHeader.nOMXReturn); 986 } 987 988 EXIT: 989 if (pPacket) 990 RPC_freePacket(pPacket); 991 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 992 RPC_freePacket(pRetPacket); 993 994 DOMX_EXIT(""); 995 return eRPCError; 996} 997 998/* ===========================================================================*/ 999/** 1000 * @name RPC_UseBuffer() 1001 * @brief Remote invocation stub for OMX_AllcateBuffer() 1002 * @param hComp: This is the handle on the Remote core, the proxy will replace 1003 it's handle with actual OMX Component handle that recides on the specified core 1004 * @param ppBufferHdr: 1005 * @param nPortIndex: 1006 * @param pAppPrivate: 1007 * @param eCompReturn: This is return value that will be supplied by Proxy to the caller. 1008 * This is actual return value returned by the Remote component 1009 * @return RPC_OMX_ErrorNone = Successful 1010 * @sa TBD 1011 * 1012 */ 1013/* ===========================================================================*/ 1014RPC_OMX_ERRORTYPE RPC_UseBuffer(OMX_HANDLETYPE hRPCCtx, 1015 OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, OMX_U32 nPortIndex, 1016 OMX_PTR pAppPrivate, OMX_U32 nSizeBytes, OMX_U8 * pBuffer, 1017 OMX_U32 * pBufHeaderRemote, OMX_ERRORTYPE * eCompReturn) 1018{ 1019 1020 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1021 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 1022 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = 1023 NULL, pRetData = NULL; 1024 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 1025 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 1026 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 1027 OMX_S32 status = 0; 1028 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 1029 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 1030 OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL; 1031 OMX_BUFFERHEADERTYPE *pBufferHdr = *ppBufferHdr; 1032 struct omx_packet *pOmxPacket = NULL; 1033 RPC_OMX_MAP_INFO_TYPE eMapInfo = RPC_OMX_MAP_INFO_NONE; 1034 OMX_PTR pMetaDataBuffer = NULL; 1035 OMX_U32 a =32; 1036 1037 DOMX_ENTER(""); 1038 1039 nFxnIdx = RPC_OMX_FXN_IDX_USE_BUFFER; 1040 RPC_getPacket(nPacketSize, pPacket); 1041 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 1042 1043 DOMX_DEBUG("Marshaling data"); 1044 /*Buffer mapping required */ 1045 eMapInfo = RPC_OMX_MAP_INFO_ONE_BUF; 1046 if (((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)-> 1047 pAuxBuf1 != NULL) 1048 eMapInfo = RPC_OMX_MAP_INFO_TWO_BUF; 1049 if (((OMX_TI_PLATFORMPRIVATE *)pBufferHdr->pPlatformPrivate)-> 1050 pMetaDataBuffer != NULL) 1051 eMapInfo = RPC_OMX_MAP_INFO_THREE_BUF; 1052 1053 /*Offset is the location of the buffer pointer from the start of the data packet */ 1054 nOffset = 1055 sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) + 1056 sizeof(OMX_HANDLETYPE) + sizeof(OMX_U32) + sizeof(OMX_PTR) + 1057 sizeof(OMX_U32); 1058 RPC_SETFIELDVALUE(pData, nPos, eMapInfo, RPC_OMX_MAP_INFO_TYPE); 1059 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 1060 1061 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 1062 RPC_SETFIELDVALUE(pData, nPos, nPortIndex, OMX_U32); 1063 RPC_SETFIELDVALUE(pData, nPos, pAppPrivate, OMX_PTR); 1064 RPC_SETFIELDVALUE(pData, nPos, nSizeBytes, OMX_U32); 1065 1066 RPC_SETFIELDVALUE(pData, nPos, pBuffer, OMX_U32); 1067 DOMX_DEBUG("eMapInfo = %x",eMapInfo); 1068 if (eMapInfo >= RPC_OMX_MAP_INFO_TWO_BUF) 1069 { 1070 RPC_SETFIELDVALUE(pData, nPos, 1071 ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr-> 1072 pPlatformPrivate)->pAuxBuf1, OMX_U32); 1073 DOMX_DEBUG("UV buffer fd= %d",((OMX_TI_PLATFORMPRIVATE *)pBufferHdr->pPlatformPrivate)->pAuxBuf1); 1074 } 1075 1076 if (eMapInfo >= RPC_OMX_MAP_INFO_THREE_BUF) 1077 { 1078 RPC_SETFIELDVALUE(pData, nPos, 1079 ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr-> 1080 pPlatformPrivate)->pMetaDataBuffer, OMX_U32); 1081 DOMX_DEBUG("Metadata buffer = %d",((OMX_TI_PLATFORMPRIVATE *)pBufferHdr->pPlatformPrivate)->pMetaDataBuffer); 1082 } 1083 1084 DOMX_DEBUG("About to send packet"); 1085 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 1086 nSize); 1087 DOMX_DEBUG("Remote call returned"); 1088 1089 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 1090 1091 if (*eCompReturn == OMX_ErrorNone) 1092 { 1093 pRetData = ((struct omx_packet *) pRetPacket)->data; 1094 RPC_GETFIELDVALUE(pRetData, nPos, *pBufHeaderRemote, OMX_U32); 1095 //save platform private before overwriting 1096 pPlatformPrivate = (*ppBufferHdr)->pPlatformPrivate; 1097 1098 /*Copying each field of the header separately due to padding issues in 1099 the buffer header structure */ 1100 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nSize, OMX_U32); 1101 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nVersion, 1102 OMX_VERSIONTYPE); 1103 /* 1104 Do not expect buffer pointer - local buffer pointer is already 1105 present in the local header. 1106 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pBuffer, 1107 OMX_U8 *); 1108 */ 1109 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nAllocLen, 1110 OMX_U32); 1111 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFilledLen, 1112 OMX_U32); 1113 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nOffset, 1114 OMX_U32); 1115 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pAppPrivate, 1116 OMX_PTR); 1117 //Do not expect PlatformPrivate from Ducati 1118 //RPC_GETFIELDVALUE(pRetData, nPos,pBufferHdr->pPlatformPrivate, OMX_PTR); 1119 RPC_GETFIELDVALUE(pRetData, nPos, 1120 pBufferHdr->pInputPortPrivate, OMX_PTR); 1121 RPC_GETFIELDVALUE(pRetData, nPos, 1122 pBufferHdr->pOutputPortPrivate, OMX_PTR); 1123 RPC_GETFIELDVALUE(pRetData, nPos, 1124 pBufferHdr->hMarkTargetComponent, OMX_HANDLETYPE); 1125 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->pMarkData, 1126 OMX_PTR); 1127 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTickCount, 1128 OMX_U32); 1129 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nTimeStamp, 1130 OMX_TICKS); 1131 RPC_GETFIELDVALUE(pRetData, nPos, pBufferHdr->nFlags, 1132 OMX_U32); 1133 RPC_GETFIELDVALUE(pRetData, nPos, 1134 pBufferHdr->nInputPortIndex, OMX_U32); 1135 RPC_GETFIELDVALUE(pRetData, nPos, 1136 pBufferHdr->nOutputPortIndex, OMX_U32); 1137 1138 //Do not expect PlatformPrivate from Ducati 1139 /* 1140 (*ppBufferHdr)->pPlatformPrivate = pPlatformPrivate; 1141 1142 DOMX_DEBUG(" Copying plat pvt. "); 1143 RPC_GETFIELDCOPYTYPE(pRetData, nPos, 1144 (OMX_TI_PLATFORMPRIVATE *) ((*ppBufferHdr)-> 1145 pPlatformPrivate), OMX_TI_PLATFORMPRIVATE);*/ 1146 1147 /*Resetting size as it might be diff on Ducati due to padding issues */ 1148 pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE); 1149 } 1150 1151 EXIT: 1152 if (pPacket) 1153 RPC_freePacket(pPacket); 1154 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 1155 RPC_freePacket(pRetPacket); 1156 1157 DOMX_EXIT(""); 1158 return eRPCError; 1159} 1160 1161/* ===========================================================================*/ 1162/** 1163 * @name RPC_FreeBuffer() 1164 * @brief Remote invocation stub for OMX_AllcateBuffer() 1165 * @param size : Size of the incoming RCM message (parameter used in the RCM alloc call) 1166 * @param *data : Pointer to the RCM message/buffer received 1167 * @return RPC_OMX_ErrorNone = Successful 1168 * @sa TBD 1169 * 1170 */ 1171/* ===========================================================================*/ 1172RPC_OMX_ERRORTYPE RPC_FreeBuffer(OMX_HANDLETYPE hRPCCtx, 1173 OMX_IN OMX_U32 nPortIndex, OMX_IN OMX_U32 BufHdrRemote, OMX_U32 pBuffer, 1174 OMX_ERRORTYPE * eCompReturn) 1175{ 1176 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1177 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 1178 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 1179 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 1180 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 1181 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 1182 OMX_S32 status = 0; 1183 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 1184 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 1185 struct omx_packet *pOmxPacket = NULL; 1186 1187 DOMX_ENTER(""); 1188 1189 nFxnIdx = RPC_OMX_FXN_IDX_FREE_BUFFER; 1190 RPC_getPacket(nPacketSize, pPacket); 1191 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 1192 1193 /*Offset is the location of the buffer pointer from the start of the data packet */ 1194 nOffset = sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) + 1195 sizeof(OMX_HANDLETYPE) + sizeof(OMX_U32) + sizeof(OMX_U32); 1196 /*No buffer mapping required */ 1197 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_ONE_BUF, 1198 RPC_OMX_MAP_INFO_TYPE); 1199 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 1200 1201 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 1202 RPC_SETFIELDVALUE(pData, nPos, nPortIndex, OMX_U32); 1203 RPC_SETFIELDVALUE(pData, nPos, BufHdrRemote, OMX_U32); 1204 /* Buffer is being sent separately only to catch NULL buffer errors 1205 in PA mode */ 1206 RPC_SETFIELDVALUE(pData, nPos, pBuffer, OMX_U32); 1207 1208 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 1209 nSize); 1210 1211 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 1212 1213 EXIT: 1214 if (pPacket) 1215 RPC_freePacket(pPacket); 1216 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 1217 RPC_freePacket(pRetPacket); 1218 1219 DOMX_EXIT(""); 1220 return eRPCError; 1221} 1222 1223 1224/* ===========================================================================*/ 1225/** 1226 * @name RPC_EmptyThisBuffer() 1227 * @brief 1228 * @param size : Size of the incoming RCM message (parameter used in the RCM alloc call) 1229 * @param *data : Pointer to the RCM message/buffer received 1230 * @return RPC_OMX_ErrorNone = Successful 1231 * @sa TBD 1232 * 1233 */ 1234/* ===========================================================================*/ 1235 1236RPC_OMX_ERRORTYPE RPC_EmptyThisBuffer(OMX_HANDLETYPE hRPCCtx, 1237 OMX_BUFFERHEADERTYPE * pBufferHdr, OMX_U32 BufHdrRemote, 1238 OMX_ERRORTYPE * eCompReturn, OMX_BOOL bMapBuffer) 1239{ 1240 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1241 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 1242 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 1243 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 1244 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 1245 OMX_S32 status = 0; 1246 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 1247 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 1248 OMX_U8 *pAuxBuf1 = NULL; 1249 struct omx_packet *pOmxPacket = NULL; 1250 RPC_OMX_MAP_INFO_TYPE eMapInfo = RPC_OMX_MAP_INFO_NONE; 1251#ifdef RPC_SYNC_MODE 1252 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 1253#endif 1254 1255 DOMX_ENTER(""); 1256 1257 nFxnIdx = RPC_OMX_FXN_IDX_EMPTYTHISBUFFER; 1258 RPC_getPacket(nPacketSize, pPacket); 1259 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 1260 1261 if(bMapBuffer == OMX_TRUE) 1262 { 1263 pAuxBuf1 = ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->pAuxBuf1; 1264 /*Buffer mapping required */ 1265 if (((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->pAuxBuf1 == NULL) 1266 eMapInfo = RPC_OMX_MAP_INFO_ONE_BUF; 1267 else 1268 eMapInfo = RPC_OMX_MAP_INFO_TWO_BUF; 1269 /*Offset is the location of the buffer pointer from the start of the data packet */ 1270 nOffset = 1271 sizeof(RPC_OMX_MAP_INFO_TYPE) + sizeof(OMX_U32) + 1272 sizeof(OMX_HANDLETYPE) + sizeof(OMX_BUFFERHEADERTYPE *) + 3*sizeof(OMX_U32) + 1273 sizeof(OMX_TICKS) + sizeof(OMX_HANDLETYPE) + sizeof(OMX_PTR) + 3*sizeof(OMX_U32); 1274 } 1275 1276 RPC_SETFIELDVALUE(pData, nPos, eMapInfo, RPC_OMX_MAP_INFO_TYPE); 1277 1278 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 1279 1280 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 1281 RPC_SETFIELDVALUE(pData, nPos, 1282 (OMX_BUFFERHEADERTYPE *) BufHdrRemote, OMX_BUFFERHEADERTYPE *); 1283 1284 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFilledLen, OMX_U32); 1285 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOffset, OMX_U32); 1286 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFlags, OMX_U32); 1287 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nTimeStamp, OMX_TICKS); 1288 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->hMarkTargetComponent, 1289 OMX_HANDLETYPE); 1290 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->pMarkData, OMX_PTR); 1291 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nAllocLen, OMX_U32); 1292 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOutputPortIndex, OMX_U32); 1293 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nInputPortIndex, OMX_U32); 1294 1295 if(bMapBuffer == OMX_TRUE) 1296 { 1297 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->pBuffer, OMX_U32); 1298 if (eMapInfo == RPC_OMX_MAP_INFO_TWO_BUF) 1299 { 1300 RPC_SETFIELDVALUE(pData, nPos, 1301 ((OMX_TI_PLATFORMPRIVATE *) pBufferHdr->pPlatformPrivate)->pAuxBuf1, OMX_U32); 1302 } 1303 } 1304 1305 DOMX_DEBUG(" pBufferHdr = %x BufHdrRemote %x", pBufferHdr, 1306 BufHdrRemote); 1307 1308#ifdef RPC_SYNC_MODE 1309 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 1310 nSize); 1311 1312 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 1313#else 1314 RPC_sendPacket_async(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket, 1315 nFxnIdx); 1316 RPC_checkAsyncErrors(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket); 1317 1318 *eCompReturn = OMX_ErrorNone; 1319#endif 1320 1321 EXIT: 1322 if (pPacket) 1323 RPC_freePacket(pPacket); 1324 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 1325 RPC_freePacket(pRetPacket); 1326 1327 DOMX_EXIT(""); 1328 return eRPCError; 1329} 1330 1331 1332/* ===========================================================================*/ 1333/** 1334 * @name RPC_FillThisBuffer() 1335 * @brief Remote invocation stub for OMX_AllcateBuffer() 1336 * @param size : Size of the incoming RCM message (parameter used in the RCM alloc call) 1337 * @param *data : Pointer to the RCM message/buffer received 1338 * @return RPC_OMX_ErrorNone = Successful 1339 * @sa TBD 1340 * 1341 */ 1342/* ===========================================================================*/ 1343RPC_OMX_ERRORTYPE RPC_FillThisBuffer(OMX_HANDLETYPE hRPCCtx, 1344 OMX_BUFFERHEADERTYPE * pBufferHdr, OMX_U32 BufHdrRemote, 1345 OMX_ERRORTYPE * eCompReturn) 1346{ 1347 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1348 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 1349 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 1350 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 1351 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 1352 OMX_S32 status = 0; 1353 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 1354 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 1355 OMX_U8 *pAuxBuf1 = NULL; 1356 struct omx_packet *pOmxPacket = NULL; 1357#ifdef RPC_SYNC_MODE 1358 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 1359#endif 1360 1361 DOMX_ENTER(""); 1362 1363 nFxnIdx = RPC_OMX_FXN_IDX_FILLTHISBUFFER; 1364 RPC_getPacket(nPacketSize, pPacket); 1365 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 1366 1367 /*No buffer mapping required */ 1368 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, 1369 RPC_OMX_MAP_INFO_TYPE); 1370 RPC_SETFIELDVALUE(pData, nPos, nOffset, OMX_U32); 1371 1372 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 1373 RPC_SETFIELDVALUE(pData, nPos, 1374 (OMX_BUFFERHEADERTYPE *) BufHdrRemote, OMX_BUFFERHEADERTYPE *); 1375 1376 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFilledLen, OMX_U32); 1377 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOffset, OMX_U32); 1378 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nFlags, OMX_U32); 1379 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nAllocLen, OMX_U32); 1380 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nOutputPortIndex, OMX_U32); 1381 RPC_SETFIELDVALUE(pData, nPos, pBufferHdr->nInputPortIndex, OMX_U32); 1382 1383 DOMX_DEBUG(" pBufferHdr = %x BufHdrRemote %x", pBufferHdr, 1384 BufHdrRemote); 1385 1386#ifdef RPC_SYNC_MODE 1387 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 1388 nSize); 1389 1390 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 1391 1392#else 1393 RPC_sendPacket_async(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket, 1394 nFxnIdx); 1395 RPC_checkAsyncErrors(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket); 1396 1397 *eCompReturn = OMX_ErrorNone; 1398#endif 1399 1400 EXIT: 1401 if (pPacket) 1402 RPC_freePacket(pPacket); 1403 if (pRetPacket && *eCompReturn != OMX_ErrorHardware) 1404 RPC_freePacket(pRetPacket); 1405 1406 DOMX_EXIT(""); 1407 return eRPCError; 1408} 1409 1410 1411/* ***************************** EMPTY APIs ******************************** */ 1412 1413/* ===========================================================================*/ 1414/** 1415 * @name EMPTY-STUB 1416 * @brief 1417 * @param 1418 * @return 1419 * 1420 */ 1421/* ===========================================================================*/ 1422OMX_ERRORTYPE RPC_EventHandler(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData, 1423 OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2, OMX_PTR pEventData) 1424{ 1425 return RPC_OMX_ErrorNone; 1426} 1427 1428OMX_ERRORTYPE RPC_EmptyBufferDone(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData, 1429 OMX_BUFFERHEADERTYPE * pBuffer) 1430{ 1431 return RPC_OMX_ErrorNone; 1432} 1433 1434OMX_ERRORTYPE RPC_FillBufferDone(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData, 1435 OMX_BUFFERHEADERTYPE * pBuffer) 1436{ 1437 return RPC_OMX_ErrorNone; 1438} 1439 1440RPC_OMX_ERRORTYPE RPC_ComponentTunnelRequest(OMX_HANDLETYPE hRPCCtx, 1441 OMX_IN OMX_U32 nPort, OMX_HANDLETYPE hTunneledRemoteHandle, 1442 OMX_U32 nTunneledPort, OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup, 1443 OMX_ERRORTYPE * eCompReturn) 1444{ 1445 RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone; 1446 TIMM_OSAL_ERRORTYPE eError = TIMM_OSAL_ERR_NONE; 1447 OMX_U32 nPacketSize = RPC_PACKET_SIZE; 1448 RPC_OMX_CONTEXT *hCtx = hRPCCtx; 1449 OMX_HANDLETYPE hComp = hCtx->hRemoteHandle; 1450 RPC_OMX_CONTEXT *hTunneledCtx = hTunneledRemoteHandle; 1451 OMX_HANDLETYPE hTunneledComp = hTunneledCtx->hRemoteHandle; 1452 RPC_OMX_FXN_IDX_TYPE nFxnIdx; 1453 struct omx_packet *pOmxPacket = NULL; 1454 OMX_U32 nPos = 0, nSize = 0, nOffset = 0; 1455 OMX_S32 status = 0; 1456#ifdef RPC_SYNC_MODE 1457 TIMM_OSAL_PTR pPacket = NULL, pRetPacket = NULL, pData = NULL; 1458#endif 1459 1460 printf(" Entering rpc:domx_stub.c:ComponentTunnelRequest\n"); 1461 1462 nFxnIdx = RPC_OMX_FXN_IDX_COMP_TUNNEL_REQUEST; 1463 RPC_getPacket(nPacketSize, pPacket); 1464 RPC_initPacket(pPacket, pOmxPacket, pData, nFxnIdx, nPacketSize); 1465 1466 /*Pack the values into a packet*/ 1467 //Marshalled:[>ParentComp|>ParentPort|>TunnelComp|>TunneledPort>TunnelSetup] 1468 RPC_SETFIELDVALUE(pData, nPos, RPC_OMX_MAP_INFO_NONE, RPC_OMX_MAP_INFO_TYPE); 1469 RPC_SETFIELDVALUE(pData, nPos, hComp, OMX_HANDLETYPE); 1470 RPC_SETFIELDVALUE(pData, nPos, nPort, OMX_U32); 1471 RPC_SETFIELDVALUE(pData, nPos, hTunneledComp, OMX_HANDLETYPE); 1472 RPC_SETFIELDVALUE(pData, nPos, nTunneledPort, OMX_U32); 1473 printf("\n after RPC_sendPacket_sync"); 1474 RPC_sendPacket_sync(hCtx, pPacket, nPacketSize, nFxnIdx, pRetPacket, 1475 nSize); 1476 1477 printf("\n after RPC_sendPacket_sync: *eCompReturn : 0x%x\n", (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result)); 1478 *eCompReturn = (OMX_ERRORTYPE) (((struct omx_packet *) pRetPacket)->result); 1479 1480 EXIT: 1481 if (pPacket) 1482 RPC_freePacket(pPacket); 1483 if (pRetPacket) 1484 RPC_freePacket(pRetPacket); 1485 1486 DOMX_EXIT(""); 1487 return eRPCError; 1488 1489} 1490