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 /* ===========================================================================*/
RPC_GetHandle(OMX_HANDLETYPE hRPCCtx,OMX_STRING cComponentName,OMX_PTR pAppData,OMX_CALLBACKTYPE * pCallBacks,OMX_ERRORTYPE * eCompReturn)167 RPC_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 /* ===========================================================================*/
RPC_FreeHandle(OMX_HANDLETYPE hRPCCtx,OMX_ERRORTYPE * eCompReturn)251 RPC_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 /* ===========================================================================*/
RPC_SetParameter(OMX_HANDLETYPE hRPCCtx,OMX_INDEXTYPE nParamIndex,OMX_PTR pCompParam,OMX_PTR pLocBufNeedMap,OMX_U32 nNumOfLocalBuf,OMX_ERRORTYPE * eCompReturn)307 RPC_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 /* ===========================================================================*/
RPC_GetParameter(OMX_HANDLETYPE hRPCCtx,OMX_INDEXTYPE nParamIndex,OMX_PTR pCompParam,OMX_PTR pLocBufNeedMap,OMX_ERRORTYPE * eCompReturn)381 RPC_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 /* ===========================================================================*/
RPC_SetConfig(OMX_HANDLETYPE hRPCCtx,OMX_INDEXTYPE nConfigIndex,OMX_PTR pCompConfig,OMX_PTR pLocBufNeedMap,OMX_ERRORTYPE * eCompReturn)461 RPC_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 /* ===========================================================================*/
RPC_GetConfig(OMX_HANDLETYPE hRPCCtx,OMX_INDEXTYPE nConfigIndex,OMX_PTR pCompConfig,OMX_PTR pLocBufNeedMap,OMX_ERRORTYPE * eCompReturn)527 RPC_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 /* ===========================================================================*/
RPC_SendCommand(OMX_HANDLETYPE hRPCCtx,OMX_COMMANDTYPE eCmd,OMX_U32 nParam,OMX_PTR pCmdData,OMX_ERRORTYPE * eCompReturn)607 RPC_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 /* ===========================================================================*/
RPC_GetState(OMX_HANDLETYPE hRPCCtx,OMX_STATETYPE * pState,OMX_ERRORTYPE * eCompReturn)678 RPC_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 /* ===========================================================================*/
RPC_GetComponentVersion(OMX_HANDLETYPE hRPCCtx,OMX_STRING pComponentName,OMX_VERSIONTYPE * pComponentVersion,OMX_VERSIONTYPE * pSpecVersion,OMX_UUIDTYPE * pComponentUUID,OMX_ERRORTYPE * eCompReturn)747 RPC_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 /* ===========================================================================*/
RPC_GetExtensionIndex(OMX_HANDLETYPE hRPCCtx,OMX_STRING cParameterName,OMX_INDEXTYPE * pIndexType,OMX_ERRORTYPE * eCompReturn)816 RPC_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 /* ===========================================================================*/
RPC_AllocateBuffer(OMX_HANDLETYPE hRPCCtx,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_IN OMX_U32 nPortIndex,OMX_U32 * pBufHeaderRemote,OMX_PTR pAppPrivate,OMX_U32 nSizeBytes,OMX_ERRORTYPE * eCompReturn)882 RPC_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 /* ===========================================================================*/
RPC_UseBuffer(OMX_HANDLETYPE hRPCCtx,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_U32 nPortIndex,OMX_PTR pAppPrivate,OMX_U32 nSizeBytes,OMX_U8 * pBuffer,OMX_U32 * pBufHeaderRemote,OMX_ERRORTYPE * eCompReturn)1014 RPC_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 /* ===========================================================================*/
RPC_FreeBuffer(OMX_HANDLETYPE hRPCCtx,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_U32 BufHdrRemote,OMX_U32 pBuffer,OMX_ERRORTYPE * eCompReturn)1172 RPC_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
RPC_EmptyThisBuffer(OMX_HANDLETYPE hRPCCtx,OMX_BUFFERHEADERTYPE * pBufferHdr,OMX_U32 BufHdrRemote,OMX_ERRORTYPE * eCompReturn,OMX_BOOL bMapBuffer)1236 RPC_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 /* ===========================================================================*/
RPC_FillThisBuffer(OMX_HANDLETYPE hRPCCtx,OMX_BUFFERHEADERTYPE * pBufferHdr,OMX_U32 BufHdrRemote,OMX_ERRORTYPE * eCompReturn)1343 RPC_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 /* ===========================================================================*/
RPC_EventHandler(OMX_HANDLETYPE hRPCCtx,OMX_PTR pAppData,OMX_EVENTTYPE eEvent,OMX_U32 nData1,OMX_U32 nData2,OMX_PTR pEventData)1422 OMX_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
RPC_EmptyBufferDone(OMX_HANDLETYPE hRPCCtx,OMX_PTR pAppData,OMX_BUFFERHEADERTYPE * pBuffer)1428 OMX_ERRORTYPE RPC_EmptyBufferDone(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData,
1429 OMX_BUFFERHEADERTYPE * pBuffer)
1430 {
1431 return RPC_OMX_ErrorNone;
1432 }
1433
RPC_FillBufferDone(OMX_HANDLETYPE hRPCCtx,OMX_PTR pAppData,OMX_BUFFERHEADERTYPE * pBuffer)1434 OMX_ERRORTYPE RPC_FillBufferDone(OMX_HANDLETYPE hRPCCtx, OMX_PTR pAppData,
1435 OMX_BUFFERHEADERTYPE * pBuffer)
1436 {
1437 return RPC_OMX_ErrorNone;
1438 }
1439
RPC_ComponentTunnelRequest(OMX_HANDLETYPE hRPCCtx,OMX_IN OMX_U32 nPort,OMX_HANDLETYPE hTunneledRemoteHandle,OMX_U32 nTunneledPort,OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup,OMX_ERRORTYPE * eCompReturn)1440 RPC_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