[libDCE] Add IPC 3.x Adapted code to Repository
authorSaurabh Bipin Chandra <a0131926@ti.com>
Mon, 22 Apr 2013 16:42:19 +0000 (22:12 +0530)
committerSaurabh Bipin Chandra <a0131926@ti.com>
Fri, 26 Apr 2013 14:14:28 +0000 (19:44 +0530)
This patch adds libdce code to the repository.
LibDCE has been adapted to use the MmRpc layer
of IPC 3.x. This version of LibDCE is expected to
work on QNX.

Patchset 2 adds/modifies:
1. Removes Tiler 2D allocation/free for now.
2. Corrects memplugin_free() for Tiler 1D.
3. Modifies dce_test app to dump output till 30 frames.
4. Renamed dce.h to libdce.h.
5. Corrected header files across all files.
6. Build configuration for QNX
7. Removes build warnings.
8. Add README for Build instructions
9. Takes care of comments of Buddy and Pradeep.

Patchset 3 adds/modifies:
1. Reduced Stack usage of each function.
2. Add ptr check in memplugin and remove from libdce.
3. Add DCE_Assert macros.
4. Add DCE_error_status enum.
5. Comments Cleanup
6. Make some functions static.
7. process() cleanup including removing reply_buf.
8. Add else if (for codec_type == Encoder type)
9. Converted Macros to Inline functions.
10.Converted init and deinit to dce_init and dce_deinit functions.
11. Removed dce_init() and dce_deinit() declarations

Patchset 4 adds/modifies:
1. Assert Input function arguments.
2. Correct copyright year.
3. Correct memplugin_free for Shared memory.
4. Create dce_priv.h and move trace and assert macros to the header.
5. Redeclare mem_type enum and add mem_error_status enum in
   memplugin.h and make corresponding changes.
6. Add asserts in memplugin.

Intention of some of the changes above is to move towards
delinking Libdce and Memplugin.

Patchset 5:
1. Missed to add dce_priv.h file.

Patchset 6:
1. Take care Pradeep's comment.

Change-Id: I6e5e37b7088362e7bad66200fc3454bb828e0eff
Signed-off-by: Saurabh Bipin Chandra <a0131926@ti.com>
21 files changed:
Makefile [new file with mode: 0644]
README.txt [new file with mode: 0644]
common.mk [new file with mode: 0644]
dce_priv.h [new file with mode: 0644]
dce_rpc.h [new file with mode: 0644]
libdce.c [new file with mode: 0644]
libdce.h [new file with mode: 0644]
memplugin.h [new file with mode: 0644]
memplugin_qnx.c [new file with mode: 0644]
nto/Makefile [new file with mode: 0644]
nto/README.txt [new file with mode: 0644]
nto/arm/Makefile [new file with mode: 0644]
nto/arm/a.le.v7/Makefile [new file with mode: 0644]
nto/arm/so.le.v7/Makefile [new file with mode: 0644]
nto/qconf-override.mk [new file with mode: 0644]
test_qnx/Makefile [new file with mode: 0644]
test_qnx/arm/Makefile [new file with mode: 0644]
test_qnx/arm/le.v7/Makefile [new file with mode: 0644]
test_qnx/common.mk [new file with mode: 0644]
test_qnx/dce_test.c [new file with mode: 0644]
test_qnx/dce_test.use [new file with mode: 0644]

diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..18dffdd
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,3 @@
+LIST=libdce\r
+LATE_DIRS=test_qnx\r
+include recurse.mk\r
diff --git a/README.txt b/README.txt
new file mode 100644 (file)
index 0000000..05996e8
--- /dev/null
@@ -0,0 +1,51 @@
+## Building LIBDCE for QNX ##
+
+Exporting QNX variables:
+export QNX_ROOT=/opt/qnx650
+export QNX_HOST=${QNX_ROOT}/host/linux/x86
+export LD_LIBRARY_PATH=${QNX_HOST}/usr/lib
+export QNX_TARGET=${QNX_ROOT}/target/qnx6
+export MAKEFLAGS=-I${QNX_TARGET}/usr/include
+export QNX_CONFIGURATION=/etc/qnx
+export QNX_JAVAHOME=${QNX_ROOT}/_jvm
+export PATH=${QNX_HOST}/usr/bin:${PATH}:${QNX_CONFIGURATION}/bin
+export QNX_USERNAME=<registered email-id at QNX> //not important
+eval `qconfig -n "QNX Software Development Platform 6.5.0" -e`
+
+If previous eval doesn't work, that is it doesn't output:
+export QNX_HOST="/opt/qnx650/host/linux/x86";
+export QNX_TARGET="/opt/qnx650/target/qnx6";
+export PATH="/opt/qnx650/host/linux/x86/usr/bin:/opt/qnx650/host/linux/x86/bin:/opt/qnx650/host/
+             linux/x86/sbin:/opt/qnx650/host/linux/x86/usr/sbin:/opt/qnx650/host/linux/x86/usr/photon/appbuilder:
+             /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/etc/qnx/bin:/etc/qnx/bin:
+             /opt/qnx650:/etc/qnx/bin:/etc/qnx/bin:/etc/qnx/bin:/etc/qnx/bin";
+export LD_LIBRARY_PATH="/opt/qnx650/host/linux/x86/usr/lib";
+export MAKEFLAGS="-I/opt/qnx650/target/qnx6/usr/include";
+
+then try : /opt/qnx650/host/linux/x86/usr/bin/qconfig -n "QNX Software Development Platform 6.5.0" -e
+
+Exporting LIBDCE variables:
+export TITOOLSROOT=<path to XDC, XDAIS>
+export TIVIDEOTOOLSROOT=<path to CE, FC>
+export IPCHEADERS=<path to IPC Headers>
+export INSTALL_ROOT=<path for copying output binaries>
+export QCONF_OVERRIDE=<absolute path to libdce/nto/qconf-override.mk>
+export IVAHDCODECS=<path to ipumm/extrel/ti/ivahd_codecs>
+
+For IPCHEADERS - Headers should be at:
+$(IPCHEADERS)/usr/include/memmgr
+$(IPCHEADERS)/usr/include/ti/syslink/
+$(IPCHEADERS)/usr/include/ti/ipc/mm
+$(IPCHEADERS)/usr/include/ti/shmemallocator
+$(IPCHEADERS)/usr/include/
+
+Building:
+make install
+
+Clean:
+make clean
+
+Location of Binaries:
+INSTALL_ROOT/armle-v7/usr/lib/libdce.so
+INSTALL_ROOT/armle-v7/usr/lib/libdce.so.1
+INSTALL_ROOT/armle-v7/bin/dce_test
diff --git a/common.mk b/common.mk
new file mode 100644 (file)
index 0000000..b430901
--- /dev/null
+++ b/common.mk
@@ -0,0 +1,62 @@
+###################### QNX DCE Build Config #######################\r
+\r
+#### Include qconfig.mk\r
+ifndef QCONFIG\r
+QCONFIG=qconfig.mk\r
+endif\r
+\r
+include $(QCONFIG)\r
+\r
+#### Overriding qrules.mk macros before including qtargets.mk\r
+\r
+# Flags to add to the C compiler command line\r
+CCFLAGS+=-O2 -Dxdc_target_types__=qnx/targets/arm/std.h -DBUILDOS_QNX=1\r
+\r
+# To get final library name as "libdce". Needed as project name is not dce\r
+NAME=dce\r
+\r
+### Add files to be included for Build\r
+TITOOLSROOT    ?= /usr/local\r
+TIVIDEOTOOLSROOT       ?= $(TITOOLSROOT)\r
+# Different tool versions can easily be programmed by defining below variables\r
+# in your environment.\r
+CEVERSION      ?= codec_engine_3_23_00_07\r
+FCVERSION      ?= framework_components_3_23_03_17\r
+XDAISVERSION   ?= xdais_7_23_00_06\r
+XDCVERSION     ?= xdctools_3_25_00_48\r
+IPCHEADERS     ?= $(INSTALL_ROOT_nto)\r
+\r
+# Generate the full package paths for tools\r
+CEPROD         = $(TIVIDEOTOOLSROOT)/$(CEVERSION)\r
+FCPROD         = $(TIVIDEOTOOLSROOT)/$(FCVERSION)\r
+XDAISPROD      = $(TITOOLSROOT)/$(XDAISVERSION)\r
+XDCPROD            = $(TITOOLSROOT)/$(XDCVERSION)\r
+\r
+EXTRA_INCVPATH += $(CEPROD)/packages\r
+EXTRA_INCVPATH += $(FCPROD)/packages\r
+EXTRA_INCVPATH += $(XDAISPROD)/packages\r
+EXTRA_INCVPATH += $(XDCPROD)/packages\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include/memmgr\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include/ti/syslink/\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include/ti/ipc/mm\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include/ti/shmemallocator\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include/\r
+\r
+# Include IPC libraries\r
+LIBS += memmgr mmrpc sharedmemallocatorS\r
+\r
+# Include qmacros.mk\r
+include $(MKFILES_ROOT)/qmacros.mk\r
+\r
+#### Overriding qtargets.mk macros before including qtargets.mk\r
+INSTALLDIR=usr/lib\r
+INSTALLDIR+=usr/local\r
+\r
+define PINFO\r
+PINFO DESCRIPTION = libdce codec\r
+endef\r
+\r
+#### Include qtargets.mk, it internally includes qrules.mk\r
+include $(MKFILES_ROOT)/qtargets.mk\r
+\r
+#### Post-set make macros after including qtargets.mk (if-any)\r
diff --git a/dce_priv.h b/dce_priv.h
new file mode 100644 (file)
index 0000000..dea43d4
--- /dev/null
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DCE_PRIV_H__
+#define __DCE_PRIV_H__
+
+#include <sys/slog.h>
+
+/********************* MACROS ************************/
+/***************** TRACE MACROS  *********************/
+/* Need to make it OS specific and support different trace levels */
+#define ERROR(FMT, ...)  do { \
+        slogf(42, _SLOG_INFO, "%s:%d:\t%s\terror: " FMT, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
+} while( 0 )
+#define DEBUG(FMT, ...)  do { \
+        slogf(42, _SLOG_DEBUG2, "%s:%d:\t%s\tdebug: " FMT, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
+} while( 0 )
+
+
+/***************** ASSERT MACROS *********************/
+#define _ASSERT_AND_EXECUTE(_COND_, _ERRORCODE_, _EXPR_) do { \
+        if( !(_COND_)) { eError = _ERRORCODE_; \
+                         ERROR("Failed %s error val %d", # _COND_, _ERRORCODE_); \
+                         _EXPR_; \
+                         goto EXIT; } \
+} while( 0 )
+
+#define _ASSERT(_COND_, _ERRORCODE_) do { \
+        if( !(_COND_)) { eError = _ERRORCODE_; \
+                         ERROR("Failed %s error val %d", # _COND_, _ERRORCODE_); \
+                         goto EXIT; } \
+} while( 0 )
+
+#endif /* __DCE_PRIV_H__ */
+
diff --git a/dce_rpc.h b/dce_rpc.h
new file mode 100644 (file)
index 0000000..8082d76
--- /dev/null
+++ b/dce_rpc.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DCE_RPC_H__
+#define __DCE_RPC_H__
+
+/* RPC layer types.. these define the payload of messages between IPUMM
+ * and MPU.  This should be kept in sync between firmware build and
+ * driver.
+ *
+ * TODO: xxx_control(XDM_GETVERSION) is a bit awkward to deal with, because
+ * this seems to be the one special case where status->data is used..
+ * possibly we should define a special ioctl and msg to handle this case.
+ */
+
+#define DCE_DEVICE_NAME "rpmsg-dce"
+
+/* Message-Ids:
+ */
+//#define DCE_RPC_CONNECT         (0x80000000 | 00) Connect not needed anymore.
+typedef enum dce_rpc_call {
+    DCE_RPC_ENGINE_OPEN = 0,
+    DCE_RPC_ENGINE_CLOSE,
+    DCE_RPC_CODEC_CREATE,
+    DCE_RPC_CODEC_CONTROL,
+    DCE_RPC_CODEC_GET_VERSION,
+    DCE_RPC_CODEC_PROCESS,
+    DCE_RPC_CODEC_DELETE
+} dce_rpc_call;
+
+
+typedef enum dce_codec_type {
+    OMAP_DCE_VIDENC2 = 1,
+    OMAP_DCE_VIDDEC3 = 2
+} dce_codec_type;
+
+/* Structures of RPC */
+typedef struct dce_connect {
+    uint32_t chipset_id;
+    uint32_t debug;
+} dce_connect;
+
+typedef struct dce_engine_open {
+    char          name[32]; /* engine name (in) */
+    Engine_Error  error_code;   /* error code (out) */
+    Engine_Handle eng_handle;   /* engine handle (out) */
+} dce_engine_open;
+
+typedef struct dce_engine_close {
+    Engine_Handle eng_handle;   /* engine handle (in) */
+} dce_engine_close;
+
+typedef struct dce_codec_create {
+    Engine_Handle  engine;
+    char           codec_name[32];
+    void          *static_params;
+    dce_codec_type codec_id;
+    void          *codec_handle;
+} dce_codec_create;
+
+typedef struct dce_codec_control {
+    void          *codec_handle;
+    uint32_t       cmd_id;
+    void          *dyn_params;
+    void          *status;
+    dce_codec_type codec_id;
+    int32_t        result;
+} dce_codec_control;
+
+typedef struct dce_codec_get_version {
+    void          *codec_handle;
+    void          *dyn_params;
+    void          *status;
+    void          *version;
+    dce_codec_type codec_id;
+    int32_t        result;
+} dce_codec_get_version;
+
+typedef struct dce_codec_delete {
+    void          *codec_handle;
+    dce_codec_type codec_id;
+} dce_codec_delete;
+
+/*  ---------------------- For GLP DCE -----------------------------*/
+/* NOTE: CODEC_PROCESS does somewhat more than the other ioctls, in that it
+ * handles buffer mapping/unmapping.  So the inBufs/outBufs are copied inline
+ * (with translated addresses in the copy sent inline with codec_process_req).
+ * Since we need the inputID from inArgs, and it is a small struct, it is also
+ * copied inline.
+ *
+ * Therefore, the variable length data[] section has the format:
+ *    uint8_t reloc[reloc_length * 4];
+ *    uint8_t inargs[in_args_length * 4];
+ *    uint8_t outbufs[in_bufs_length * 4];
+ *    uint8_t inbufs[in_bufs_length * 4];
+ */
+
+#define MAX_INPUT_BUF 2 // Need to confirm for interlaced YUVs for Encoders
+#define MAX_OUTPUT_BUF 2
+#define MAX_TOTAl_BUF (MAX_INPUT_BUF + MAX_OUTPUT_BUF)
+
+/* Struct to be used if approach [3] of Mmrpc call is followed */
+typedef struct dce_codec_process {
+    void          *codec_handle;
+    void          *inBufs;
+    void          *outBufs;
+    void          *inArgs;
+    void          *outArgs;
+    int32_t        input_Buf[MAX_INPUT_BUF];
+    int32_t        output_Buf[MAX_OUTPUT_BUF];
+    dce_codec_type codec_id;
+    int32_t        result;
+} dce_codec_process;
+
+#endif /* __DCE_RPC_H__ */
+
diff --git a/libdce.c b/libdce.c
new file mode 100644 (file)
index 0000000..bffebac
--- /dev/null
+++ b/libdce.c
@@ -0,0 +1,711 @@
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+********************************** Notes ******************************************
+*******
+********************************* Memory *****************************************
+*
+*******
+********************************* IPC 3.x *****************************************
+* Two approaches are followed for IPC MmRpc calls.
+* 1. All the parameters which need to be sent and received to/from IPU are coupled in a struct
+*     allocated from Shared Memory. Only the adrress of the struct is passed to MmRpc
+*     as a pointer argument. This approach is useful as MmRpc in some cases to avoid multiple
+*     translations.
+*     This approach is followed for :
+*     Engine_open(), Engine_close(), create(), control(), delete()
+*     For understanding refer to the Mmrpc_test.c in IPC 3.x
+* 2. All the parameters which need to be sent are given as separate arguments to
+*     MmRpc. This appraoch is needed when you need to translate an address which is
+*     ofsetted from a pointer which in itself needs to be translated.
+*     This apporach is followed for : process()
+*     For understanding, take the example of inbufs argument in process call(). Inbufs
+*     allocated in Shared memory and needs to be translated, has the address of Input
+*     buffer (allocated from Tiler). It is not possible to give the Input buffer as an argument
+*     to Mmrpc for translation until inbufs is given as a parameter to Mmrpc. Therefore inbuf
+*     can't be populated inside another Shared memory struct.
+* 3. This approach is a workaround to use approach [1] by solving the issue posed by [2].
+*     This approach is followed for : get_version()
+*     Taking the example of inbufs to explain, the Input buffer address will be one of the
+*     parameters of the struct (explained in [1]) along with inbufs address. Therefore the
+*     Input buffer address will get translated here. At the IPU, this address needs to be
+*     copied back to inbufs.
+*********************************************************************************
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <errno.h>
+
+#include <xdc/std.h>
+
+#if defined(BUILDOS_GLP)
+#include <xf86drm.h>
+#include <omap_drm.h>
+#include <omap_dce.h>
+#include <omap_drmif.h>
+#endif /* BUILDOS_GLP */
+
+/* IPC Headers */
+#include <MmRpc.h>
+
+/*DCE Headers */
+#include "libdce.h"
+#include "dce_rpc.h"
+#include "dce_priv.h"
+#include "memplugin.h"
+
+
+#if defined(BUILDOS_GLP)
+#ifdef GLP_X11
+int dce_auth_x11(int *fd);
+#endif /* GLP_X11 */
+#ifdef GLP_WAYLAND
+int dce_auth_wayland(int *fd);
+#endif /* GLP_WAYLAND */
+
+static int                   fd = -1;
+static struct omap_device   *dev;
+static int                   ioctl_base;
+#define CMD(name) (ioctl_base + DRM_OMAP_DCE_##name)
+
+uint32_t    dce_debug = 3;
+#endif /* BUILDOS_GLP */
+
+
+/********************* GLOBALS ***********************/
+/* Hande used for Remote Communication                               */
+static MmRpc_Handle       MmRpcHandle = NULL;
+static pthread_mutex_t    mutex = PTHREAD_MUTEX_INITIALIZER;
+static int                count = 0;
+
+
+/****************** INLINE FUNCTIONS ********************/
+
+static inline void Fill_MmRpc_fxnCtx(MmRpc_FxnCtx *fxnCtx, int fxn_id, int num_params, int num_xlts, MmRpc_Xlt *xltAry)
+{
+    fxnCtx->fxn_id = fxn_id;
+    fxnCtx->num_params = num_params;
+    fxnCtx->num_xlts = num_xlts;
+    fxnCtx->xltAry = xltAry;
+}
+
+static inline void Fill_MmRpc_fxnCtx_Ptr_Params(MmRpc_Param *mmrpc_params, int size, void *addr, void *handle)
+{
+    mmrpc_params->type = MmRpc_ParamType_Ptr;
+    mmrpc_params->param.ptr.size = size;
+    mmrpc_params->param.ptr.addr = (size_t)addr;
+    mmrpc_params->param.ptr.handle = (size_t)handle;
+}
+
+static inline void Fill_MmRpc_fxnCtx_Scalar_Params(MmRpc_Param *mmrpc_params, int size, int data)
+{
+    mmrpc_params->type = MmRpc_ParamType_Scalar;
+    mmrpc_params->param.scalar.size = size;
+    mmrpc_params->param.scalar.data = (size_t)data;
+}
+
+static inline void Fill_MmRpc_fxnCtx_Xlt_Array(MmRpc_Xlt *mmrpc_xlt, int index, int32_t base, int32_t addr, void *handle)
+{
+    /* index : index of params filled in FxnCtx                                                                                        */
+    /* base  : user Virtual Address as per definition in MmRpc and not base from where offset is calculated */
+    /* offset : calculated from address of index                                                                                      */
+    mmrpc_xlt->index = index;
+    mmrpc_xlt->offset = MmRpc_OFFSET(base, addr);
+    mmrpc_xlt->base = (size_t)addr;
+    mmrpc_xlt->handle = (size_t)handle;
+}
+
+/************************ FUNCTIONS **************************/
+/* Interface for QNX for parameter buffer allocation                                */
+/* These interfaces are implemented to maintain Backward Compatability */
+void *dce_alloc(int sz)
+{
+    return (memplugin_alloc(sz, 0, TILER_1D_BUFFER));
+}
+
+void dce_free(void *ptr)
+{
+    memplugin_free(ptr, TILER_1D_BUFFER);
+}
+
+/*************** Startup/Shutdown Functions ***********************/
+static int dce_init(void)
+{
+    dce_error_status    eError = DCE_EOK;
+    MmRpc_Params        args;
+
+    printf(" >> dce_init\n");
+
+    pthread_mutex_lock(&mutex);
+
+    count++;
+    /* Check if already Initialized */
+    _ASSERT(count == 1, DCE_EOK);
+
+    /* Create remote server insance */
+    MmRpc_Params_init(&args);
+
+    eError = MmRpc_create(DCE_DEVICE_NAME, &args, &MmRpcHandle);
+
+    _ASSERT_AND_EXECUTE(eError == DCE_EOK, DCE_EIPC_CREATE_FAIL, count--);
+
+    printf("open(/dev/" DCE_DEVICE_NAME ") -> 0x%x\n", (int)MmRpcHandle);
+EXIT:
+    pthread_mutex_unlock(&mutex);
+    return (eError);
+}
+
+static void dce_deinit(void)
+{
+    pthread_mutex_lock(&mutex);
+
+    count--;
+    if( count > 0 ) {
+        goto EXIT;
+    }
+
+    if( MmRpcHandle != NULL ) {
+        MmRpc_delete(&MmRpcHandle);
+    }
+    MmRpcHandle = NULL;
+EXIT:
+    pthread_mutex_unlock(&mutex);
+    return;
+}
+
+/*===============================================================*/
+/** Engine_open        : Open Codec Engine.
+ *
+ * @ param attrs  [in]       : Engine Attributes. This param is not passed to Remote core.
+ * @ param name [in]       : Name of Encoder or Decoder codec.
+ * @ param ec [out]         : Error returned by Codec Engine.
+ * @ return : Codec Engine Handle is returned to be used to create codec.
+ *                 In case of error, NULL is returned as Engine Handle.
+ */
+Engine_Handle Engine_open(String name, Engine_Attrs *attrs, Engine_Error *ec)
+{
+    MmRpc_FxnCtx        fxnCtx;
+    int32_t             fxnRet;
+    dce_error_status    eError = DCE_EOK;
+    dce_engine_open    *engine_open_msg = NULL;
+    Engine_Handle       eng_handle = NULL;
+
+    _ASSERT(name != '\0', DCE_EINVALID_INPUT);
+    _ASSERT(ec != NULL, DCE_EINVALID_INPUT);
+
+    /* Initialize DCE and IPC. In case of Error Deinitialize them */
+    _ASSERT_AND_EXECUTE(dce_init() == DCE_EOK, DCE_EIPC_CREATE_FAIL, dce_deinit());
+
+    printf(">> Engine_open Params::name = %s size = %d\n", name, strlen(name));
+    /* Allocate Shared memory for the engine_open rpc msg structure*/
+    /* Tiler Memory preferred for now for First level testing */
+    engine_open_msg = memplugin_alloc(sizeof(dce_engine_open), 0, TILER_1D_BUFFER);
+
+    _ASSERT_AND_EXECUTE(engine_open_msg != NULL, DCE_EOUT_OF_MEMORY, eng_handle = NULL);
+
+    /* Populating the msg structure with all the params */
+    /* Populating all params into a struct avoid individual address translations of name, ec */
+    strncpy(engine_open_msg->name, name, strlen(name));
+    engine_open_msg->eng_handle = NULL;
+
+    /* Marshall function arguments into the send buffer */
+    Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_ENGINE_OPEN, 1, 0, NULL);
+    Fill_MmRpc_fxnCtx_Ptr_Params(fxnCtx.params, sizeof(dce_engine_open), engine_open_msg, NULL);
+
+    /* Invoke the Remote function through MmRpc */
+    eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
+
+    /* In case of Error, the Application will get a NULL Engine Handle */
+    _ASSERT_AND_EXECUTE(eError == DCE_EOK, DCE_EIPC_CALL_FAIL, eng_handle = NULL);
+
+    /* Populate return arguments */
+    eng_handle = engine_open_msg->eng_handle;
+    ec[0] = engine_open_msg->error_code;
+
+EXIT:
+    memplugin_free(engine_open_msg, TILER_1D_BUFFER);
+
+    return (eng_handle);
+}
+
+/*===============================================================*/
+/** Engine_close           : Close Engine.
+ *
+ * @ param engine  [in]    : Engine Handle obtained in Engine_open() call.
+ */
+Void Engine_close(Engine_Handle engine)
+{
+    MmRpc_FxnCtx        fxnCtx;
+    int32_t             fxnRet;
+    dce_error_status    eError = DCE_EOK;
+    dce_engine_close   *engine_close_msg = NULL;
+
+    _ASSERT(engine != NULL, DCE_EINVALID_INPUT);
+
+    /* Allocate Shared/Tiler memory for the engine_close rpc msg structure*/
+    engine_close_msg = memplugin_alloc(sizeof(dce_engine_close), 0, TILER_1D_BUFFER);
+
+    _ASSERT(engine_close_msg != NULL, DCE_EOUT_OF_MEMORY);
+
+    /* Populating the msg structure with all the params */
+    engine_close_msg->eng_handle = engine;
+
+    /* Marshall function arguments into the send buffer */
+    Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_ENGINE_CLOSE, 1, 0, NULL);
+    Fill_MmRpc_fxnCtx_Ptr_Params(fxnCtx.params, sizeof(dce_engine_close), engine_close_msg, NULL);
+
+    /* Invoke the Remote function through MmRpc */
+    eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
+
+    _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
+
+EXIT:
+    memplugin_free(engine_close_msg, TILER_1D_BUFFER);
+
+    dce_deinit();
+    return;
+}
+
+/*===============================================================*/
+/** Functions create(), control(), get_version(), process(), delete() are common codec
+ * glue function signatures which are same for both encoder and decoder
+ */
+/*===============================================================*/
+/** create         : Create Encoder/Decoder codec.
+ *
+ * @ param engine  [in]    : Engine Handle obtained in Engine_open() call.
+ * @ param name [in]       : Name of Encoder or Decoder codec.
+ * @ param params [in]     : Static parameters of codec.
+ * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
+ * @ return : Codec Handle is returned to be used for control, process, delete calls.
+ *                 In case of error, NULL is returned.
+ */
+static void *create(Engine_Handle engine, String name, void *params, dce_codec_type codec_id)
+{
+    MmRpc_FxnCtx        fxnCtx;
+    MmRpc_Xlt           xltAry;
+    int32_t             fxnRet;
+    dce_error_status    eError = DCE_EOK;
+    dce_codec_create   *codec_create_msg = NULL;
+    void               *codec_handle = NULL;
+
+    _ASSERT(name != '\0', DCE_EINVALID_INPUT);
+    _ASSERT(engine != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(params != NULL, DCE_EINVALID_INPUT);
+
+    /* Allocate Shared/Tiler memory for the codec_create rpc msg structure*/
+    codec_create_msg = memplugin_alloc(sizeof(dce_codec_create), 0, TILER_1D_BUFFER);
+
+    _ASSERT_AND_EXECUTE(codec_create_msg != NULL, DCE_EOUT_OF_MEMORY, codec_handle = NULL);
+
+    /* Populating the msg structure with all the params */
+    codec_create_msg->engine = engine;
+    strncpy(codec_create_msg->codec_name, name, strlen(name));
+    codec_create_msg->codec_id = codec_id;
+    codec_create_msg->codec_handle = NULL;
+    codec_create_msg->static_params = params;
+
+    /* Marshall function arguments into the send buffer */
+    Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_CREATE, 1, 1, &xltAry);
+    Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[0]), sizeof(dce_codec_create), codec_create_msg, NULL);
+
+    /* Mention the virtual pointers that need translation */
+    /* Allocations through dce_alloc need translation     */
+    /* In this case the static params buffer need translation */
+    Fill_MmRpc_fxnCtx_Xlt_Array(fxnCtx.xltAry, 0, (int32_t)codec_create_msg, (int32_t)&(codec_create_msg->static_params), NULL);
+
+    /* Invoke the Remote function through MmRpc */
+    eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
+
+    /* In case of Error, the Application will get a NULL Codec Handle */
+    _ASSERT_AND_EXECUTE(eError == DCE_EOK, DCE_EIPC_CALL_FAIL, codec_handle = NULL);
+
+    codec_handle = codec_create_msg->codec_handle;
+
+EXIT:
+    memplugin_free(codec_create_msg, TILER_1D_BUFFER);
+
+    return (codec_handle);
+}
+
+/*===============================================================*/
+/** control               : Codec control call.
+ *
+ * @ param codec  [in]     : Codec Handle obtained in create() call.
+ * @ param id [in]            : Command id for XDM control operation.
+ * @ param dynParams [in] : Dynamic input parameters to Codec.
+ * @ param status [out]    : Codec returned status parameters.
+ * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
+ * @ return : Status of control() call is returned.
+ *                #XDM_EOK                  [0]   :  Success.
+ *                #XDM_EFAIL                [-1] :  Failure.
+ *                #IPC_FAIL                   [-2] : MmRpc Call failed.
+ *                #XDM_EUNSUPPORTED [-3] :  Unsupported request.
+ *                #OUT_OF_MEMORY       [-4] :  Out of Shared Memory.
+ */
+static XDAS_Int32 control(void *codec, int id, void *dynParams, void *status, dce_codec_type codec_id)
+{
+    MmRpc_FxnCtx         fxnCtx;
+    MmRpc_Xlt            xltAry[2];
+    int32_t              fxnRet;
+    dce_error_status     eError = DCE_EOK;
+    dce_codec_control   *codec_control_msg = NULL;
+
+    _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(dynParams != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(status != NULL, DCE_EINVALID_INPUT);
+
+    /* Allocate Shared/Tiler memory for the codec_control rpc msg structure*/
+    codec_control_msg = memplugin_alloc(sizeof(dce_codec_control), 0, TILER_1D_BUFFER);
+
+    _ASSERT(codec_control_msg != NULL, DCE_EOUT_OF_MEMORY);
+
+    /* Populating the msg structure with all the params */
+    codec_control_msg->codec_handle = codec;
+    codec_control_msg->cmd_id = id;
+    codec_control_msg->codec_id = codec_id;
+    codec_control_msg->dyn_params = dynParams;
+    codec_control_msg->status = status;
+
+    /* Marshall function arguments into the send buffer */
+    Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_CONTROL, 1, 2, xltAry);
+    Fill_MmRpc_fxnCtx_Ptr_Params(fxnCtx.params, sizeof(dce_codec_control), codec_control_msg, NULL);
+
+    /* Dynamic and status params buffer need translation */
+    Fill_MmRpc_fxnCtx_Xlt_Array(fxnCtx.xltAry, 0, (int32_t)codec_control_msg, (int32_t)&(codec_control_msg->dyn_params), NULL);
+    Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[1]), 0, (int32_t)codec_control_msg, (int32_t)&(codec_control_msg->status), NULL);
+
+    /* Invoke the Remote function through MmRpc */
+    eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
+
+    _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
+
+    eError = codec_control_msg->result;
+
+EXIT:
+    memplugin_free(codec_control_msg, TILER_1D_BUFFER);
+
+    return (eError);
+}
+
+/*===============================================================*/
+/** get_version        : Codec control call to get the codec version. This call has been made
+ *                                     separate from control call because it involves an additional version
+ *                                     buffer translation.
+ *
+ * @ param codec  [in]     : Codec Handle obtained in create() call.
+ * @ param id [in]            : Command id for XDM control operation.
+ * @ param dynParams [in] : Dynamic input parameters to Codec.
+ * @ param status [out]    : Codec returned status parameters.
+ * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
+ * @ return : Status of control() call is returned.
+ *                #XDM_EOK                  [0]   :  Success.
+ *                #XDM_EFAIL                [-1] :  Failure.
+ *                #IPC_FAIL                   [-2] : MmRpc Call failed.
+ *                #XDM_EUNSUPPORTED [-3] :  Unsupported request.
+ *                #OUT_OF_MEMORY       [-4] :  Out of Shared Memory.
+ */
+static XDAS_Int32 get_version(void *codec, void *dynParams, void *status, dce_codec_type codec_id)
+{
+    MmRpc_FxnCtx             fxnCtx;
+    MmRpc_Xlt                xltAry[3];
+    int32_t                  fxnRet;
+    dce_error_status         eError = DCE_EOK;
+    dce_codec_get_version   *codec_get_version_msg = NULL;
+
+    _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(dynParams != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(status != NULL, DCE_EINVALID_INPUT);
+
+    /* Allocate Shared/Tiler memory for the codec_get_version rpc msg structure*/
+    codec_get_version_msg = memplugin_alloc(sizeof(dce_codec_get_version), 0, TILER_1D_BUFFER);
+
+    _ASSERT(codec_get_version_msg != NULL, DCE_EOUT_OF_MEMORY);
+
+    /* Populating the msg structure with all the params */
+    codec_get_version_msg->codec_handle = codec;
+    codec_get_version_msg->codec_id = codec_id;
+    codec_get_version_msg->dyn_params = dynParams;
+    codec_get_version_msg->status = status;
+    if( codec_id == OMAP_DCE_VIDDEC3 ) {
+        codec_get_version_msg->version = ((IVIDDEC3_Status *)status)->data.buf;
+    } else if( codec_id == OMAP_DCE_VIDENC2 ) {
+        codec_get_version_msg->version = ((IVIDDEC3_Status *)status)->data.buf;
+    }
+
+    /* Marshall function arguments into the send buffer */
+    Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_CONTROL, 1, 3, xltAry);
+    Fill_MmRpc_fxnCtx_Ptr_Params(fxnCtx.params, sizeof(dce_codec_get_version), codec_get_version_msg, NULL);
+
+    /* Dynamic, status params and version info buffer need translation */
+    Fill_MmRpc_fxnCtx_Xlt_Array(fxnCtx.xltAry, 0, (int32_t)codec_get_version_msg, (int32_t)&(codec_get_version_msg->dyn_params), NULL);
+    Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[1]), 0, (int32_t)codec_get_version_msg, (int32_t)&(codec_get_version_msg->status), NULL);
+    Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[2]), 0, (int32_t)codec_get_version_msg, (int32_t)&(codec_get_version_msg->version), NULL);
+
+    /* Invoke the Remote function through MmRpc */
+    eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
+
+    _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
+
+    eError = codec_get_version_msg->result;
+
+EXIT:
+    memplugin_free(codec_get_version_msg, TILER_1D_BUFFER);
+
+    return (eError);
+}
+
+typedef enum process_call_params {
+    CODEC_HANDLE_INDEX = 0,
+    INBUFS_INDEX,
+    OUTBUFS_INDEX,
+    INARGS_INDEX,
+    OUTARGS_INDEX,
+    CODEC_ID_INDEX
+} process_call_params;
+
+/*===============================================================*/
+/** process               : Encode/Decode process.
+ *
+ * @ param codec  [in]     : Codec Handle obtained in create() call.
+ * @ param inBufs [in]     : Input buffer details.
+ * @ param outBufs [in]    : Output buffer details.
+ * @ param inArgs [in]     : Input arguments.
+ * @ param outArgs [out]  : Output arguments.
+ * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
+ * @ return : Status of the process call.
+ *                #XDM_EOK                  [0]   :  Success.
+ *                #XDM_EFAIL                [-1] :  Failure.
+ *                #IPC_FAIL                   [-2] :  MmRpc Call failed.
+ *                #XDM_EUNSUPPORTED [-3] :  Unsupported request.
+ */
+static XDAS_Int32 process(void *codec, void *inBufs, void *outBufs,
+                          void *inArgs, void *outArgs, dce_codec_type codec_id)
+{
+    MmRpc_FxnCtx        fxnCtx;
+    MmRpc_Xlt           xltAry[MAX_TOTAl_BUF];
+    int                 fxnRet, count, total_count, numInBufs = 0, numOutBufs = 0, sz[5] = { 0 };
+    dce_error_status    eError = DCE_EOK;
+
+    _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(inBufs != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(outBufs != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(inArgs != NULL, DCE_EINVALID_INPUT);
+    _ASSERT(outArgs != NULL, DCE_EINVALID_INPUT);
+
+    if( codec_id == OMAP_DCE_VIDDEC3 ) {
+        numInBufs = ((XDM2_BufDesc *)inBufs)->numBufs;
+        numOutBufs = ((XDM2_BufDesc *)outBufs)->numBufs;
+        sz[INBUFS_INDEX] = sizeof(XDM2_BufDesc);
+        sz[OUTBUFS_INDEX] = sizeof(XDM2_BufDesc);
+        sz[INARGS_INDEX] = sizeof(VIDDEC3_InArgs);
+        sz[OUTARGS_INDEX] = sizeof(VIDDEC3_OutArgs);
+    } else if( codec_id == OMAP_DCE_VIDENC2 ) {
+        numInBufs = ((IVIDEO2_BufDesc *)inBufs)->numPlanes;
+        numOutBufs = ((XDM2_BufDesc *)outBufs)->numBufs;
+        sz[INBUFS_INDEX] = sizeof(IVIDEO2_BufDesc);
+        sz[OUTBUFS_INDEX] = sizeof(XDM2_BufDesc);
+        sz[INARGS_INDEX] = sizeof(VIDENC2_InArgs);
+        sz[OUTARGS_INDEX] = sizeof(VIDENC2_OutArgs);
+    }
+
+    /* marshall function arguments into the send buffer                       */
+    /* Approach [2] as explained in "Notes" used for process               */
+    Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_PROCESS, 6, numInBufs + numOutBufs, xltAry);
+    Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[CODEC_HANDLE_INDEX]), sizeof(int32_t), (int32_t)codec);
+    Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[INBUFS_INDEX]), sz[INBUFS_INDEX], inBufs, NULL);
+    Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[OUTBUFS_INDEX]), sz[OUTBUFS_INDEX], outBufs, NULL);
+    Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[INARGS_INDEX]), sz[INARGS_INDEX], inArgs, NULL);
+    Fill_MmRpc_fxnCtx_Ptr_Params(&(fxnCtx.params[OUTARGS_INDEX]), sz[OUTARGS_INDEX], outArgs, NULL);
+    Fill_MmRpc_fxnCtx_Scalar_Params(&(fxnCtx.params[CODEC_ID_INDEX]), sizeof(int32_t), codec_id);
+
+    /* InBufs, OutBufs, InArgs, OutArgs buffer need translation but since they have been */
+    /* individually mentioned as fxnCtx Params, they need not be mentioned below again */
+    /* Input and Output Buffers have to be mentioned for translation                               */
+    for( count = 0, total_count = 0; count < numInBufs; count++, total_count++ ) {
+        if( codec_id == OMAP_DCE_VIDDEC3 ) {
+            Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[total_count]), INBUFS_INDEX, (int32_t)inBufs, (int32_t)&(((XDM2_BufDesc *)inBufs)->descs[count].buf), NULL);
+        } else if( codec_id == OMAP_DCE_VIDENC2 ) {
+            Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[total_count]), INBUFS_INDEX, (int32_t)inBufs, (int32_t)&(((IVIDEO2_BufDesc *)inBufs)->planeDesc[count].buf), NULL);
+        }
+    }
+
+    for( count = 0; count < numOutBufs; count++, total_count++ ) {
+        Fill_MmRpc_fxnCtx_Xlt_Array(&(fxnCtx.xltAry[total_count]), OUTBUFS_INDEX, (int32_t)outBufs, (int32_t)&(((XDM2_BufDesc *)outBufs)->descs[count].buf), NULL);
+    }
+
+    /* Invoke the Remote function through MmRpc */
+    eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
+
+    _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
+
+    eError = (dce_error_status)(fxnRet);
+EXIT:
+    return (eError);
+}
+
+/*===============================================================*/
+/** delete                : Delete Encode/Decode codec instance.
+ *
+ * @ param codec  [in]     : Codec Handle obtained in create() call.
+ * @ param codec_id [in]  : To differentiate between Encoder and Decoder codecs.
+ * @ return : NIL.
+ */
+static void delete(void *codec, dce_codec_type codec_id)
+{
+    MmRpc_FxnCtx        fxnCtx;
+    int32_t             fxnRet;
+    dce_error_status    eError = DCE_EOK;
+    dce_codec_delete   *codec_delete_msg = NULL;
+
+    _ASSERT(codec != NULL, DCE_EINVALID_INPUT);
+
+    /* Allocate Shared/Tiler memory for the codec_delete rpc msg structure*/
+    codec_delete_msg = memplugin_alloc(sizeof(dce_codec_delete), 0, TILER_1D_BUFFER);
+
+    _ASSERT(codec_delete_msg != NULL, DCE_EOUT_OF_MEMORY);
+
+    /* Populating the msg structure with all the params */
+    codec_delete_msg->codec_handle = codec;
+    codec_delete_msg->codec_id = codec_id;
+
+    /* Marshall function arguments into the send buffer */
+    Fill_MmRpc_fxnCtx(&fxnCtx, DCE_RPC_CODEC_DELETE, 1, 0, NULL);
+    Fill_MmRpc_fxnCtx_Ptr_Params(fxnCtx.params, sizeof(dce_codec_delete), codec_delete_msg, NULL);
+
+    /* Invoke the Remote function through MmRpc */
+    eError = MmRpc_call(MmRpcHandle, &fxnCtx, &fxnRet);
+
+    _ASSERT(eError == DCE_EOK, DCE_EIPC_CALL_FAIL);
+
+EXIT:
+    memplugin_free(codec_delete_msg, TILER_1D_BUFFER);
+
+    return;
+}
+
+/*************** Deocder Codec Engine Functions ***********************/
+VIDDEC3_Handle VIDDEC3_create(Engine_Handle engine, String name,
+                              VIDDEC3_Params *params)
+{
+    VIDDEC3_Handle    codec;
+
+    DEBUG(">> engine=%p, name=%s, params=%p", engine, name, params);
+    codec = create(engine, name, params, OMAP_DCE_VIDDEC3);
+    DEBUG("<< codec=%p", codec);
+    return (codec);
+}
+
+XDAS_Int32 VIDDEC3_control(VIDDEC3_Handle codec, VIDDEC3_Cmd id,
+                           VIDDEC3_DynamicParams *dynParams, VIDDEC3_Status *status)
+{
+    XDAS_Int32    ret;
+
+    DEBUG(">> codec=%p, id=%d, dynParams=%p, status=%p",
+          codec, id, dynParams, status);
+    if( id == XDM_GETVERSION ) {
+        ret = get_version(codec, dynParams, status, OMAP_DCE_VIDDEC3);
+    } else {
+        ret = control(codec, id, dynParams, status, OMAP_DCE_VIDDEC3);
+    }
+    DEBUG("<< ret=%d", ret);
+    return (ret);
+}
+
+XDAS_Int32 VIDDEC3_process(VIDDEC3_Handle codec,
+                           XDM2_BufDesc *inBufs, XDM2_BufDesc *outBufs,
+                           VIDDEC3_InArgs *inArgs, VIDDEC3_OutArgs *outArgs)
+{
+    XDAS_Int32    ret;
+
+    DEBUG(">> codec=%p, inBufs=%p, outBufs=%p, inArgs=%p, outArgs=%p",
+          codec, inBufs, outBufs, inArgs, outArgs);
+    ret = process(codec, inBufs, outBufs, inArgs, outArgs, OMAP_DCE_VIDDEC3);
+    DEBUG("<< ret=%d", ret);
+    return (ret);
+}
+
+Void VIDDEC3_delete(VIDDEC3_Handle codec)
+{
+    DEBUG(">> codec=%p", codec);
+    delete(codec, OMAP_DCE_VIDDEC3);
+    DEBUG("<<");
+}
+
+/*************** Enocder Codec Engine Functions ***********************/
+VIDENC2_Handle VIDENC2_create(Engine_Handle engine, String name,
+                              VIDENC2_Params *params)
+{
+    VIDENC2_Handle    codec;
+
+    DEBUG(">> engine=%p, name=%s, params=%p", engine, name, params);
+    codec = create(engine, name, params, OMAP_DCE_VIDENC2);
+    DEBUG("<< codec=%p", codec);
+    return (codec);
+}
+
+XDAS_Int32 VIDENC2_control(VIDENC2_Handle codec, VIDENC2_Cmd id,
+                           VIDENC2_DynamicParams *dynParams, VIDENC2_Status *status)
+{
+    XDAS_Int32    ret;
+
+    DEBUG(">> codec=%p, id=%d, dynParams=%p, status=%p",
+          codec, id, dynParams, status);
+    ret = control(codec, id, dynParams, status, OMAP_DCE_VIDENC2);
+    DEBUG("<< ret=%d", ret);
+    return (ret);
+}
+
+XDAS_Int32 VIDENC2_process(VIDENC2_Handle codec,
+                           IVIDEO2_BufDesc *inBufs, XDM2_BufDesc *outBufs,
+                           VIDENC2_InArgs *inArgs, VIDENC2_OutArgs *outArgs)
+{
+    XDAS_Int32    ret;
+
+    DEBUG(">> codec=%p, inBufs=%p, outBufs=%p, inArgs=%p, outArgs=%p",
+          codec, inBufs, outBufs, inArgs, outArgs);
+    ret = process(codec, inBufs, outBufs, inArgs, outArgs, OMAP_DCE_VIDENC2);
+    DEBUG("<< ret=%d", ret);
+    return (ret);
+}
+
+Void VIDENC2_delete(VIDENC2_Handle codec)
+{
+    DEBUG(">> codec=%p", codec);
+    delete(codec, OMAP_DCE_VIDENC2);
+    DEBUG("<<");
+}
+
diff --git a/libdce.h b/libdce.h
new file mode 100644 (file)
index 0000000..c64456a
--- /dev/null
+++ b/libdce.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __LIBDCE_H__
+#define __LIBDCE_H__
+
+
+#include <ti/sdo/ce/Engine.h>
+#include <ti/sdo/ce/video3/viddec3.h>
+#include <ti/sdo/ce/video2/videnc2.h>
+
+
+/* DCE Error Types */
+typedef enum dce_error_status {
+    DCE_EOK = 0,
+    DCE_EXDM_FAIL = -1,
+    DCE_EOUT_OF_MEMORY = -2,
+    DCE_EXDM_UNSUPPORTED = -3,
+    DCE_EIPC_CREATE_FAIL = -4,
+    DCE_EIPC_CALL_FAIL = -5,
+    DCE_EINVALID_INPUT = -6
+} dce_error_status;
+
+
+/* other than the codec-engine API, you must use the following two functions
+ * to allocate the data structures passed to codec-engine APIs (other than the
+ * raw input/output buffers which should be passed as virtual addresses in
+ * TILER space
+ */
+void *dce_alloc(int sz);
+void dce_free(void *ptr);
+
+
+#if defined(BUILDOS_GLP)
+void dce_set_fd(int fd);
+int dce_get_fd();
+
+/* avoid some messy stuff in xdc/std.h which leads to gcc issues */
+#define xdc__ARGTOPTR
+#define xdc__ARGTOFXN
+
+struct omap_device   *dce_init(void);
+void dce_deinit(struct omap_device *dev);
+
+#define XDM_MEMTYPE_BO 10
+#define XDM_MEMTYPE_BO_OFFSET 11
+#endif /* BUILDOS_GLP */
+
+#endif /* __LIBDCE_H__ */
+
diff --git a/memplugin.h b/memplugin.h
new file mode 100644 (file)
index 0000000..f4dda8e
--- /dev/null
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __MEMPLUGIN_H__
+#define __MEMPLUGIN_H__
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#if defined(BUILDOS_QNX)
+#include <memmgr.h>
+#endif /* BUILDOS_QNX */
+
+#if defined(BUILDOS_GLP)
+#include <xf86drm.h>
+#endif /* BUILDOS_GLP */
+
+/* IPC Headers */
+#include <tilermem.h>
+#include <SharedMemoryAllocatorUsr.h>
+
+
+#define P2H(p) (&(((MemHeader *)(p))[-1]))
+#define H2P(h) ((void *)&(h)[1])
+
+typedef enum mem_type {
+    TILER_1D_BUFFER,
+    TILER8_2D_BUFFER,
+    TILER16_2D_BUFFER,
+    SHARED_MEMORY_BUFFER,
+    MEM_MAX
+} mem_type;
+
+
+/* DCE Error Types */
+typedef enum mem_error_status {
+    MEM_EOK = 0,
+    MEM_EINVALID_INPUT = -1,
+    MEM_EOUT_OF_TILER_MEMORY = -2,
+    MEM_EOUT_OF_SHMEMORY = -3,
+    MEM_EOUT_OF_SYSTEM_MEMORY = -4
+} mem_error_status;
+
+void *memplugin_alloc(int sz, int height, mem_type memory_type);
+
+void memplugin_free(void *ptr, mem_type memory_type);
+
+void *memplugin_share(void *ptr, mem_type memory_type);
+
+#endif /* __MEMPLUGIN_H__ */
+
diff --git a/memplugin_qnx.c b/memplugin_qnx.c
new file mode 100644 (file)
index 0000000..5555037
--- /dev/null
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "memplugin.h"
+#include "dce_priv.h"
+
+
+/* Would it be good to have MemHeaders for Tiler 2D buffers??     */
+/* Since the decision is to not support allocation of IO buffers, no  */
+/* need to worry about Tiler 2D Buffers. Hence below Memheader */
+/* can be used.                                                                         */
+/*
+typedef struct {
+    dce_memory_type memory_type;
+    union {
+        struct {
+            Uint32 size;
+            Uint32 ducati_addr;
+        } tilerHeader;
+        shm_buf shm_bufHeader;
+    }
+} MemHeader;
+else for Tiler 1D buffers */
+
+/* MemHeader is important because it is necessary to know the           */
+/* size of the parameter buffers on IPU for Cache operations               */
+/* The size can't be assumed as codec supports different inputs           */
+/* For ex: static params can be VIDDEC3_Params, IVIDDEC3_Params */
+/* or IH264DEC_Params                                                                   */
+typedef struct MemHeader {
+    int   size;
+    void *ptr;
+} MemHeader;
+
+
+/* For TILER 2D Buffers : sz       = width                              */
+/*                                : height = nonzero                           */
+/* For other memory_types : height = 0                               */
+void *memplugin_alloc(int sz, int height, mem_type memory_type)
+{
+    MemHeader          *h;
+    shm_buf            *handle;
+    MemAllocBlock       block;
+    int                 num_block;
+    mem_error_status    eError = MEM_EOK;
+
+    _ASSERT(sz != 0, MEM_EINVALID_INPUT);
+    _ASSERT((memory_type < MEM_MAX) && (memory_type >= TILER_1D_BUFFER), MEM_EINVALID_INPUT);
+
+    /* Tiler buffer Allocations : Only Tiler 1D used for Parameter Buffers and RPC Message buffers */
+    if( memory_type == TILER_1D_BUFFER || memory_type == TILER8_2D_BUFFER || memory_type == TILER16_2D_BUFFER ) {
+        num_block = 1;
+
+        if( memory_type == TILER_1D_BUFFER ) {
+            /* Allocate in tiler paged mode (1d) container */
+            block.pixelFormat = PIXEL_FMT_PAGE;
+            block.dim.len = sz + sizeof(MemHeader);
+#if 0 /* Data Tiler Buffers not to be allocated by DCE */
+        } else if( memory_type == TILER8_2D_BUFFER ) {
+            /* Allocate in tiler 8 bit mode (2d) container */
+            _ASSERT(height != 0, MEM_EINVALID_INPUT);
+            block.pixelFormat = PIXEL_FMT_8BIT;
+            block.dim.area.width  = sz;
+            block.dim.area.height = height;
+        } else {
+            /* Allocate in tiler 16 bit mode (2d) container */
+            _ASSERT(height != 0, MEM_EINVALID_INPUT);
+            block.pixelFormat = PIXEL_FMT_16BIT;
+            block.dim.area.width  = sz;
+            block.dim.area.height = height;
+#endif
+        }
+        block.stride = 0;
+
+        h = MemMgr_Alloc(&block, num_block);
+
+        _ASSERT(h != NULL, MEM_EOUT_OF_TILER_MEMORY);
+
+        h->size = sz;
+        memset(H2P(h), 0, sz);
+        return (H2P(h));
+    } else {
+
+        handle = malloc(sizeof(shm_buf));
+        _ASSERT(handle != NULL, MEM_EOUT_OF_SYSTEM_MEMORY);
+
+        /* Parameter Buffers : Allocate from Shared Memory considering MemHeader*/
+        SHM_alloc(sz + sizeof(MemHeader), handle);
+
+        h = (MemHeader *)handle->vir_addr;
+        _ASSERT_AND_EXECUTE(h != NULL, MEM_EOUT_OF_SHMEMORY, free(handle));
+
+        h->size = sz;
+        h->ptr = handle;
+        memset(H2P(h), 0, sz);
+        return (H2P(h));
+    }
+EXIT:
+    return (NULL);
+}
+
+/* memory_type is not added if MemHeader is used for Tiler Buffers */
+void memplugin_free(void *ptr, mem_type memory_type)
+{
+    shm_buf            *handle;
+    mem_error_status    eError = MEM_EOK;
+
+    _ASSERT(ptr != NULL, MEM_EINVALID_INPUT);
+    _ASSERT((memory_type < MEM_MAX) && (memory_type >= TILER_1D_BUFFER), MEM_EINVALID_INPUT);
+
+    if( memory_type == TILER_1D_BUFFER ) {
+        MemMgr_Free(P2H(ptr));
+    } else if( memory_type == SHARED_MEMORY_BUFFER ) {
+        handle = (P2H(ptr))->ptr;
+        SHM_release(handle);
+        free(handle);
+    } else {
+        ERROR("Tiler 2D Allocation/Free not implemented");
+    }
+EXIT:;
+}
+
+void *memplugin_share(void *ptr, mem_type memory_type)
+{
+    /* No Userspace Virtual pointers to DMA BUF Handles conversion required*/
+    /* Do nothing */
+    return (ptr);
+}
+
diff --git a/nto/Makefile b/nto/Makefile
new file mode 100644 (file)
index 0000000..5323e99
--- /dev/null
@@ -0,0 +1,2 @@
+LIST=CPU\r
+include recurse.mk\r
diff --git a/nto/README.txt b/nto/README.txt
new file mode 100644 (file)
index 0000000..bf43f03
--- /dev/null
@@ -0,0 +1 @@
+This Directory is QNX/Neutrino specific.
diff --git a/nto/arm/Makefile b/nto/arm/Makefile
new file mode 100644 (file)
index 0000000..a5e4d9b
--- /dev/null
@@ -0,0 +1,2 @@
+LIST=VARIANT\r
+include recurse.mk\r
diff --git a/nto/arm/a.le.v7/Makefile b/nto/arm/a.le.v7/Makefile
new file mode 100644 (file)
index 0000000..9d6821f
--- /dev/null
@@ -0,0 +1 @@
+include ../../../common.mk\r
diff --git a/nto/arm/so.le.v7/Makefile b/nto/arm/so.le.v7/Makefile
new file mode 100644 (file)
index 0000000..9d6821f
--- /dev/null
@@ -0,0 +1 @@
+include ../../../common.mk\r
diff --git a/nto/qconf-override.mk b/nto/qconf-override.mk
new file mode 100644 (file)
index 0000000..cf6c23c
--- /dev/null
@@ -0,0 +1,9 @@
+# If you wish to override the values of some of the macros defined in qconfig.mk
+# without modifying the contents of the file, set the QCONF_OVERRIDE environment
+# variable to this file (which will be included at the end of the qconfig.mk file)
+# and override the qconfig.mk macros here.
+
+# Override INSTALL_ROOT_nto macro
+INSTALL_ROOT ?= $(shell pwd)
+INSTALL_ROOT_nto := $(INSTALL_ROOT)
+USE_INSTALL_ROOT = 1
diff --git a/test_qnx/Makefile b/test_qnx/Makefile
new file mode 100644 (file)
index 0000000..5323e99
--- /dev/null
@@ -0,0 +1,2 @@
+LIST=CPU\r
+include recurse.mk\r
diff --git a/test_qnx/arm/Makefile b/test_qnx/arm/Makefile
new file mode 100644 (file)
index 0000000..6a18617
--- /dev/null
@@ -0,0 +1,8 @@
+LIST=VARIANT\r
+ifndef QRECURSE\r
+QRECURSE=recurse.mk\r
+ifdef QCONFIG\r
+QRDIR=$(dir $(QCONFIG))\r
+endif\r
+endif\r
+include $(QRDIR)$(QRECURSE)\r
diff --git a/test_qnx/arm/le.v7/Makefile b/test_qnx/arm/le.v7/Makefile
new file mode 100644 (file)
index 0000000..cc39927
--- /dev/null
@@ -0,0 +1 @@
+include ../../common.mk\r
diff --git a/test_qnx/common.mk b/test_qnx/common.mk
new file mode 100644 (file)
index 0000000..be901c0
--- /dev/null
@@ -0,0 +1,50 @@
+###################### QNX DCE Test App Build Config #######################\r
+\r
+#### Include qconfig.mk\r
+ifndef QCONFIG\r
+QCONFIG=qconfig.mk\r
+endif\r
+include $(QCONFIG)\r
+\r
+define PINFO\r
+PINFO DESCRIPTION=DCE Test\r
+endef\r
+\r
+NAME = dce_test\r
+INSTALLDIR = bin\r
+\r
+# Different tool versions can easily be programmed by defining below variables\r
+# in your environment.\r
+CEVERSION      ?= codec_engine_3_23_00_07\r
+FCVERSION      ?= framework_components_3_23_03_17\r
+XDAISVERSION   ?= xdais_7_23_00_06\r
+XDCVERSION     ?= xdctools_3_25_00_48\r
+IPCHEADERS     ?= $(INSTALL_ROOT_nto)\r
+IVAHDCODECS ?= ipumm/extrel/ti/ivahd_codecs\r
+\r
+# Generate the full package paths for tools\r
+CEPROD         = $(TIVIDEOTOOLSROOT)/$(CEVERSION)\r
+FCPROD         = $(TIVIDEOTOOLSROOT)/$(FCVERSION)\r
+XDAISPROD      = $(TITOOLSROOT)/$(XDAISVERSION)\r
+XDCPROD            = $(TITOOLSROOT)/$(XDCVERSION)\r
+\r
+#Add extra include path\r
+EXTRA_INCVPATH += $(CEPROD)/packages\r
+EXTRA_INCVPATH += $(FCPROD)/packages\r
+EXTRA_INCVPATH += $(XDAISPROD)/packages\r
+EXTRA_INCVPATH += $(XDCPROD)/packages\r
+EXTRA_INCVPATH += $(IVAHDCODECS)/packages\r
+EXTRA_INCVPATH += $(PROJECT_ROOT)/../\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include/memmgr\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include/ti/syslink\r
+EXTRA_INCVPATH += $(IPCHEADERS)/usr/include\r
+\r
+CCOPTS+=-g -O0 -Dxdc_target_types__=qnx/targets/arm/std.h\r
+\r
+EXTRA_LIBVPATH += $(PROJECT_ROOT)/../nto/arm/so.le.v7 \\r
+                  $(INSTALL_ROOT_nto)/armle-v7/usr/lib\r
+\r
+LDOPTS+= -ldce -lmemmgr -ltilerusr -lsyslink_client -lsharedmemallocator\r
+\r
+include $(MKFILES_ROOT)/qtargets.mk\r
+\r
diff --git a/test_qnx/dce_test.c b/test_qnx/dce_test.c
new file mode 100644 (file)
index 0000000..805b240
--- /dev/null
@@ -0,0 +1,1437 @@
+/*
+ * Copyright (c) 2013, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <xdc/std.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <time.h>
+#include <sys/mman.h>
+
+#include <tilermem.h>
+#include <memmgr.h>
+#include <xdc/std.h>
+#include <ti/sdo/ce/Engine.h>
+#include <ti/sdo/ce/video3/viddec3.h>
+#include <ti/sdo/codecs/h264vdec/ih264vdec.h>
+#include <ti/sdo/codecs/mpeg4vdec/impeg4vdec.h>
+#include <ti/sdo/codecs/vc1vdec/ivc1vdec.h>
+#include <ti/sdo/codecs/jpegvdec/ijpegvdec.h>
+#ifdef ENABLE_MPEG2
+#include <ti/sdo/codecs/mpeg2vdec/impeg2vdec.h>
+#endif
+#include "ti/shmemallocator/SharedMemoryAllocatorUsr.h"
+#include "libdce.h"
+
+#define OMAP5
+
+#define PRINT_DEBUG
+#define ERROR(FMT, ...)  printf("%s:%d:\t%s\terror: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+// enable below to print debug information
+#ifdef PRINT_DEBUG
+#define DEBUG(FMT, ...)  printf("%s:%d:\t%s\tdebug: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#else
+#define DEBUG(FMT, ...)
+#endif
+#define INFO(FMT, ...)  printf("%s:%d:\t%s\tinfo: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
+#define MIN(a, b)        (((a) < (b)) ? (a) : (b))
+
+/* align x to next highest multiple of 2^n */
+#define ALIGN2(x, n)   (((x) + ((1 << (n)) - 1)) & ~((1 << (n)) - 1))
+
+// Profile the init and decode calls
+//#define PROFILE_TIME
+
+enum {
+    IVAHD_AVC1_DECODE,
+    IVAHD_H264_DECODE,
+    IVAHD_MP4V_DECODE,
+    IVAHD_S263_DECODE,
+    IVAHD_VC1AP_DECODE,
+    IVAHD_VC1SMP_DECODE,
+    IVAHD_VP6V_DECODE,
+    IVAHD_MP2V_DECODE,
+    IVAHD_JPEGV_DECODE
+};
+
+/*
+ * A very simple VIDDEC3 client which will decode h264 frames (one per file),
+ * and write out raw (unstrided) nv12 frames (one per file).
+ */
+
+int                      width, height, padded_width, padded_height, num_buffers, tiler;
+Engine_Handle            engine    = NULL;
+VIDDEC3_Handle           codec     = NULL;
+VIDDEC3_Params          *params    = NULL;
+VIDDEC3_DynamicParams   *dynParams = NULL;
+VIDDEC3_Status          *status    = NULL;
+XDM2_BufDesc            *inBufs    = NULL;
+XDM2_BufDesc            *outBufs   = NULL;
+VIDDEC3_InArgs          *inArgs    = NULL;
+VIDDEC3_OutArgs         *outArgs   = NULL;
+
+IH264VDEC_Params          *h264_params    = NULL;
+IH264VDEC_DynamicParams   *h264_dynParams = NULL;
+IH264VDEC_Status          *h264_status    = NULL;
+
+IMPEG4VDEC_Params          *mpeg4_params       = NULL;
+IMPEG4VDEC_DynamicParams   *mpeg4_dynParams    = NULL;
+IMPEG4VDEC_Status          *mpeg4_status       = NULL;
+
+IVC1VDEC_Params          *vc1_params     = NULL;
+IVC1VDEC_DynamicParams   *vc1_dynParams  = NULL;
+IVC1VDEC_Status          *vc1_status     = NULL;
+
+IJPEGVDEC_Params          *mjpeg_params       = NULL;
+IJPEGVDEC_DynamicParams   *mjpeg_dynParams    = NULL;
+IJPEGVDEC_Status          *mjpeg_status       = NULL;
+#ifdef ENABLE_MPEG2
+IMPEG2VDEC_Params          *mpeg2_params       = NULL;
+IMPEG2VDEC_DynamicParams   *mpeg2_dynParams    = NULL;
+IMPEG2VDEC_Status          *mpeg2_status       = NULL;
+#endif
+unsigned int    frameSize[64000]; /* Buffer for keeping frame sizes */
+static int      input_offset = 0;
+
+/*! Padding for width as per  Codec Requirement */
+#define PADX_H264   32
+#define PADX_MPEG4  32
+#define PADX_VC1    32
+/*! Padding for height as per Codec Requirement */
+#define PADY_H264   24
+#define PADY_MPEG4  32
+#define PADY_VC1    40
+
+static void *tiler_alloc(int width, int height)
+{
+    int              dimensions;
+    void            *bufPtr = NULL;
+    MemAllocBlock    block;
+    MemAllocBlock    blocks[2];
+
+    memset(&block, 0, sizeof(MemAllocBlock));
+    memset(blocks, 0, sizeof(MemAllocBlock) * 2);
+
+    if( !height ) {
+        DEBUG("tiler alloc 1D allocation width=%d", width);
+        /* 1d allocation: */
+        dimensions = 1;
+
+        block.pixelFormat = PIXEL_FMT_PAGE;
+        block.dim.len = width;
+        block.stride = 0;
+
+        bufPtr = MemMgr_Alloc(&block, dimensions);
+    } else {
+        DEBUG("tiler alloc 2D allocation width=%d height=%d", width, height);
+        /* 2d allocation: */
+        dimensions = 2;
+        blocks[0].pixelFormat = PIXEL_FMT_8BIT;
+        blocks[0].dim.area.width  = width;
+        blocks[0].dim.area.height = height;
+        blocks[0].stride = 0;
+
+        blocks[1].pixelFormat = PIXEL_FMT_16BIT;
+        blocks[1].dim.area.width  = width >> 1;
+        blocks[1].dim.area.height = height >> 1;
+        blocks[1].stride = 0;
+
+        bufPtr = MemMgr_Alloc(blocks, dimensions);
+    }
+    DEBUG("tiler alloc return bufPtr %p", bufPtr);
+
+    return (bufPtr);
+}
+
+/* ************************************************************************* */
+/* utilities to allocate/manage 2d output buffers */
+
+typedef struct OutputBuffer OutputBuffer;
+
+struct OutputBuffer {
+    char         *buf; /* virtual address for local access, 4kb stride */
+    uint32_t      y, uv; /* virtual address of Y and UV for remote access */
+    OutputBuffer *next;      /* next free buffer */
+    bool          tiler;
+    uint32_t      len;
+    shm_buf       shmBuf;
+};
+
+static XDAS_Int16
+get_mem_type (uint32_t paddr)
+{
+    if((0x60000000 <= paddr) && (paddr < 0x68000000)) {
+        return (XDM_MEMTYPE_TILED8);
+    }
+    if((0x68000000 <= paddr) && (paddr < 0x70000000)) {
+        return (XDM_MEMTYPE_TILED16);
+    }
+    if((0x70000000 <= paddr) && (paddr < 0x78000000)) {
+        return (XDM_MEMTYPE_TILED32);
+    }
+    if((0x78000000 <= paddr) && (paddr < 0x80000000)) {
+        return (XDM_MEMTYPE_RAW);
+    }
+    return (-1);
+}
+
+/* list of free buffers, not locked by codec! */
+static OutputBuffer   *head = NULL;
+
+#if 0
+/*! @brief Start address of DDR region for 1GB RAM */
+#define DDR_1G_ADDRESS_START           0x80000000
+/*! @brief End address of DDR region for 1GB RAM */
+#define DDR_1G_ADDRESS_END             0xBFFFFFFF
+#define DDR_1G_DUCATI_OFFSET           0x40000000
+
+/*! @brief Start address of DDR region for 2GB RAM */
+#define DDR_2G_ADDRESS_START           0xC0000000
+/*! @brief End address of DDR region for 2GB RAM */
+#define DDR_2G_ADDRESS_END             0xFFFFFFFF
+#define DDR_2G_DUCATI_OFFSET           0xA0000000
+
+static Int
+SysLinkMemUtils_translateAddr (UInt32 physAddr)
+{
+    Int    ret = 0;
+
+    if( physAddr >= DDR_1G_ADDRESS_START && physAddr <= DDR_1G_ADDRESS_END ) {
+        ret = physAddr + DDR_1G_DUCATI_OFFSET;
+    } else if( physAddr >= DDR_2G_ADDRESS_START && physAddr <= DDR_2G_ADDRESS_END ) {
+        ret = physAddr - DDR_2G_DUCATI_OFFSET;
+    }
+
+    return (ret);
+}
+
+#endif
+
+int output_allocate(XDM2_BufDesc *outBufs, int cnt,
+                    int width, int height, int stride)
+{
+    int    tw, th;
+
+    outBufs->numBufs = 2;
+
+    if( stride != 4096 ) {
+        /* non-2d allocation! */
+        int    size_y = stride * height;
+        int    size_uv = stride * height / 2;
+        tw = size_y + size_uv;
+        th = 0;
+        outBufs->descs[0].memType = XDM_MEMTYPE_TILEDPAGE;
+        outBufs->descs[0].bufSize.bytes = size_y;
+        outBufs->descs[1].memType = XDM_MEMTYPE_TILEDPAGE;
+        outBufs->descs[1].bufSize.bytes = size_uv;
+    } else {
+        tw = width;
+        th = height;
+        outBufs->descs[0].memType = XDM_MEMTYPE_TILED8;
+        outBufs->descs[0].bufSize.tileMem.width  = width;
+        outBufs->descs[0].bufSize.tileMem.height = height;
+        outBufs->descs[1].memType = XDM_MEMTYPE_TILED16;
+        outBufs->descs[1].bufSize.tileMem.width  = width; /* UV interleaved width is same a Y */
+        outBufs->descs[1].bufSize.tileMem.height = height / 2;
+    }
+
+    while( cnt ) {
+        OutputBuffer   *buf = calloc(sizeof(OutputBuffer), 1);
+
+        DEBUG(" ----------------- create TILER buf 0x%x --------------------", (unsigned int)buf);
+
+        buf->buf = tiler_alloc(tw, th);
+        if( buf->buf ) {
+            buf->y   = (uint32_t) buf->buf;
+            buf->uv  = (uint32_t)(buf->buf + (height * stride));
+
+            DEBUG("cnt=%d buf=%p, y=%08x, uv=%08x", cnt, buf, buf->y, buf->uv);
+
+            buf->tiler = TRUE;
+            buf->next = head;
+            head = buf;
+        } else {
+            ERROR(" ---------------- tiler_alloc failed --------------------");
+            free(buf);
+            return (-EAGAIN);
+        }
+        cnt--;
+    }
+
+    return (0);
+}
+
+int output_allocate_nonTiler(XDM2_BufDesc *outBufs, int cnt,
+                             int width, int height, int stride)
+{
+    int           tw;
+    XDAS_Int16    y_type, uv_type;
+
+    outBufs->numBufs = 2;
+
+    while( cnt ) {
+        OutputBuffer   *buf = calloc(sizeof(OutputBuffer), 1);
+
+        DEBUG(" ----------------- create nonTILER buf 0x%x --------------------", (unsigned int)buf);
+        int    size_y = width * height;
+        int    size_uv = width * height * 1 / 2;
+        tw = size_y + size_uv;
+
+        // Allocation through mmap
+        uint64_t   *vaddr;
+        int32_t     ret, len = 0;
+        int64_t     paddr = 0;
+        uint32_t    uv_addr;
+
+        //vaddr = mmap64(0, tw, PROT_NOCACHE | PROT_READ | PROT_WRITE, MAP_ANON | MAP_PHYS | MAP_SHARED, NOFD, 0);
+        ret = SHM_alloc(tw, &buf->shmBuf);
+        //if (vaddr == MAP_FAILED) {
+        if( ret < 0 ) {
+            //ERROR("Failed to do memory mapping\n");
+            ERROR("Failed to alloc shmem buffer\n");
+            free(buf);
+            return (-ENOMEM);
+        }
+        vaddr = (uint64_t *)buf->shmBuf.vir_addr;
+
+        // Make sure the memory is contiguous
+        ret = mem_offset64(vaddr, NOFD, (size_t) tw, &paddr, (size_t *) &len);
+        if( ret ) {
+            ERROR("Failed to check memory contiguous ret %d errno %d\n", ret, errno);
+            //munmap(vaddr, tw);
+            SHM_release(&buf->shmBuf);
+            free(buf);
+            return (-ENOMEM);
+        } else if( len != (tw)) {
+            ERROR("Failed to check len %d != %d\n", len, tw);
+            //munmap(vaddr, tw);
+            SHM_release(&buf->shmBuf);
+            free(buf);
+            return (-ENOMEM);
+        }
+
+        buf->buf = (char *) vaddr;
+        buf->y = (uint32_t)vaddr;
+        uv_addr = (uint32_t) vaddr + (width * height);
+        buf->uv = uv_addr;
+
+        DEBUG("cnt=%d nonTILER buf=%p, y=%08x, uv=%08x paddr=%08x", cnt, buf, buf->y, buf->uv, (unsigned int) paddr);
+
+        y_type = get_mem_type(buf->y);
+        uv_type = get_mem_type(buf->uv);
+
+        if((y_type < 0) || (uv_type < 0)) {
+            DEBUG("non TILER buffer address translation buf->y %x buf->uv %x", buf->y, buf->uv);
+            //buf->y = SysLinkMemUtils_translateAddr(buf->y);
+            //buf->uv = SysLinkMemUtils_translateAddr(buf->uv);
+            y_type = XDM_MEMTYPE_RAW;
+            uv_type = XDM_MEMTYPE_RAW;
+            DEBUG("buf->y %x buf->uv %x", buf->y, buf->uv);
+            if( !buf->y || !buf->uv ) {
+                //munmap(vaddr, tw);
+                SHM_release(&buf->shmBuf);
+                free(buf);
+                return (-ENOMEM);
+            }
+        }
+
+        buf->next = head;
+        buf->tiler = FALSE;
+        buf->len = tw;
+        head = buf;
+
+        cnt--;
+    }
+
+    if((y_type == XDM_MEMTYPE_RAW) && (uv_type == XDM_MEMTYPE_RAW)) {
+        outBufs->descs[0].memType = y_type;
+        outBufs->descs[0].bufSize.bytes = width * height;
+        outBufs->descs[1].memType = uv_type;
+        outBufs->descs[1].bufSize.bytes = width * height * 1 / 2;
+    }
+
+    return (0);
+}
+
+void output_free(void)
+{
+    OutputBuffer   *buf = head;
+
+    while((buf=head)) {
+        if( buf->tiler ) {
+            MemMgr_Free(buf->buf);
+        } else {
+            //munmap(buf->buf, buf->len);
+            SHM_release(&buf->shmBuf);
+        }
+        head = buf->next;
+        free(buf);
+    }
+}
+
+OutputBuffer *output_get(void)
+{
+    OutputBuffer   *buf = head;
+
+    if( buf ) {
+        head = buf->next;
+    }
+    DEBUG("output_get: %p", buf);
+    return (buf);
+}
+
+void output_release(OutputBuffer *buf)
+{
+    DEBUG("output_release: %p", buf);
+    buf->next = head;
+    head = buf;
+}
+
+/* ************************************************************************* */
+
+/* get file path.. return path is only valid until next time this is called */
+static const char *get_path(const char *pattern, int cnt)
+{
+    static int     len = 0;
+    static char   *path = NULL;
+
+    /* It would be better to not assume the pattern doesn't expand to
+     * less than 10 chars it's original length..
+     */
+    if((strlen(pattern) + 10) > len ) {
+        len  = strlen(pattern) + 10;
+        path = realloc(path, len);
+    }
+
+    snprintf(path, len - 1, pattern, cnt);
+
+    return (path);
+}
+
+/* helper to read one frame of input */
+int read_input(const char *pattern, int cnt, char *input)
+{
+    int           sz = 0, n = 0;
+    const char   *path = get_path(pattern, cnt);
+    int           fd = open(path, O_RDONLY);
+
+    //DEBUG("Open file fd %d errno %d", fd, errno);
+    /* if we can't find the file, then at the end of stream */
+    if( fd < 0 ) {
+        DEBUG("open input file failed");
+        return (0);
+    }
+
+    if( frameSize[cnt] && (frameSize[cnt] != -1)) {
+        lseek(fd, input_offset, SEEK_SET);
+        n = read(fd, input, frameSize[cnt]);
+        //DEBUG("reading input frameSize[%d] = n =%d", cnt, n);
+        sz += n;
+        input_offset += n;
+    } else if((frameSize[cnt] == -1)) {
+        // This happens to indicate flush command
+        DEBUG("Flush requested from file size -1,frameSize[%d] is %d", cnt, frameSize[cnt]);
+        sz = -1;
+    }
+
+    close(fd);
+
+    DEBUG("sz=%d", sz);
+    return (sz);
+}
+
+/* helper to write one frame of output */
+int write_output(const char *pattern, int cnt, char *y, char *uv, int stride)
+{
+    int           sz = 0, n, i;
+    const char   *path = get_path(pattern, cnt);
+    int           fd = open(path, O_WRONLY | O_CREAT | O_APPEND, 0644);
+
+    if( fd < 0 ) {
+        ERROR("could open output file: %s (%d)", path, errno);
+        return (0);
+    }
+
+    for( i = 0; i < height; i++ ) {
+        char   *p = y;
+        int     len = width;
+
+        while( len && ((n = write(fd, p, len)) > 0)) {
+            sz  += n;
+            p   += n;
+            len -= n;
+        }
+
+        if( n < 0 ) {
+            ERROR("couldn't write to output file: (%d)", errno);
+            break;
+        }
+        y += stride;
+    }
+
+    if( n >= 0 ) {
+        for( i = 0; i < height / 2; i++ ) {
+            char   *p = uv;
+            int     len = width;
+
+            while( len && ((n = write(fd, p, len)) > 0)) {
+                sz  += n;
+                p   += n;
+                len -= n;
+            }
+
+            if( n < 0 ) {
+                ERROR("couldn't write to output file: (%d)", errno);
+                break;
+            }
+            uv += stride;
+        }
+    }
+
+    close(fd);
+
+    return (sz);
+}
+
+#ifdef PROFILE_TIME
+/* for timing in microsecond */
+uint64_t mark_microsecond(uint64_t *last)
+{
+#if 0
+    struct timespec    time;
+    uint64_t           t1 = 0;
+
+    clock_gettime(CLOCK_REALTIME, &time);
+    t1 = timespec2nsec(&time);
+    t1 = t1 / 1000;
+#else
+    uint64_t    t1 = 0;
+
+    t1 = ClockCycles();
+    t1 = t1 * 1000000000 / SYSPAGE_ENTRY(qtime)->cycles_per_sec;
+    t1 = t1 / 1000;
+#endif
+    if( last ) {
+        return (t1 - *last);
+    }
+    return (t1);
+}
+
+#endif
+//#define DUMPINPUTDATA
+
+#ifdef DUMPINPUTDATA
+FILE   *inputDump;
+#endif
+
+#define VERSION_SIZE 128
+static char    version_buffer[VERSION_SIZE];
+
+/* decoder body */
+int main(int argc, char * *argv)
+{
+    Engine_Error     ec;
+    XDAS_Int32       err;
+    char            *input = NULL;
+    char            *in_pattern, *out_pattern, *frameData;
+    int              in_cnt = 0, out_cnt = 0;
+    int              oned, stride;
+    unsigned int     frameCount = 0;
+    FILE            *frameFile;
+    unsigned char    frameinput[10] = { "\0" };
+    int              eof = 0;
+    int              ivahd_decode_type;
+    char             vid_codec[10];
+    char             tilerbuffer[10];
+    unsigned int     codec_switch = 0;
+    unsigned int     vc1_flush = 0;
+    Bool             outBufsInUse = FALSE;
+
+#ifdef PROFILE_TIME
+    uint64_t    init_start_time = 0;
+    uint64_t    codec_process_time = 0;
+    uint64_t    total_init_time = 0;
+    uint64_t    output_alloc_time = 0;
+#endif
+
+#if 0
+    int    loop = 0;
+
+    while( loop == 0 ) {
+        loop = 0;
+    }
+
+#endif
+
+    if((argc >= 2) && !strcmp(argv[1], "-1")) {
+        oned = TRUE;
+        argc--;
+        argv++;
+    } else {
+        oned = FALSE;
+    }
+
+    if( argc != 8 ) {
+        printf("usage:   %s width height framefile inpattern outpattern codec tilerbuffer\n", argv[0]);
+        printf("example: %s 320 240 frame.txt in.h264 out.yuv h264 tiler\n", argv[0]);
+        printf("example: %s 640 480 frame.txt in.m4v out.yuv mpeg4 nontiler\n", argv[0]);
+        printf("example: %s 720 480 frame.txt in.vc1 out.yuv vc1ap tiler\n", argv[0]);
+        printf("example: %s 320 240 frame.txt in.vc1 out.yuv vc1smp nontiler\n", argv[0]);
+        printf("example: %s 1280 720 frame.txt in.bin out.yuv mjpeg tiler\n", argv[0]);
+        printf("example: %s 1920 1088 frame.txt in.bin out.yuv mpeg2 nontiler\n", argv[0]);
+        printf("Currently supported codecs: h264, mpeg4, vc1ap, vc1smp, mjpeg, mpeg2\n");
+        return (1);
+    }
+
+    /* error checking? */
+    width  = atoi(argv[1]);
+    height = atoi(argv[2]);
+    frameData   = argv[3];
+    in_pattern  = argv[4];
+    out_pattern = argv[5];
+    strcpy(vid_codec, argv[6]);
+    strcpy(tilerbuffer, argv[7]);
+
+    printf("Selected codec: %s\n", vid_codec);
+    printf("Selected buffer: %s\n", tilerbuffer);
+
+    enum {
+        DCE_TEST_H264   = 1,
+        DCE_TEST_MPEG4  = 2,
+        DCE_TEST_VC1SMP = 3,
+        DCE_TEST_VC1AP  = 4,
+        DCE_TEST_MJPEG  = 5,
+        DCE_TEST_MPEG2  = 6
+    };
+
+    if((!(strcmp(vid_codec, "h264")))) {
+        ivahd_decode_type = IVAHD_H264_DECODE;
+        codec_switch = DCE_TEST_H264;
+
+    } else if((!(strcmp(vid_codec, "mpeg4")))) {
+        ivahd_decode_type = IVAHD_MP4V_DECODE;
+        codec_switch = DCE_TEST_MPEG4;
+
+    } else if((!(strcmp(vid_codec, "vc1smp")))) {
+        ivahd_decode_type = IVAHD_VC1SMP_DECODE;
+        codec_switch = DCE_TEST_VC1SMP;
+        vc1_flush = 1;
+
+    } else if((!(strcmp(vid_codec, "vc1ap")))) {
+        ivahd_decode_type = IVAHD_VC1AP_DECODE;
+        codec_switch = DCE_TEST_VC1AP;
+        vc1_flush = 1;
+
+    } else if((!(strcmp(vid_codec, "mjpeg")))) {
+        ivahd_decode_type = IVAHD_JPEGV_DECODE;
+        codec_switch = DCE_TEST_MJPEG;
+
+    } else if((!(strcmp(vid_codec, "mpeg2")))) {
+        ivahd_decode_type = IVAHD_MP2V_DECODE;
+        codec_switch = DCE_TEST_MPEG2;
+
+    } else {
+        printf("No valid codec entry. Please use: h264, mpeg4, vc1ap, vc1smp, mjpeg or mpeg2\n");
+        return (1);
+    }
+
+    DEBUG("Storing frame size data");
+    frameFile = fopen(frameData, "rb");
+    DEBUG("frameFile open %p errno %d", frameFile, errno);
+    if( frameFile == NULL ) {
+        DEBUG("Opening framesize file FAILED");
+    }
+
+    /* Read the frame Size from the frame size file */
+    while( NULL != fgets((char *)frameinput, 10, frameFile)) {
+        frameSize[frameCount] = atoi((char *)frameinput);
+        //DEBUG("frameSize[%d] = %d \n", frameCount, frameSize[frameCount]);
+
+        if( frameCount > 64000 ) {
+            DEBUG("Num Frames %d exceeded MAX limit %d \n", frameCount, 64000);
+            goto out;
+        }
+        frameCount++;
+    }
+
+    DEBUG("Num Frames is %d width=%d, height=%d", frameCount, width, height);
+
+    /* calculate output buffer parameters: */
+    width  = ALIGN2(width, 4);         /* round up to MB */
+    height = ALIGN2(height, 4);        /* round up to MB */
+
+    switch( codec_switch ) {
+        case DCE_TEST_H264 :
+            padded_width  = ALIGN2(width + (2 * PADX_H264), 7);
+            padded_height = height + 4 * PADY_H264;
+            // Some clips don't have enough buffers based on N+3 formula
+            // Need sps->num_ref_frames data to match filter precisely
+            //num_buffers   = 2 * (MIN(16, 32768 / ((width / 16) * (height / 16)))) + 1;
+            num_buffers   = (MIN(16, 32768 / ((width / 16) * (height / 16)))) + 3;
+            break;
+        case DCE_TEST_MPEG4 :
+            padded_width = ALIGN2(width + PADX_MPEG4, 7);
+            padded_height = height + PADY_MPEG4;
+            num_buffers = 8;
+            break;
+        case DCE_TEST_VC1SMP :
+        case DCE_TEST_VC1AP :
+            padded_width = ALIGN2(width + (2 * PADX_VC1), 7);
+            padded_height = (ALIGN2(height / 2, 4) * 2) + 4 * PADY_VC1;
+            num_buffers = 5;
+            break;
+        case DCE_TEST_MJPEG :
+            padded_width = ALIGN2(width, 4);
+            padded_height = ALIGN2(height, 4);
+            num_buffers = 5;
+            break;
+        case DCE_TEST_MPEG2 :
+            padded_width = ALIGN2(width, 7);
+            padded_height = height;
+            num_buffers = 4;
+            break;
+    }
+
+    if( oned ) {
+        stride = padded_width;
+    } else {
+        stride = 4096;
+    }
+
+    DEBUG("padded_width=%d, padded_height=%d, stride=%d, num_buffers=%d",
+          padded_width, padded_height, stride, num_buffers);
+#ifdef PROFILE_TIME
+    init_start_time = mark_microsecond(NULL);
+#endif
+    engine = Engine_open("ivahd_vidsvr", NULL, &ec);
+
+    if( !engine ) {
+        ERROR("fail");
+        goto out;
+    }
+
+    DEBUG("Engine_open successful engine=%p", engine);
+
+    switch( codec_switch ) {
+        case DCE_TEST_H264 :
+            params = dce_alloc(sizeof(IH264VDEC_Params));
+            if( !params ) {
+                ERROR("dce_alloc fail");
+                goto out;
+            }
+            params->size = sizeof(IH264VDEC_Params);
+            params->maxBitRate      = 10000000;
+            params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_AUTO;
+            params->numOutputDataUnits  = 0;
+            params->maxWidth            = width;
+            break;
+        case DCE_TEST_MPEG4 :
+            params = dce_alloc(sizeof(IMPEG4VDEC_Params));
+            if( !params ) {
+                ERROR("dce_alloc fail");
+                goto out;
+            }
+            params->size = sizeof(IMPEG4VDEC_Params);
+            params->maxBitRate      = 10000000;
+            params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
+            params->numOutputDataUnits  = 0;
+            params->maxWidth            = width;
+            break;
+        case DCE_TEST_VC1SMP :
+        case DCE_TEST_VC1AP :
+            params = dce_alloc(sizeof(IVC1VDEC_Params));
+            if( !params ) {
+                ERROR("dce_alloc fail");
+                goto out;
+            }
+            params->size = sizeof(IVC1VDEC_Params);
+            params->maxBitRate      = 45000000;
+            params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
+            params->numOutputDataUnits  = 0;
+            params->maxWidth            = width;
+            break;
+        case DCE_TEST_MJPEG :
+            params = dce_alloc(sizeof(IJPEGVDEC_Params));
+            if( !params ) {
+                ERROR("dce_alloc fail");
+                goto out;
+            }
+            params->size = sizeof(IJPEGVDEC_Params);
+            params->maxBitRate      = 10000000;
+            params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
+            params->numOutputDataUnits  = 1;
+            params->maxWidth            = width;
+            break;
+#ifdef ENABLE_MPEG2
+        case DCE_TEST_MPEG2 :
+            params = dce_alloc(sizeof(IMPEG2VDEC_Params));
+            if( !params ) {
+                ERROR("dce_alloc fail");
+                goto out;
+            }
+            params->size = sizeof(IMPEG2VDEC_Params);
+            params->maxBitRate      = 10000000;
+            params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
+            params->numOutputDataUnits  = 0;
+            params->maxWidth            = padded_width;
+            break;
+#endif
+    }
+
+    params->maxHeight           = height;
+    params->maxFrameRate        = 30000;
+    params->dataEndianness      = XDM_BYTE;
+    params->forceChromaFormat   = XDM_YUV_420SP;
+    params->operatingMode       = IVIDEO_DECODE_ONLY;
+    //params->displayDelay        = IVIDDEC3_DECODE_ORDER;
+    params->displayBufsMode     = IVIDDEC3_DISPLAYBUFS_EMBEDDED;
+    params->inputDataMode       = IVIDEO_ENTIREFRAME;
+    params->metadataType[0]     = IVIDEO_METADATAPLANE_NONE;
+    params->metadataType[1]     = IVIDEO_METADATAPLANE_NONE;
+    params->metadataType[2]     = IVIDEO_METADATAPLANE_NONE;
+    params->outputDataMode      = IVIDEO_ENTIREFRAME;
+    params->numInputDataUnits   = 0;
+    params->errorInfoMode       = IVIDEO_ERRORINFO_OFF;
+
+    DEBUG("dce_alloc VIDDEC3_Params successful params=%p", params);
+
+    switch( codec_switch ) {
+        case DCE_TEST_H264 :
+            h264_params = (IH264VDEC_Params *) params;
+            h264_params->dpbSizeInFrames = IH264VDEC_DPB_NUMFRAMES_AUTO;
+            h264_params->pConstantMemory = 0;
+            h264_params->presetLevelIdc = IH264VDEC_LEVEL41;
+            h264_params->errConcealmentMode = IH264VDEC_APPLY_CONCEALMENT;
+            h264_params->temporalDirModePred = TRUE;
+            h264_params->detectCabacAlignErr = IH264VDEC_DISABLE_CABACALIGNERR_DETECTION;
+
+            DEBUG("dce_alloc VIDDEC3_Params successful h264_params=%p", h264_params);
+
+            err = msync((Ptr)h264_params, sizeof(IH264VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
+
+            codec = VIDDEC3_create(engine, "ivahd_h264dec", (VIDDEC3_Params *)h264_params);
+            break;
+
+        case DCE_TEST_MPEG4 :
+            mpeg4_params = (IMPEG4VDEC_Params *) params;
+            mpeg4_params->outloopDeBlocking = TRUE;
+            mpeg4_params->sorensonSparkStream = FALSE;
+            mpeg4_params->errorConcealmentEnable = FALSE;
+            mpeg4_params->debugTraceLevel = 0;
+            mpeg4_params->lastNFramesToLog = 0;
+            mpeg4_params->paddingMode = IMPEG4VDEC_DEFAULT_MODE_PADDING;
+
+            DEBUG("dce_alloc VIDDEC3_Params successful mpeg4_params=%p", mpeg4_params);
+
+            err = msync((Ptr)mpeg4_params, sizeof(IMPEG4VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
+#ifdef OMAP5
+            codec = VIDDEC3_create(engine, "ivahd_mpeg4dec", (VIDDEC3_Params *)mpeg4_params);
+#else
+            codec = VIDDEC3_create(engine, "ivahd_mpeg4vdec", (VIDDEC3_Params *)mpeg4_params);
+#endif
+            break;
+
+        case DCE_TEST_VC1SMP :
+        case DCE_TEST_VC1AP :
+            vc1_params = (IVC1VDEC_Params *) params;
+
+            DEBUG("dce_alloc VIDDEC3_Params successful vc1_params=%p", vc1_params);
+
+            err = msync((Ptr)vc1_params, sizeof(IVC1VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
+
+            codec = VIDDEC3_create(engine, "ivahd_vc1vdec", (VIDDEC3_Params *)vc1_params);
+            break;
+
+        case DCE_TEST_MJPEG :
+            mjpeg_params = (IJPEGVDEC_Params *) params;
+            mjpeg_params->ErrorConcealmentON = TRUE;
+            mjpeg_params->debugTraceLevel = 0;
+            mjpeg_params->lastNFramesToLog = 0;
+            mjpeg_params->sliceSwitchON = 0;
+            mjpeg_params->numSwitchPerFrame = 0;
+            mjpeg_params->numRestartMarkerPerSwitch = 0;
+
+            DEBUG("dce_alloc VIDDEC3_Params successful mjpeg_params=%p", mjpeg_params);
+
+            err = msync((Ptr)mjpeg_params, sizeof(IJPEGVDEC_Params), MS_CACHE_ONLY | MS_SYNC);
+
+            codec = VIDDEC3_create(engine, "ivahd_jpegvdec", (VIDDEC3_Params *)mjpeg_params);
+            break;
+#ifdef ENABLE_MPEG2
+        case DCE_TEST_MPEG2 :
+            mpeg2_params = (IMPEG2VDEC_Params *) params;
+            mpeg2_params->outloopDeBlocking = TRUE;
+            mpeg2_params->ErrorConcealmentON = FALSE;
+            mpeg2_params->debugTraceLevel = 0;
+            mpeg2_params->lastNFramesToLog = 0;
+
+            DEBUG("dce_alloc VIDDEC3_Params successful mpeg2_params=%p", mpeg2_params);
+
+            err = msync((Ptr)mpeg2_params, sizeof(IMPEG2VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
+
+            codec = VIDDEC3_create(engine, "ivahd_mpeg2vdec", (VIDDEC3_Params *)mpeg2_params);
+            break;
+#endif
+    }
+
+    if( !codec ) {
+        ERROR("fail");
+        goto out;
+    }
+
+    DEBUG("VIDDEC3_create successful codec=%p", codec);
+
+    switch( codec_switch ) {
+        case DCE_TEST_H264 :
+            dynParams = dce_alloc(sizeof(IH264VDEC_DynamicParams));
+            dynParams->size = sizeof(IH264VDEC_DynamicParams);
+            break;
+        case DCE_TEST_MPEG4 :
+            dynParams = dce_alloc(sizeof(IMPEG4VDEC_DynamicParams));
+            dynParams->size = sizeof(IMPEG4VDEC_DynamicParams);
+            dynParams->lateAcquireArg = -1;
+            break;
+        case DCE_TEST_VC1SMP :
+        case DCE_TEST_VC1AP :
+            dynParams = dce_alloc(sizeof(IVC1VDEC_DynamicParams));
+            dynParams->size = sizeof(IVC1VDEC_DynamicParams);
+            dynParams->lateAcquireArg = -1;
+            break;
+        case DCE_TEST_MJPEG :
+            dynParams = dce_alloc(sizeof(IJPEGVDEC_DynamicParams));
+            dynParams->size = sizeof(IJPEGVDEC_DynamicParams);
+            dynParams->lateAcquireArg = -1;
+            break;
+#ifdef ENABLE_MPEG2
+        case DCE_TEST_MPEG2 :
+            dynParams = dce_alloc(sizeof(IMPEG2VDEC_DynamicParams));
+            dynParams->size = sizeof(IMPEG2VDEC_DynamicParams);
+            dynParams->lateAcquireArg = -1;
+            break;
+#endif
+    }
+
+    dynParams->decodeHeader  = XDM_DECODE_AU;
+    /*Not Supported: Set default*/
+    dynParams->displayWidth  = 0;
+    dynParams->frameSkipMode = IVIDEO_NO_SKIP;
+    dynParams->newFrameFlag  = XDAS_TRUE;
+
+
+    //Testing XDM_GETVERSION
+    // NOT WORKING
+#if 0
+
+    switch( codec_switch ) {
+        case DCE_TEST_H264 :
+
+            DEBUG("dce_alloc IH264VDEC_DynamicParams successful dynParams=%p", dynParams);
+            h264_dynParams = (IH264VDEC_DynamicParams *) dynParams;
+            DEBUG("dce_alloc IH264VDEC_DynamicParams successful h264_dynParams=%p", h264_dynParams);
+
+            status = dce_alloc(sizeof(IH264VDEC_Status));
+            status->size = sizeof(IH264VDEC_Status);
+            DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
+
+            status->data.buf = (XDAS_Int8 *) version_buffer;
+            h264_status = (IH264VDEC_Status *) status;
+            DEBUG("dce_alloc IH264VDEC_Status successful h264_status=%p", h264_status);
+
+            //((IH264VDEC_Status*)h264_status)->viddec3Status->data.buf = version_buffer;
+            err = VIDDEC3_control(codec, XDM_GETVERSION, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
+
+            DEBUG("dce_alloc IH264VDEC_Status get_version h264_status=%s", (((VIDDEC3_Status *)h264_status)->data.buf));
+            break;
+        default :
+            DEBUG("Not implemented or supported codec_switch %d", codec_switch);
+    }
+
+    if( status ) {
+        dce_free(status);
+    }
+#endif
+
+    switch( codec_switch ) {
+        case DCE_TEST_H264 :
+
+            DEBUG("dce_alloc IH264VDEC_DynamicParams successful dynParams=%p", dynParams);
+            h264_dynParams = (IH264VDEC_DynamicParams *) dynParams;
+            DEBUG("dce_alloc IH264VDEC_DynamicParams successful h264_dynParams=%p", h264_dynParams);
+
+            status = dce_alloc(sizeof(IH264VDEC_Status));
+            status->size = sizeof(IH264VDEC_Status);
+            DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
+
+            h264_status = (IH264VDEC_Status *) status;
+            DEBUG("dce_alloc IH264VDEC_Status successful h264_status=%p", h264_status);
+            err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
+            break;
+
+        case DCE_TEST_MPEG4 :
+
+            DEBUG("dce_alloc IMPEG4VDEC_DynamicParams successful dynParams=%p", dynParams);
+            mpeg4_dynParams = (IMPEG4VDEC_DynamicParams *) dynParams;
+            DEBUG("dce_alloc IMPEG4VDEC_DynamicParams successful mpeg4_dynParams=%p", mpeg4_dynParams);
+
+            status = dce_alloc(sizeof(IMPEG4VDEC_Status));
+            status->size = sizeof(IMPEG4VDEC_Status);
+            DEBUG("dce_alloc IMPEG4VDEC_Status successful status=%p", status);
+
+            mpeg4_status = (IMPEG4VDEC_Status *) status;
+            DEBUG("dce_alloc IMPEG4VDEC_Status successful mpeg4_status=%p", mpeg4_status);
+            err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
+            break;
+
+        case DCE_TEST_VC1SMP :
+        case DCE_TEST_VC1AP :
+
+            DEBUG("dce_alloc IVC1VDEC_DynamicParams successful dynParams=%p", dynParams);
+            vc1_dynParams = (IVC1VDEC_DynamicParams *) dynParams;
+            DEBUG("dce_alloc IVC1VDEC_DynamicParams successful vc1_dynParams=%p", vc1_dynParams);
+
+            status = dce_alloc(sizeof(IVC1VDEC_Status));
+            status->size = sizeof(IVC1VDEC_Status);
+            DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
+
+            vc1_status = (IVC1VDEC_Status *) status;
+            DEBUG("dce_alloc IVC1VDEC_Status successful vc1_status=%p", vc1_status);
+            err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
+            break;
+
+        case DCE_TEST_MJPEG :
+
+            DEBUG("dce_alloc IJPEGVDEC_DynamicParams successful dynParams=%p", dynParams);
+            mjpeg_dynParams = (IJPEGVDEC_DynamicParams *) dynParams;
+            mjpeg_dynParams->decodeThumbnail = 0;
+            mjpeg_dynParams->thumbnailMode = IJPEGVDEC_THUMBNAIL_DOWNSAMPLE;
+            mjpeg_dynParams->downsamplingFactor = IJPEGVDEC_NODOWNSAMPLE;
+            mjpeg_dynParams->streamingCompliant = 1;
+
+            DEBUG("dce_alloc IJPEGVDEC_DynamicParams successful mjpeg_dynParams=%p", mjpeg_dynParams);
+
+            status = dce_alloc(sizeof(IVC1VDEC_Status));
+            status->size = sizeof(IJPEGVDEC_Status);
+            DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
+
+            mjpeg_status = (IJPEGVDEC_Status *) status;
+            DEBUG("dce_alloc IJPEGVDEC_Status successful mjpeg_status=%p", mjpeg_status);
+            err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
+            break;
+#ifdef ENABLE_MPEG2
+        case DCE_TEST_MPEG2 :
+
+            DEBUG("dce_alloc IMPEG2VDEC_DynamicParams successful dynParams=%p", dynParams);
+            mpeg2_dynParams = (IMPEG2VDEC_DynamicParams *) dynParams;
+            //MPEG2 buffer width should be 128 byte aligned for non TILER (atleast)
+            //If displayWidth=0 then MPEG2 codec does not have a way to calculate
+            //the stride as compared to other codecs which can calculate it from
+            //buffer size and image height.stride=buffersize/(height*1.5)
+            mpeg2_dynParams->viddecDynamicParams.displayWidth = padded_width;
+
+            DEBUG("dce_alloc IMPEG2VDEC_DynamicParams successful mpeg2_dynParams=%p", mpeg2_dynParams);
+
+            status = dce_alloc(sizeof(IMPEG2VDEC_Status));
+            status->size = sizeof(IMPEG2VDEC_Status);
+            DEBUG("dce_alloc IMPEG2VDEC_Status successful status=%p", status);
+
+            mpeg2_status = (IMPEG2VDEC_Status *) status;
+            DEBUG("dce_alloc IMPEG2VDEC_Status successful mpeg2_status=%p", mpeg2_status);
+            err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
+            break;
+#endif
+        default :
+            DEBUG("Not implemented or supported codec_switch %d", codec_switch);
+    }
+
+    if( err ) {
+        ERROR("fail: %d", err);
+        goto shutdown;
+    }
+
+    DEBUG("VIDDEC3_control XDM_SETPARAMS successful");
+
+    DEBUG("input buffer configuration width %d height %d", width, height);
+    inBufs = dce_alloc(sizeof(XDM2_BufDesc));
+    inBufs->numBufs = 1;
+    input = tiler_alloc(width * height, 0);
+    inBufs->descs[0].buf = (XDAS_Int8 *)input;
+    inBufs->descs[0].memType = XDM_MEMTYPE_RAW;
+
+    DEBUG("inBufs->descs[0].buf %p input %p", inBufs->descs[0].buf, input);
+
+    outBufs = dce_alloc(sizeof(XDM2_BufDesc));
+
+    DEBUG("output buffer configuration num_buffers %d padded_width %d padded_height %d", num_buffers, padded_width, padded_height);
+
+#ifdef PROFILE_TIME
+    uint64_t    alloc_time_start = mark_microsecond(NULL);
+#endif
+
+    if( !(strcmp(tilerbuffer, "tiler"))) {
+        DEBUG("Output allocate through tiler");
+        tiler = 1;
+        err = output_allocate(outBufs, num_buffers,
+                              padded_width, padded_height, stride);
+    } else {
+        DEBUG("Output allocate through non-tiler");
+        tiler = 0;
+        err = output_allocate_nonTiler(outBufs, num_buffers,
+                                       padded_width, padded_height, stride);
+    }
+
+#ifdef PROFILE_TIME
+    output_alloc_time = mark_microsecond(&alloc_time_start);
+#endif
+
+    if( err ) {
+        ERROR("fail: %d", err);
+        goto shutdown;
+    }
+
+    inArgs = dce_alloc(sizeof(IVIDDEC3_InArgs));
+    inArgs->size = sizeof(IVIDDEC3_InArgs);
+
+    outArgs = dce_alloc(sizeof(IVIDDEC3_OutArgs));
+    outArgs->size = sizeof(IVIDDEC3_OutArgs);
+
+#ifdef PROFILE_TIME
+    total_init_time = (uint64_t)mark_microsecond(&init_start_time);
+    INFO("total_init_time %llu output_alloc_time %llu actual init time in: %lld us", total_init_time, output_alloc_time, total_init_time  - output_alloc_time);
+#endif
+
+    while( inBufs->numBufs && outBufs->numBufs ) {
+        OutputBuffer   *buf;
+        int             n, i;
+
+        if( !outBufsInUse ) {
+            buf = output_get();
+            if( !buf ) {
+                ERROR("fail: out of buffers");
+                goto shutdown;
+            }
+        } else {
+            buf = 0;
+        }
+
+        n = read_input(in_pattern, in_cnt, input);
+        if( n && (n != -1)) {
+            eof = 0;
+            inBufs->numBufs = 1;
+            inBufs->descs[0].buf = (XDAS_Int8 *)input;
+            inBufs->descs[0].bufSize.bytes = n;
+            inArgs->numBytes = n;
+            DEBUG("push: %d (%d bytes) (%p)", in_cnt, n, buf);
+            in_cnt++;
+
+            /*
+             * Input buffer has data to be decoded.
+             */
+            inArgs->inputID = (XDAS_Int32)buf;
+            if( !outBufsInUse ) {
+                outBufs->numBufs = 2;
+                outBufs->descs[0].buf = (XDAS_Int8 *)buf->y;
+                outBufs->descs[1].buf = (XDAS_Int8 *)buf->uv;
+            }
+        } else if( n == -1 ) {
+
+            // Set EOF as 1 to ensure flush completes
+            eof = 1;
+            in_cnt++;
+
+            switch( codec_switch ) {
+                case DCE_TEST_H264 :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH h264_dynParams %p h264_status %p", h264_dynParams, h264_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
+                    break;
+                case DCE_TEST_MPEG4 :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg4_dynParams %p mpeg4_status %p", mpeg4_dynParams, mpeg4_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
+                    break;
+                case DCE_TEST_VC1SMP :
+                case DCE_TEST_VC1AP :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH vc1_dynParams %p vc1_status %p", vc1_dynParams, vc1_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
+                    break;
+                case DCE_TEST_MJPEG :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH mjpeg_dynParams %p mjpeg_status %p", mjpeg_dynParams, mjpeg_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
+                    break;
+#ifdef ENABLE_MPEG2
+                case DCE_TEST_MPEG2 :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg2_dynParams %p mpeg2_status %p", mpeg2_dynParams, mpeg2_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
+                    break;
+#endif
+            }
+
+            /* We have sent the XDM_FLUSH, call VIDDEC3_process until we get
+             * an error of XDM_EFAIL which tells us there are no more buffers
+             * at codec level.
+             */
+
+            inArgs->inputID = 0;
+            inArgs->numBytes = 0;
+            inBufs->descs[0].buf = NULL;
+            inBufs->descs[0].bufSize.bytes = 0;
+            outBufs->numBufs = 0;
+            outBufs->descs[0].buf = NULL;
+            outBufs->descs[1].buf = NULL;
+            if( buf ) {
+                output_release(buf);
+            }
+            outBufsInUse = 0;
+
+
+        } else {
+            /* end of input.. */
+            inBufs->numBufs = 0;
+            eof = 1;
+
+            switch( codec_switch ) {
+                case DCE_TEST_H264 :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH h264_dynParams %p h264_status %p", h264_dynParams, h264_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
+                    break;
+                case DCE_TEST_MPEG4 :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg4_dynParams %p mpeg4_status %p", mpeg4_dynParams, mpeg4_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
+                    break;
+                case DCE_TEST_VC1SMP :
+                case DCE_TEST_VC1AP :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH vc1_dynParams %p vc1_status %p", vc1_dynParams, vc1_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
+                    break;
+                case DCE_TEST_MJPEG :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH mjpeg_dynParams %p mjpeg_status %p", mjpeg_dynParams, mjpeg_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
+                    break;
+#ifdef ENABLE_MPEG2
+                case DCE_TEST_MPEG2 :
+                    DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg2_dynParams %p mpeg2_status %p", mpeg2_dynParams, mpeg2_status);
+                    err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
+                    break;
+#endif
+            }
+
+            /* We have sent the XDM_FLUSH, call VIDDEC3_process until we get
+             * an error of XDM_EFAIL which tells us there are no more buffers
+             * at codec level.
+             */
+
+            inArgs->inputID = 0;
+            inArgs->numBytes = 0;
+            inBufs->numBufs = 0;
+            inBufs->descs[0].buf = NULL;
+            inBufs->descs[0].bufSize.bytes = 0;
+            outBufs->numBufs = 0;
+            outBufs->descs[0].buf = NULL;
+            outBufs->descs[1].buf = NULL;
+            if( buf ) {
+                output_release(buf);
+            }
+        }
+
+#ifdef DUMPINPUTDATA
+        DEBUG("input data dump inArgs->numBytes[%d] inputDump[%p]", inArgs->numBytes, inputDump);
+
+        //Dump the file
+        if( inputDump == NULL ) {
+            inputDump = fopen("/tmp/inputdump.h264", "ab");
+            DEBUG("input data dump file open %p errno %d", inputDump, errno);
+            if( inputDump == NULL ) {
+                DEBUG("Opening input Dump /tmp/inputdump.h264 file FAILED");
+            }
+        }
+        DEBUG("input data dump file open %p Successful", inputDump);
+
+        fwrite(input, sizeof(char), inArgs->numBytes, inputDump);
+        DEBUG("Dumping input file with size = %d ", inArgs->numBytes);
+        fflush(inputDump);
+        fclose(inputDump);
+        inputDump = NULL;
+    #endif
+
+        int    iters = 0;
+
+        do {
+            DEBUG("Calling VIDDEC3_process inArgs->inputID=%x inBufs->descs[0].buf %p inBufs->descs.bufSize %d input %p",
+                  inArgs->inputID, inBufs->descs[0].buf, (int) inBufs->descs[0].bufSize.bytes, input);
+#ifdef PROFILE_TIME
+            codec_process_time = mark_microsecond(NULL);
+#endif
+            err = VIDDEC3_process(codec, inBufs, outBufs, inArgs, outArgs);
+#ifdef PROFILE_TIME
+            INFO("processed returned in: %llu us", (uint64_t) mark_microsecond(&codec_process_time));
+#endif
+            if( err ) {
+                if( XDM_ISFATALERROR(outArgs->extendedError)) {
+                    ERROR("process returned error: %d\n", err);
+                    ERROR("extendedError: %08x", outArgs->extendedError);
+                    goto shutdown;
+                } else if( eof ) {
+                    /*
+                     * Flush has been ordered, processing the returned output from codec.
+                     * For H.264, bit 18 - IH264VDEC_ERR_STREAM_END indicates flush is completed.
+                     * For MPEG4, bit 24 - IMPEG4VDEC_ERR_STREAM_END indicates flush is completed.
+                     * Only return XDM_EFAIL, when those bit are set.
+                     */
+                    ERROR("Codec_process returned err=%d, extendedError=%08x", err, outArgs->extendedError);
+                    err = XDM_EFAIL;
+
+                    if((!(((outArgs->extendedError) >> 24) & 0x1)) &&
+                       ((ivahd_decode_type == 2 /*IVAHD_MP4V_DECODE*/) ||
+                        (ivahd_decode_type == 3 /*IVAHD_S263_DECODE*/))) {
+                        err = XDM_EOK;
+                    }
+
+                    if((!(((outArgs->extendedError) >> 18) & 0x1)) &&
+                       ((ivahd_decode_type == 1 /*IVAHD_H264_DECODE*/) ||
+                        (ivahd_decode_type == 0 /*IVAHD_AVC1_DECODE*/))) {
+                        err = XDM_EOK;
+                    }
+
+                    if( err == XDM_EFAIL ) {
+                        DEBUG("-------------------- Flush completed------------------------");
+                    }
+                } else {
+                    DEBUG("Non-fatal err=%d, extendedError=%08x", err, outArgs->extendedError);
+                    err = XDM_EOK;
+                }
+            }
+
+            /*
+             * Handling of output data from codec
+             */
+            if( tiler ) {
+                for( i = 0; outArgs->outputID[i]; i++ ) {
+                    /* calculate offset to region of interest */
+                    XDM_Rect   *r = &(outArgs->displayBufs.bufDesc[0].activeFrameRegion);
+
+                    int    yoff  = (r->topLeft.y * stride) + r->topLeft.x;
+                    int    uvoff = (r->topLeft.y * stride / 2) + (stride * padded_height) + r->topLeft.x;
+
+                    /* get the output buffer and write it to file */
+                    buf = (OutputBuffer *)outArgs->outputID[i];
+                    DEBUG("pop: %d (%p)", out_cnt, buf);
+
+                    if( out_cnt < 30 ) {  // write first 30 frames to output file out_cnt < 300
+                        write_output(out_pattern, out_cnt++, buf->buf + yoff,
+                                     buf->buf + uvoff, stride);
+                    } else {
+                        out_cnt++;
+                    }
+                }
+            } else {
+                for( i = 0; outArgs->outputID[i]; i++ ) {
+                    /* calculate offset to region of interest */
+                    XDM_Rect   *r = &(outArgs->displayBufs.bufDesc[0].activeFrameRegion);
+
+                    int    yoff  = (r->topLeft.y * padded_width) + r->topLeft.x;
+                    int    uvoff = (r->topLeft.y * padded_width / 2) + (padded_height * padded_width) + r->topLeft.x;
+
+                    /* get the output buffer and write it to file */
+                    buf = (OutputBuffer *)outArgs->outputID[i];
+                    DEBUG("pop: %d (%p)", out_cnt, buf);
+
+                    if( out_cnt < 300 ) {  // write first 300 frames to output file
+                        write_output(out_pattern, out_cnt++, buf->buf + yoff,
+                                     buf->buf + uvoff, padded_width);
+                    } else {
+                        out_cnt++;
+                    }
+                }
+            }
+
+            for( i = 0; outArgs->freeBufID[i]; i++ ) {
+                DEBUG("freeBufID[%d] = %d", i, outArgs->freeBufID[i]);
+                buf = (OutputBuffer *)outArgs->freeBufID[i];
+                output_release(buf);
+            }
+
+            if( outArgs->outBufsInUseFlag ) {
+                outBufsInUse = TRUE;
+                DEBUG("outBufsInUseFlag is SET. Not sending a new output buffer to codec on the next Codec_process ");
+            } else {
+                outBufsInUse = FALSE;
+            }
+
+            ++iters; // Guard for infinite VIDDEC3_PROCESS loop when codec never return XDM_EFAIL
+        } while( eof && (err != XDM_EFAIL) && (iters < 100));  // Multiple VIDDEC3_process when eof until err == XDM_EFAIL
+
+    }
+
+shutdown:
+
+    printf("\nDeleting codec...\n");
+    VIDDEC3_delete(codec);
+
+out:
+    if( engine ) {
+        Engine_close(engine);
+    }
+    if( params ) {
+        dce_free(params);
+    }
+    if( dynParams ) {
+        dce_free(dynParams);
+    }
+    if( status ) {
+        dce_free(status);
+    }
+    if( inBufs ) {
+        dce_free(inBufs);
+    }
+    if( outBufs ) {
+        dce_free(outBufs);
+    }
+    if( inArgs ) {
+        dce_free(inArgs);
+    }
+    if( outArgs ) {
+        dce_free(outArgs);
+    }
+    if( input ) {
+        MemMgr_Free(input);
+    }
+
+    output_free();
+
+    printf("DCE test completed...\n");
+
+    return (0);
+}
+
diff --git a/test_qnx/dce_test.use b/test_qnx/dce_test.use
new file mode 100644 (file)
index 0000000..413d849
--- /dev/null
@@ -0,0 +1,38 @@
+/*\r
+ * $QNXLicenseC:\r
+ */\r
+\r
+\r
+%C dce test application to test libdce\r
+\r
+Syntax:\r
+%C [options]\r
+Options:\r
+ -h         Print out the help information\r
+\r
+Examples:\r
+1. decoding h.264\r
+   dce_test width height framesize inpattern outpattern codec tiler/nontiler\r
+   dce_test 320 240 framesize.txt inputfile.h264 outputfile.yuv h264 tiler\r
+\r
+2. decoding mpeg4\r
+   dce_test width height framesize inpattern outpattern codec tiler/nontiler\r
+   dce_test 640 480 framesize.txt inputfile.m4v outputfile.yuv mpeg4 nontiler\r
+\r
+3. decoding vc1ap\r
+   dce_test width height framesize inpattern outpattern codec tiler/nontiler\r
+   dce_test 720 480 framesize.txt inputfile.vc1 outputfile.yuv vc1ap tiler\r
+\r
+4. decoding vc1smp\r
+   dce_test width height framesize inpattern outpattern codec tiler/nontiler\r
+   dce_test 320 240 framesize.txt inputfile.vc1 outputfile.yuv vc1smp nontiler\r
+\r
+5. decoding mjpeg\r
+   dce_test width height framesize inpattern outpattern codec tiler/nontiler\r
+   dce_test 1280 720 framesize.txt inputfile.bin outputfile.yuv mjpeg tiler\r
+\r
+6. decoding mpeg2\r
+   dce_test width height framesize inpattern outpattern codec tiler/nontiler\r
+   dce_test 1920 1088 framesize.txt inputfile.bin outputfile.yuv mpeg2 nontiler\r
+\r
+Currently supported codecs: h264, mpeg4, vc1ap, vc1smp, mjpeg, mpeg2\r