[GLP] Libdce linux implementation
[glsdk/libdce2.git] / libdce.c
1 /*
2  * Copyright (c) 2013, 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  */
33 /*
34 ********************************** Notes ******************************************
35 *******
36 ********************************* Memory *****************************************
37 *
38 *******
39 ********************************* IPC 3.x *****************************************
40 * Two approaches are followed for IPC MmRpc calls.
41 * 1. All the parameters which need to be sent and received to/from IPU are coupled in a struct
42 *     allocated from Shared Memory. Only the adrress of the struct is passed to MmRpc
43 *     as a pointer argument. This approach is useful as MmRpc in some cases to avoid multiple
44 *     translations.
45 *     This approach is followed for :
46 *     Engine_open(), Engine_close(), create(), control(), delete()
47 *     For understanding refer to the Mmrpc_test.c in IPC 3.x
48 * 2. All the parameters which need to be sent are given as separate arguments to
49 *     MmRpc. This appraoch is needed when you need to translate an address which is
50 *     ofsetted from a pointer which in itself needs to be translated.
51 *     This apporach is followed for : process()
52 *     For understanding, take the example of inbufs argument in process call(). Inbufs
53 *     allocated in Shared memory and needs to be translated, has the address of Input
54 *     buffer (allocated from Tiler). It is not possible to give the Input buffer as an argument
55 *     to Mmrpc for translation until inbufs is given as a parameter to Mmrpc. Therefore inbuf
56 *     can't be populated inside another Shared memory struct.
57 * 3. This approach is a workaround to use approach [1] by solving the issue posed by [2].
58 *     This approach is followed for : get_version()
59 *     Taking the example of inbufs to explain, the Input buffer address will be one of the
60 *     parameters of the struct (explained in [1]) along with inbufs address. Therefore the
61 *     Input buffer address will get translated here. At the IPU, this address needs to be
62 *     copied back to inbufs.
63 *********************************************************************************
64 */
66 #include <stdlib.h>
67 #include <string.h>
68 #include <stdio.h>
69 #include <pthread.h>
70 #include <errno.h>
72 #include <xdc/std.h>
74 #if defined(BUILDOS_LINUX)
75 #include <xf86drm.h>
76 #include <omap_drm.h>
77 #include <omap_drmif.h>
78 #endif /* BUILDOS_LINUX */
80 /* IPC Headers */
81 #include <MmRpc.h>
83 /*DCE Headers */
84 #include "libdce.h"
85 #include "dce_rpc.h"
86 #include "dce_priv.h"
87 #include "memplugin.h"
90 #if defined(BUILDOS_LINUX)
91 #ifdef HAVE_X11
92 // Defined from configure.ac
93 extern int dce_auth_x11(int *fd);
94 #endif /* HAVE_X11 */
95 #ifdef HAVE_WAYLAND   // Defined from configure.ac
96 extern int dce_auth_wayland(int *fd);
97 #endif /* HAVE_WAYLAND */
99 int                     fd                 = -1;
100 struct   omap_device   *dev   =  0;
101 uint32_t                dce_debug          =  3;
102 #endif /* BUILDOS_LINUX */
105 /********************* GLOBALS ***********************/
106 /* Hande used for Remote Communication                               */
107 static MmRpc_Handle       MmRpcHandle = NULL;
108 static pthread_mutex_t    mutex = PTHREAD_MUTEX_INITIALIZER;
109 static int                count = 0;
112 /****************** INLINE FUNCTIONS ********************/
114 static inline void Fill_MmRpc_fxnCtx(MmRpc_FxnCtx *fxnCtx, int fxn_id, int num_params, int num_xlts, MmRpc_Xlt *xltAry)
116     fxnCtx->fxn_id = fxn_id;
117     fxnCtx->num_params = num_params;
118     fxnCtx->num_xlts = num_xlts;
119     fxnCtx->xltAry = xltAry;
122 static inline void Fill_MmRpc_fxnCtx_Ptr_Params(MmRpc_Param *mmrpc_params, int size, void *addr, void *handle)
124     mmrpc_params->type = MmRpc_ParamType_Ptr;
125     mmrpc_params->param.ptr.size = size;
126     mmrpc_params->param.ptr.addr = (size_t)addr;
127     mmrpc_params->param.ptr.handle = (size_t)handle;
130 static inline void Fill_MmRpc_fxnCtx_Scalar_Params(MmRpc_Param *mmrpc_params, int size, int data)
132     mmrpc_params->type = MmRpc_ParamType_Scalar;
133     mmrpc_params->param.scalar.size = size;
134     mmrpc_params->param.scalar.data = (size_t)data;
137 static inline void Fill_MmRpc_fxnCtx_Xlt_Array(MmRpc_Xlt *mmrpc_xlt, int index, int32_t base, int32_t addr, void *handle)
139     /* index : index of params filled in FxnCtx                                                                                        */
140     /* offset : calculated from address of index                                                                                      */
141     mmrpc_xlt->index = index;
142     mmrpc_xlt->offset = MmRpc_OFFSET(base, addr);
143     mmrpc_xlt->handle = (size_t)handle;
146 /************************ FUNCTIONS **************************/
147 /* Interface for QNX for parameter buffer allocation                                */
148 /* These interfaces are implemented to maintain Backward Compatability */
149 void *dce_alloc(int sz)
151     return (memplugin_alloc(sz, 0, TILER_1D_BUFFER));
154 void dce_free(void *ptr)
156     memplugin_free(ptr, TILER_1D_BUFFER);
159 /*************** Startup/Shutdown Functions ***********************/
160 static int dce_init(void)
162     dce_error_status    eError = DCE_EOK;
163     MmRpc_Params        args;
165     printf(" >> dce_init\n");
167     pthread_mutex_lock(&mutex);
169     count++;
170     /* Check if already Initialized */
171     _ASSERT(count == 1, DCE_EOK);
173     /* Create remote server insance */
174     MmRpc_Params_init(&args);
176     eError = MmRpc_create(DCE_DEVICE_NAME, &args, &MmRpcHandle);
178     _ASSERT_AND_EXECUTE(eError == DCE_EOK, DCE_EIPC_CREATE_FAIL, count--);
180     printf("open(/dev/" DCE_DEVICE_NAME ") -> 0x%x\n", (int)MmRpcHandle);
182 #if defined(BUILDOS_LINUX)
183     /* Open omapdrm device */
184     int    authenticated = 0;
186 #ifdef HAVE_X11
187     /*If X11 server is running*/
188     if( !authenticated ) {
189         int    ret = dce_auth_x11(&fd);
190         if( !ret ) {
191             authenticated = 1;
192         }
193     }
194 #endif
195 #ifdef HAVE_WAYLAND
196     /*If Wayland windowing is supported*/
197     if( !authenticated ) {
198         int    ret = dce_auth_wayland(&fd);
199         if( !ret ) {
200             authenticated = 1;
201         }
202     }
203 #endif
204     if((fd == -1) && !authenticated ) {
205         printf("no X11/wayland, fallback to opening DRM device directly\n");
206         fd = drmOpen("omapdrm", "platform:omapdrm:00");
207     }
208     if( fd >= 0 ) {
209         dev = omap_device_new(fd);
210     } else {
211         printf("Error opening omapdrm : drmOpen failed");
212         goto EXIT;
213     }
214 #endif /* BUILDOS_LINUX */
217 EXIT:
218     pthread_mutex_unlock(&mutex);
219     return (eError);
222 static void dce_deinit(void)
224     pthread_mutex_lock(&mutex);
226     count--;
227     if( count > 0 ) {
228         goto EXIT;
229     }
231     if( MmRpcHandle != NULL ) {
232         MmRpc_delete(&MmRpcHandle);
233     }
234     MmRpcHandle = NULL;
236 #if defined(BUILDOS_LINUX)
237     omap_device_del(dev);
238     dev = NULL;
239     close(fd);
240     fd = -1;
241 #endif /* BUILDOS_LINUX */
244 EXIT:
245     pthread_mutex_unlock(&mutex);
246     return;
249 /* Incase of X11 or Wayland the fd can be shared to libdce using this call */
250 #if defined(BUILDOS_LINUX)
251 void dce_set_fd(int dce_fd)
253     fd = dce_fd;
256 int dce_get_fd(void)
258     return (fd);
261 #endif /* BUILDOS_LINUX */
263 /*===============================================================*/
264 /** Engine_open        : Open Codec Engine.
265  *
266  * @ param attrs  [in]       : Engine Attributes. This param is not passed to Remote core.
267  * @ param name [in]       : Name of Encoder or Decoder codec.
268  * @ param ec [out]         : Error returned by Codec Engine.
269  * @ return : Codec Engine Handle is returned to be used to create codec.
270  *                 In case of error, NULL is returned as Engine Handle.
271  */
272 Engine_Handle Engine_open(String name, Engine_Attrs *attrs, Engine_Error *ec)
274     MmRpc_FxnCtx        fxnCtx;
275     dce_error_status    eError = DCE_EOK;
276     dce_engine_open    *engine_open_msg = NULL;
277     Engine_Attrs       *engine_attrs = NULL;
278     Engine_Handle       engine_handle = NULL;
280     _ASSERT(name != '\0', DCE_EINVALID_INPUT);
282     /* Initialize DCE and IPC. In case of Error Deinitialize them */
283     _ASSERT_AND_EXECUTE(dce_init() == DCE_EOK, DCE_EIPC_CREATE_FAIL, dce_deinit());
285     printf(">> Engine_open Params::name = %s size = %d\n", name, strlen(name));
286     /* Allocate Shared memory for the engine_open rpc msg structure*/
287     /* Tiler Memory preferred in QNX */
288     engine_open_msg = memplugin_alloc(sizeof(dce_engine_open), 0, TILER_1D_BUFFER);
289     _ASSERT_AND_EXECUTE(engine_open_msg != NULL, DCE_EOUT_OF_MEMORY, engine_handle = NULL);
291     if( attrs ) {
292         engine_attrs = memplugin_alloc(sizeof(Engine_Attrs), 0, TILER_1D_BUFFER);
293         _ASSERT_AND_EXECUTE(engine_attrs != NULL, DCE_EOUT_OF_MEMORY, engine_handle = NULL);
294         *engine_attrs = *attrs;
295     }
296     /* Populating the msg structure with all the params */
297     /* Populating all params into a struct avoid individual address translations of name, ec */
298     strncpy(engine_open_msg->name, name, strlen(name));
299     engine_open_msg->engine_attrs = engine_attrs;
301     /* Marshall function arguments into the send buffer */
302     Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_ENGINE_OPEN, 1, 0, NULL);
303     Fill_MmRpc_fxnCtx_Ptr_Params(fxnCtx.params, sizeof(dce_engine_open), engine_open_msg, NULL);
305     /* Invoke the Remote function through MmRpc */
306     eError = MmRpc_call(MmRpcHandle, &fxnCtx, (int32_t *)(&engine_handle));
308     /* In case of Error, the Application will get a NULL Engine Handle */
309     _ASSERT_AND_EXECUTE(eError == DCE_EOK, DCE_EIPC_CALL_FAIL, engine_handle = NULL);
311     if( ec ) {
312         *ec = engine_open_msg->error_code;
313     }
314 EXIT:
315     memplugin_free(engine_open_msg, TILER_1D_BUFFER);
316     if( engine_attrs ) {
317         memplugin_free(engine_attrs, TILER_1D_BUFFER);
318     }
319     return ((Engine_Handle)engine_handle);
322 /*===============================================================*/
323 /** Engine_close           : Close Engine.
324  *
325  * @ param engine  [in]    : Engine Handle obtained in Engine_open() call.
326  */
327 Void Engine_close(Engine_Handle engine)
329     MmRpc_FxnCtx        fxnCtx;
330     int32_t             fxnRet;
331     dce_error_status    eError = DCE_EOK;
333     _ASSERT(engine != NULL, DCE_EINVALID_INPUT);
335     /* Marshall function arguments into the send buffer */
336     Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_ENGINE_CLOSE, 1, 0, NULL);
337     Fill_MmRpc_fxnCtx_Scalar_Params(fxnCtx.params, sizeof(Engine_Handle), (int32_t)engine);
339     /* Invoke the Remote function through MmRpc */
340     eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
342     _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
344 EXIT:
345     dce_deinit();
346     return;
349 /*===============================================================*/
350 /** Functions create(), control(), get_version(), process(), delete() are common codec
351  * glue function signatures which are same for both encoder and decoder
352  */
353 /*===============================================================*/
354 /** create         : Create Encoder/Decoder codec.
355  *
356  * @ param engine  [in]    : Engine Handle obtained in Engine_open() call.
357  * @ param name [in]       : Name of Encoder or Decoder codec.
358  * @ param params [in]     : Static parameters of codec.
359  * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
360  * @ return : Codec Handle is returned to be used for control, process, delete calls.
361  *                 In case of error, NULL is returned.
362  */
363 static void *create(Engine_Handle engine, String name, void *params, dce_codec_type codec_id)
365     MmRpc_FxnCtx        fxnCtx;
366     dce_error_status    eError = DCE_EOK;
367     void               *codec_handle = NULL;
368     char               *codec_name = NULL;
370     _ASSERT(name != '\0', DCE_EINVALID_INPUT);
371     _ASSERT(engine != NULL, DCE_EINVALID_INPUT);
372     _ASSERT(params != NULL, DCE_EINVALID_INPUT);
374     /* Allocate shared memory for translating codec name to IPU */
375     codec_name = memplugin_alloc(MAX_NAME_LENGTH * sizeof(char), 0, TILER_1D_BUFFER);
376     _ASSERT_AND_EXECUTE(codec_name != NULL, DCE_EOUT_OF_MEMORY, codec_handle = NULL);
378     strncpy(codec_name, name, strlen(name));
380     /* Marshall function arguments into the send buffer */
381     Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_CREATE, 4, 0, NULL);
382     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[0]), sizeof(int32_t), codec_id);
383     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[1]), sizeof(Engine_Handle), (int32_t)engine);
384     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[2]), (P2H(codec_name))->size, codec_name, NULL);
385     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[3]), (P2H(params))->size, params, NULL);
387     /* Invoke the Remote function through MmRpc */
388     eError = MmRpc_call(MmRpcHandle, &fxnCtx, (int32_t *)(&codec_handle));
390     /* In case of Error, the Application will get a NULL Codec Handle */
391     _ASSERT_AND_EXECUTE(eError == DCE_EOK, DCE_EIPC_CALL_FAIL, codec_handle = NULL);
393 EXIT:
394     memplugin_free(codec_name, TILER_1D_BUFFER);
395     return ((void *)codec_handle);
398 /*===============================================================*/
399 /** control               : Codec control call.
400  *
401  * @ param codec  [in]     : Codec Handle obtained in create() call.
402  * @ param id [in]            : Command id for XDM control operation.
403  * @ param dynParams [in] : Dynamic input parameters to Codec.
404  * @ param status [out]    : Codec returned status parameters.
405  * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
406  * @ return : Status of control() call is returned.
407  *                #XDM_EOK                  [0]   :  Success.
408  *                #XDM_EFAIL                [-1] :  Failure.
409  *                #IPC_FAIL                   [-2] : MmRpc Call failed.
410  *                #XDM_EUNSUPPORTED [-3] :  Unsupported request.
411  *                #OUT_OF_MEMORY       [-4] :  Out of Shared Memory.
412  */
413 static XDAS_Int32 control(void *codec, int id, void *dynParams, void *status, dce_codec_type codec_id)
415     MmRpc_FxnCtx        fxnCtx;
416     int32_t             fxnRet;
417     dce_error_status    eError = DCE_EOK;
419     _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
420     _ASSERT(dynParams != NULL, DCE_EINVALID_INPUT);
421     _ASSERT(status != NULL, DCE_EINVALID_INPUT);
423     /* Marshall function arguments into the send buffer */
424     Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_CONTROL, 5, 0, NULL);
425     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[0]), sizeof(int32_t), codec_id);
426     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[1]), sizeof(int32_t), (int32_t)codec);
427     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[2]), sizeof(int32_t), (int32_t)id);
428     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[3]), (P2H(dynParams))->size, dynParams, NULL);
429     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[4]), (P2H(status))->size, status, NULL);
431     /* Invoke the Remote function through MmRpc */
432     eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
434     _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
436 EXIT:
437     return (fxnRet);
441 /*===============================================================*/
442 /** get_version        : Codec control call to get the codec version. This call has been made
443  *                                     separate from control call because it involves an additional version
444  *                                     buffer translation.
445  *
446  * @ param codec  [in]     : Codec Handle obtained in create() call.
447  * @ param id [in]            : Command id for XDM control operation.
448  * @ param dynParams [in] : Dynamic input parameters to Codec.
449  * @ param status [out]    : Codec returned status parameters.
450  * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
451  * @ return : Status of control() call is returned.
452  *                #XDM_EOK                  [0]   :  Success.
453  *                #XDM_EFAIL                [-1] :  Failure.
454  *                #IPC_FAIL                   [-2] : MmRpc Call failed.
455  *                #XDM_EUNSUPPORTED [-3] :  Unsupported request.
456  *                #OUT_OF_MEMORY       [-4] :  Out of Shared Memory.
457  */
458 static XDAS_Int32 get_version(void *codec, void *dynParams, void *status, dce_codec_type codec_id)
460     MmRpc_FxnCtx        fxnCtx;
461     MmRpc_Xlt           xltAry;
462     void             * *version_buf = NULL;
463     int32_t             fxnRet;
464     dce_error_status    eError = DCE_EOK;
466     _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
467     _ASSERT(dynParams != NULL, DCE_EINVALID_INPUT);
468     _ASSERT(status != NULL, DCE_EINVALID_INPUT);
470     if( codec_id == OMAP_DCE_VIDDEC3 ) {
471         version_buf = (void * *)(&(((IVIDDEC3_Status *)status)->data.buf));
472     } else if( codec_id == OMAP_DCE_VIDENC2 ) {
473         version_buf = (void * *)(&(((IVIDENC2_Status *)status)->data.buf));
474     }
475     _ASSERT(*version_buf != NULL, DCE_EINVALID_INPUT);
477     /* Marshall function arguments into the send buffer */
478     Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_GET_VERSION, 4, 1, &xltAry);
479     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[0]), sizeof(int32_t), codec_id);
480     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[1]), sizeof(int32_t), (int32_t)codec);
481     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[2]), (P2H(dynParams))->size, dynParams, NULL);
482     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[3]), (P2H(status))->size, status, NULL);
484     /* Address Translation needed for buffer for version Info */
485     Fill_MmRpc_fxnCtx_Xlt_Array(fxnCtx.xltAry, 3, (int32_t)status, (int32_t)version_buf, NULL);
487     /* Invoke the Remote function through MmRpc */
488     eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
490     _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
492 EXIT:
493     return (fxnRet);
496 typedef enum process_call_params {
497     CODEC_ID_INDEX = 0,
498     CODEC_HANDLE_INDEX,
499     INBUFS_INDEX,
500     OUTBUFS_INDEX,
501     INARGS_INDEX,
502     OUTARGS_INDEX
503 } process_call_params;
505 /*===============================================================*/
506 /** process               : Encode/Decode process.
507  *
508  * @ param codec  [in]     : Codec Handle obtained in create() call.
509  * @ param inBufs [in]     : Input buffer details.
510  * @ param outBufs [in]    : Output buffer details.
511  * @ param inArgs [in]     : Input arguments.
512  * @ param outArgs [out]  : Output arguments.
513  * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
514  * @ return : Status of the process call.
515  *                #XDM_EOK                  [0]   :  Success.
516  *                #XDM_EFAIL                [-1] :  Failure.
517  *                #IPC_FAIL                   [-2] :  MmRpc Call failed.
518  *                #XDM_EUNSUPPORTED [-3] :  Unsupported request.
519  */
520 static XDAS_Int32 process(void *codec, void *inBufs, void *outBufs,
521                           void *inArgs, void *outArgs, dce_codec_type codec_id)
523     MmRpc_FxnCtx        fxnCtx;
524     MmRpc_Xlt           xltAry[MAX_TOTAl_BUF];
525     int                 fxnRet, count, total_count, numInBufs = 0, numOutBufs = 0, sz[OUTARGS_INDEX + 1] = { 0 };
526     dce_error_status    eError = DCE_EOK;
528     _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
529     _ASSERT(inBufs != NULL, DCE_EINVALID_INPUT);
530     _ASSERT(outBufs != NULL, DCE_EINVALID_INPUT);
531     _ASSERT(inArgs != NULL, DCE_EINVALID_INPUT);
532     _ASSERT(outArgs != NULL, DCE_EINVALID_INPUT);
534     if( codec_id == OMAP_DCE_VIDDEC3 ) {
535         numInBufs = ((XDM2_BufDesc *)inBufs)->numBufs;
536         numOutBufs = ((XDM2_BufDesc *)outBufs)->numBufs;
537         sz[INBUFS_INDEX] = sizeof(XDM2_BufDesc);
538         sz[OUTBUFS_INDEX] = sizeof(XDM2_BufDesc);
539         sz[INARGS_INDEX] = sizeof(VIDDEC3_InArgs);
540         sz[OUTARGS_INDEX] = sizeof(VIDDEC3_OutArgs);
541     } else if( codec_id == OMAP_DCE_VIDENC2 ) {
542         numInBufs = ((IVIDEO2_BufDesc *)inBufs)->numPlanes;
543         numOutBufs = ((XDM2_BufDesc *)outBufs)->numBufs;
544         sz[INBUFS_INDEX] = sizeof(IVIDEO2_BufDesc);
545         sz[OUTBUFS_INDEX] = sizeof(XDM2_BufDesc);
546         sz[INARGS_INDEX] = sizeof(VIDENC2_InArgs);
547         sz[OUTARGS_INDEX] = sizeof(VIDENC2_OutArgs);
548     }
550     /* marshall function arguments into the send buffer                       */
551     /* Approach [2] as explained in "Notes" used for process               */
552     Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_PROCESS, 6, numInBufs + numOutBufs, xltAry);
553     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[CODEC_ID_INDEX]), sizeof(int32_t), codec_id);
554     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[CODEC_HANDLE_INDEX]), sizeof(int32_t), (int32_t)codec);
555     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[INBUFS_INDEX]), sz[INBUFS_INDEX], inBufs, NULL);
556     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[OUTBUFS_INDEX]), sz[OUTBUFS_INDEX], outBufs, NULL);
557     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[INARGS_INDEX]), sz[INARGS_INDEX], inArgs, NULL);
558     Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[OUTARGS_INDEX]), sz[OUTARGS_INDEX], outArgs, NULL);
560     /* InBufs, OutBufs, InArgs, OutArgs buffer need translation but since they have been */
561     /* individually mentioned as fxnCtx Params, they need not be mentioned below again */
562     /* Input and Output Buffers have to be mentioned for translation                               */
563     for( count = 0, total_count = 0; count < numInBufs; count++, total_count++ ) {
564         if( codec_id == OMAP_DCE_VIDDEC3 ) {
565             Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[total_count]), INBUFS_INDEX, (int32_t)inBufs, (int32_t)&(((XDM2_BufDesc *)inBufs)->descs[count].buf), NULL);
566         } else if( codec_id == OMAP_DCE_VIDENC2 ) {
567             Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[total_count]), INBUFS_INDEX, (int32_t)inBufs, (int32_t)&(((IVIDEO2_BufDesc *)inBufs)->planeDesc[count].buf), NULL);
568         }
569     }
571     for( count = 0; count < numOutBufs; count++, total_count++ ) {
572         Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[total_count]), OUTBUFS_INDEX, (int32_t)outBufs, (int32_t)&(((XDM2_BufDesc *)outBufs)->descs[count].buf), NULL);
573     }
575     /* Invoke the Remote function through MmRpc */
576     eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
578     _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
580     eError = (dce_error_status)(fxnRet);
581 EXIT:
582     return (eError);
585 /*===============================================================*/
586 /** delete                : Delete Encode/Decode codec instance.
587  *
588  * @ param codec  [in]     : Codec Handle obtained in create() call.
589  * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
590  * @ return : NIL.
591  */
592 static void delete(void *codec, dce_codec_type codec_id)
594     MmRpc_FxnCtx        fxnCtx;
595     int32_t             fxnRet;
596     dce_error_status    eError = DCE_EOK;
598     _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
600     /* Marshall function arguments into the send buffer */
601     Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_DELETE, 2, 0, NULL);
602     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[0]), sizeof(int32_t), codec_id);
603     Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[1]), sizeof(int32_t), (int32_t)codec);
605     /* Invoke the Remote function through MmRpc */
606     eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
608     _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
610 EXIT:
611     return;
614 /*************** Deocder Codec Engine Functions ***********************/
615 VIDDEC3_Handle VIDDEC3_create(Engine_Handle engine, String name,
616                               VIDDEC3_Params *params)
618     VIDDEC3_Handle    codec;
620     DEBUG(">> engine=%p, name=%s, params=%p", engine, name, params);
621     codec = create(engine, name, params, OMAP_DCE_VIDDEC3);
622     DEBUG("<< codec=%p", codec);
623     return (codec);
626 XDAS_Int32 VIDDEC3_control(VIDDEC3_Handle codec, VIDDEC3_Cmd id,
627                            VIDDEC3_DynamicParams *dynParams, VIDDEC3_Status *status)
629     XDAS_Int32    ret;
631     DEBUG(">> codec=%p, id=%d, dynParams=%p, status=%p",
632           codec, id, dynParams, status);
633     if( id == XDM_GETVERSION ) {
634         ret = get_version(codec, dynParams, status, OMAP_DCE_VIDDEC3);
635     } else {
636         ret = control(codec, id, dynParams, status, OMAP_DCE_VIDDEC3);
637     }
638     DEBUG("<< ret=%d", ret);
639     return (ret);
642 XDAS_Int32 VIDDEC3_process(VIDDEC3_Handle codec,
643                            XDM2_BufDesc *inBufs, XDM2_BufDesc *outBufs,
644                            VIDDEC3_InArgs *inArgs, VIDDEC3_OutArgs *outArgs)
646     XDAS_Int32    ret;
648     DEBUG(">> codec=%p, inBufs=%p, outBufs=%p, inArgs=%p, outArgs=%p",
649           codec, inBufs, outBufs, inArgs, outArgs);
650     ret = process(codec, inBufs, outBufs, inArgs, outArgs, OMAP_DCE_VIDDEC3);
651     DEBUG("<< ret=%d", ret);
652     return (ret);
655 Void VIDDEC3_delete(VIDDEC3_Handle codec)
657     DEBUG(">> codec=%p", codec);
658     delete(codec, OMAP_DCE_VIDDEC3);
659     DEBUG("<<");
662 /*************** Enocder Codec Engine Functions ***********************/
663 VIDENC2_Handle VIDENC2_create(Engine_Handle engine, String name,
664                               VIDENC2_Params *params)
666     VIDENC2_Handle    codec;
668     DEBUG(">> engine=%p, name=%s, params=%p", engine, name, params);
669     codec = create(engine, name, params, OMAP_DCE_VIDENC2);
670     DEBUG("<< codec=%p", codec);
671     return (codec);
674 XDAS_Int32 VIDENC2_control(VIDENC2_Handle codec, VIDENC2_Cmd id,
675                            VIDENC2_DynamicParams *dynParams, VIDENC2_Status *status)
677     XDAS_Int32    ret;
679     DEBUG(">> codec=%p, id=%d, dynParams=%p, status=%p",
680           codec, id, dynParams, status);
681     ret = control(codec, id, dynParams, status, OMAP_DCE_VIDENC2);
682     DEBUG("<< ret=%d", ret);
683     return (ret);
686 XDAS_Int32 VIDENC2_process(VIDENC2_Handle codec,
687                            IVIDEO2_BufDesc *inBufs, XDM2_BufDesc *outBufs,
688                            VIDENC2_InArgs *inArgs, VIDENC2_OutArgs *outArgs)
690     XDAS_Int32    ret;
692     DEBUG(">> codec=%p, inBufs=%p, outBufs=%p, inArgs=%p, outArgs=%p",
693           codec, inBufs, outBufs, inArgs, outArgs);
694     ret = process(codec, inBufs, outBufs, inArgs, outArgs, OMAP_DCE_VIDENC2);
695     DEBUG("<< ret=%d", ret);
696     return (ret);
699 Void VIDENC2_delete(VIDENC2_Handle codec)
701     DEBUG(">> codec=%p", codec);
702     delete(codec, OMAP_DCE_VIDENC2);
703     DEBUG("<<");