[2/2] st/omx_tizonia: Add AVC decoder

Submitted by Gurkirpal Singh on Aug. 11, 2017, 4:31 a.m.

Details

Message ID 1502425915-11606-2-git-send-email-gurkirpal204@gmail.com
State New
Series "Series without cover letter"
Headers show

Commit Message

Gurkirpal Singh Aug. 11, 2017, 4:31 a.m.
Signed-off-by: Gurkirpal Singh <gurkirpal204@gmail.com>
---
 src/gallium/state_trackers/omx_tizonia/Makefile.am |   35 +
 .../state_trackers/omx_tizonia/Makefile.sources    |    9 +
 .../state_trackers/omx_tizonia/entrypoint.c        |  152 ++
 .../state_trackers/omx_tizonia/entrypoint.h        |   35 +
 src/gallium/state_trackers/omx_tizonia/h264d.c     |  173 ++
 src/gallium/state_trackers/omx_tizonia/h264d.h     |   54 +
 src/gallium/state_trackers/omx_tizonia/h264dprc.c  | 1713 ++++++++++++++++++++
 src/gallium/state_trackers/omx_tizonia/h264dprc.h  |   31 +
 .../state_trackers/omx_tizonia/h264dprc_decls.h    |  108 ++
 src/gallium/state_trackers/omx_tizonia/names.h     |   30 +
 10 files changed, 2340 insertions(+)
 create mode 100644 src/gallium/state_trackers/omx_tizonia/Makefile.am
 create mode 100644 src/gallium/state_trackers/omx_tizonia/Makefile.sources
 create mode 100644 src/gallium/state_trackers/omx_tizonia/entrypoint.c
 create mode 100644 src/gallium/state_trackers/omx_tizonia/entrypoint.h
 create mode 100644 src/gallium/state_trackers/omx_tizonia/h264d.c
 create mode 100644 src/gallium/state_trackers/omx_tizonia/h264d.h
 create mode 100644 src/gallium/state_trackers/omx_tizonia/h264dprc.c
 create mode 100644 src/gallium/state_trackers/omx_tizonia/h264dprc.h
 create mode 100644 src/gallium/state_trackers/omx_tizonia/h264dprc_decls.h
 create mode 100644 src/gallium/state_trackers/omx_tizonia/names.h

Patch hide | download patch | download mbox

diff --git a/src/gallium/state_trackers/omx_tizonia/Makefile.am b/src/gallium/state_trackers/omx_tizonia/Makefile.am
new file mode 100644
index 0000000..932929b
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/Makefile.am
@@ -0,0 +1,35 @@ 
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+include Makefile.sources
+include $(top_srcdir)/src/gallium/Automake.inc
+
+AM_CFLAGS = \
+	$(GALLIUM_CFLAGS) \
+	$(VISIBILITY_CFLAGS) \
+	$(VL_CFLAGS) \
+	$(XCB_DRI3_CFLAGS) \
+	$(OMX_TIZONIA_CFLAGS) \
+	$(OMX_TIZILHEADERS_CFLAGS) \
+	$(OMX_TIZPLATFORM_CFLAGS)
+
+noinst_LTLIBRARIES = libomxtiztracker.la
+
+libomxtiztracker_la_SOURCES = $(C_SOURCES)
diff --git a/src/gallium/state_trackers/omx_tizonia/Makefile.sources b/src/gallium/state_trackers/omx_tizonia/Makefile.sources
new file mode 100644
index 0000000..7bb08b9
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/Makefile.sources
@@ -0,0 +1,9 @@ 
+C_SOURCES := \
+	entrypoint.c \
+	entrypoint.h \
+	h264d.c \
+	h264d.h \
+	h264dprc.c \
+	h264dprc.h \
+	names.h \
+	h264prc_decls.h
diff --git a/src/gallium/state_trackers/omx_tizonia/entrypoint.c b/src/gallium/state_trackers/omx_tizonia/entrypoint.c
new file mode 100644
index 0000000..95094cf
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/entrypoint.c
@@ -0,0 +1,152 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include <assert.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <tizplatform.h>
+#include <tizkernel.h>
+#include <tizscheduler.h>
+#include <tizport.h>
+#include <tizport_decls.h>
+#include <tizvideoport.h>
+#include <tizvideoport_decls.h>
+
+#include "os/os_thread.h"
+#include "util/u_memory.h"
+#include "loader/loader.h"
+
+#include "entrypoint.h"
+#include "h264d.h"
+#include "h264dprc.h"
+#include "names.h"
+
+#if defined(HAVE_X11_PLATFORM)
+#include <X11/Xlib.h>
+#else
+#define XOpenDisplay(x) NULL
+#define XCloseDisplay(x)
+#define Display void
+#endif
+
+static mtx_t omx_lock = _MTX_INITIALIZER_NP;
+static Display *omx_display = NULL;
+static struct vl_screen *omx_screen = NULL;
+static unsigned omx_usecount = 0;
+static const char *omx_render_node = NULL;
+static int drm_fd;
+
+OMX_ERRORTYPE OMX_ComponentInit (OMX_HANDLETYPE ap_hdl)
+{
+   tiz_role_factory_t h264d_role;
+   const tiz_role_factory_t * rf_list[] = {&h264d_role};
+   tiz_type_factory_t h264dprc_type;
+   const tiz_type_factory_t * tf_list[] = {&h264dprc_type};
+
+   /* Settings for roles */
+   strcpy ((OMX_STRING) h264d_role.role, OMX_VID_DEC_AVC_ROLE);
+   h264d_role.pf_cport = instantiate_h264d_config_port;
+   h264d_role.pf_port[0] = instantiate_h264d_input_port;
+   h264d_role.pf_port[1] = instantiate_h264d_output_port;
+   h264d_role.nports = 2;
+   h264d_role.pf_proc = instantiate_h264d_processor;
+
+   /* Settings for classes */
+   strcpy ((OMX_STRING) h264dprc_type.class_name, "h264dprc_class");
+   h264dprc_type.pf_class_init = h264d_prc_class_init;
+   strcpy ((OMX_STRING) h264dprc_type.object_name, "h264dprc");
+   h264dprc_type.pf_object_init = h264d_prc_init;
+
+   /* Initialize the component infrastructure */
+   tiz_comp_init (ap_hdl, OMX_VID_COMP_NAME);
+
+   /* Classes need to be registered first */
+   tiz_comp_register_types (ap_hdl, tf_list, 1);
+
+   /* Register the component roles */
+   tiz_comp_register_roles (ap_hdl, rf_list, 1);
+
+   return OMX_ErrorNone;
+}
+
+struct vl_screen *omx_get_screen(void)
+{
+   static bool first_time = true;
+   mtx_lock(&omx_lock);
+
+   if (!omx_screen) {
+      if (first_time) {
+         omx_render_node = debug_get_option("OMX_RENDER_NODE", NULL);
+         first_time = false;
+      }
+      if (omx_render_node) {
+         drm_fd = loader_open_device(omx_render_node);
+         if (drm_fd < 0)
+            goto error;
+
+         omx_screen = vl_drm_screen_create(drm_fd);
+         if (!omx_screen) {
+            close(drm_fd);
+            goto error;
+         }
+      } else {
+         omx_display = XOpenDisplay(NULL);
+         if (!omx_display)
+            goto error;
+
+         omx_screen = vl_dri3_screen_create(omx_display, 0);
+         if (!omx_screen)
+            omx_screen = vl_dri2_screen_create(omx_display, 0);
+         if (!omx_screen) {
+            XCloseDisplay(omx_display);
+            goto error;
+         }
+      }
+   }
+
+   ++omx_usecount;
+
+   mtx_unlock(&omx_lock);
+   return omx_screen;
+
+error:
+   mtx_unlock(&omx_lock);
+   return NULL;
+}
+
+void omx_put_screen(void)
+{
+   mtx_lock(&omx_lock);
+   if ((--omx_usecount) == 0) {
+      omx_screen->destroy(omx_screen);
+      omx_screen = NULL;
+
+      if (omx_render_node)
+         close(drm_fd);
+      else
+         XCloseDisplay(omx_display);
+   }
+   mtx_unlock(&omx_lock);
+}
diff --git a/src/gallium/state_trackers/omx_tizonia/entrypoint.h b/src/gallium/state_trackers/omx_tizonia/entrypoint.h
new file mode 100644
index 0000000..e5d3932
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/entrypoint.h
@@ -0,0 +1,35 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef OMX_TIZ_ENTRYPOINT_H
+#define OMX_TIZ_ENTRYPOINT_H
+
+#include "vl/vl_winsys.h"
+
+PUBLIC OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE ap_hdl);
+
+struct vl_screen *omx_get_screen(void);
+void omx_put_screen(void);
+
+#endif
diff --git a/src/gallium/state_trackers/omx_tizonia/h264d.c b/src/gallium/state_trackers/omx_tizonia/h264d.c
new file mode 100644
index 0000000..7cafdc9
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/h264d.c
@@ -0,0 +1,173 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include <tizport_decls.h>
+
+#include "h264dprc.h"
+#include "h264d.h"
+#include "names.h"
+
+static OMX_VERSIONTYPE h264_decoder_version = {{0, 0, 0, 1}};
+
+OMX_PTR instantiate_h264d_input_port(OMX_HANDLETYPE ap_hdl)
+{
+   OMX_VIDEO_PORTDEFINITIONTYPE portdef;
+   OMX_VIDEO_PARAM_AVCTYPE avctype;
+   OMX_VIDEO_CODINGTYPE encodings[] = {
+      OMX_VIDEO_CodingAVC,
+      OMX_VIDEO_CodingMax
+   };
+   OMX_COLOR_FORMATTYPE formats[] = {
+      OMX_COLOR_FormatUnused,
+      OMX_COLOR_FormatMax
+   };
+   tiz_port_options_t avc_port_opts = {
+      OMX_PortDomainVideo,
+      OMX_DirInput,
+      OMX_VID_DEC_AVC_INPUT_PORT_MIN_BUF_COUNT,
+      OMX_VID_DEC_AVC_PORT_MIN_INPUT_BUF_SIZE,
+      OMX_VID_DEC_AVC_PORT_NONCONTIGUOUS,
+      OMX_VID_DEC_AVC_PORT_ALIGNMENT,
+      OMX_VID_DEC_AVC_PORT_SUPPLIERPREF,
+      {OMX_VID_DEC_AVC_INPUT_PORT_INDEX, NULL, NULL, NULL},
+      1                     /* slave port */
+   };
+   OMX_VIDEO_AVCLEVELTYPE levels[] = {
+      OMX_VIDEO_AVCLevel1,
+      OMX_VIDEO_AVCLevel1b,
+      OMX_VIDEO_AVCLevel11,
+      OMX_VIDEO_AVCLevel12,
+      OMX_VIDEO_AVCLevel13,
+      OMX_VIDEO_AVCLevel2,
+      OMX_VIDEO_AVCLevel21,
+      OMX_VIDEO_AVCLevel22,
+      OMX_VIDEO_AVCLevel3,
+      OMX_VIDEO_AVCLevel31,
+      OMX_VIDEO_AVCLevel32,
+      OMX_VIDEO_AVCLevel4,
+      OMX_VIDEO_AVCLevel41,
+      OMX_VIDEO_AVCLevel42,
+      OMX_VIDEO_AVCLevel5,
+      OMX_VIDEO_AVCLevel51,
+      OMX_VIDEO_AVCLevelMax
+   };
+
+   portdef.pNativeRender = NULL;
+   portdef.nFrameWidth = OMX_VID_DEC_AVC_DEFAULT_FRAME_WIDTH;
+   portdef.nFrameHeight = OMX_VID_DEC_AVC_DEFAULT_FRAME_HEIGHT;
+   portdef.nStride = 0;
+   portdef.nSliceHeight = 0;
+   portdef.nBitrate = 64000;
+   portdef.xFramerate = OMX_VID_DEC_AVC_DEFAULT_FRAME_RATE;
+   portdef.bFlagErrorConcealment = OMX_FALSE;
+   portdef.eCompressionFormat = OMX_VIDEO_CodingAVC;
+   portdef.eColorFormat = OMX_COLOR_FormatUnused;
+   portdef.pNativeWindow = NULL;
+
+   avctype.nSize = sizeof (OMX_VIDEO_PARAM_AVCTYPE);
+   avctype.nVersion.nVersion = OMX_VERSION;
+   avctype.nPortIndex = OMX_VID_DEC_AVC_INPUT_PORT_INDEX;
+   avctype.eProfile = OMX_VIDEO_AVCProfileHigh;
+    /* Encoder related, decide if need to initialise these */
+   avctype.nSliceHeaderSpacing = 0;
+   avctype.nPFrames = 0;
+   avctype.nBFrames = 0;
+   avctype.bUseHadamard = OMX_FALSE;
+   avctype.nRefFrames = 1;
+   avctype.nRefIdx10ActiveMinus1 = 1;
+   avctype.nRefIdx11ActiveMinus1 = 0;
+   avctype.bEnableUEP = OMX_FALSE;
+   avctype.bEnableFMO = OMX_FALSE;
+   avctype.bEnableASO = OMX_FALSE;
+   avctype.bEnableRS = OMX_FALSE;
+   avctype.eLevel = OMX_VIDEO_AVCLevel51;
+   avctype.nAllowedPictureTypes = 2;
+   avctype.bFrameMBsOnly = OMX_FALSE;
+   avctype.bMBAFF = OMX_FALSE;
+   avctype.bEntropyCodingCABAC = OMX_FALSE;
+   avctype.bWeightedPPrediction = OMX_FALSE;
+   avctype.nWeightedBipredicitonMode = 0;
+   avctype.bconstIpred = OMX_FALSE;
+   avctype.bDirect8x8Inference = OMX_FALSE;
+   avctype.bDirectSpatialTemporal = OMX_FALSE;
+   avctype.nCabacInitIdc = 0;
+   avctype.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
+
+   return factory_new (tiz_get_type(ap_hdl, "tizavcport"),
+                       &avc_port_opts, &portdef,
+                       &encodings, &formats, &avctype, &levels,
+                       NULL  /* OMX_VIDEO_PARAM_BITRATETYPE */);
+}
+
+OMX_PTR instantiate_h264d_output_port(OMX_HANDLETYPE ap_hdl)
+{
+   OMX_VIDEO_PORTDEFINITIONTYPE portdef;
+   OMX_VIDEO_CODINGTYPE encodings[] = {
+      OMX_VIDEO_CodingUnused,
+      OMX_VIDEO_CodingMax
+   };
+   OMX_COLOR_FORMATTYPE formats[] = {
+      OMX_COLOR_FormatYUV420SemiPlanar,
+      OMX_COLOR_FormatMax
+   };
+   tiz_port_options_t rawvideo_port_opts = {
+      OMX_PortDomainVideo,
+      OMX_DirOutput,
+      OMX_VID_DEC_AVC_OUTPUT_PORT_MIN_BUF_COUNT,
+      OMX_VID_DEC_AVC_PORT_MIN_OUTPUT_BUF_SIZE,
+      OMX_VID_DEC_AVC_PORT_NONCONTIGUOUS,
+      OMX_VID_DEC_AVC_PORT_ALIGNMENT,
+      OMX_VID_DEC_AVC_PORT_SUPPLIERPREF,
+      {OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX, NULL, NULL, NULL},
+      0                     /* Master port */
+   };
+
+   portdef.pNativeRender = NULL;
+   portdef.nFrameWidth = OMX_VID_DEC_AVC_DEFAULT_FRAME_WIDTH;
+   portdef.nFrameHeight = OMX_VID_DEC_AVC_DEFAULT_FRAME_HEIGHT;
+   portdef.nStride = 0;
+   portdef.nSliceHeight = 0;
+   portdef.nBitrate = 64000;
+   portdef.xFramerate = OMX_VID_DEC_AVC_DEFAULT_FRAME_RATE;
+   portdef.bFlagErrorConcealment = OMX_FALSE;
+   portdef.eCompressionFormat = OMX_VIDEO_CodingUnused;
+   portdef.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+   portdef.pNativeWindow = NULL;
+
+   return factory_new(tiz_get_type(ap_hdl, "tizvideoport"),
+                      &rawvideo_port_opts, &portdef,
+                      &encodings, &formats);
+}
+
+OMX_PTR instantiate_h264d_config_port(OMX_HANDLETYPE ap_hdl)
+{
+   return factory_new(tiz_get_type(ap_hdl, "tizconfigport"),
+                      NULL, /* this port does not take options */
+                      OMX_VID_COMP_NAME, h264_decoder_version);
+}
+
+OMX_PTR instantiate_h264d_processor(OMX_HANDLETYPE ap_hdl)
+{
+   return factory_new(tiz_get_type(ap_hdl, "h264dprc"));
+}
diff --git a/src/gallium/state_trackers/omx_tizonia/h264d.h b/src/gallium/state_trackers/omx_tizonia/h264d.h
new file mode 100644
index 0000000..2601401
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/h264d.h
@@ -0,0 +1,54 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef H264D_H
+#define H264D_H
+
+#include <tizonia/OMX_Core.h>
+#include <tizonia/OMX_Types.h>
+#include <tizonia/OMX_Video.h>
+
+#define OMX_VID_DEC_AVC_DEFAULT_FRAME_WIDTH      176
+#define OMX_VID_DEC_AVC_DEFAULT_FRAME_HEIGHT     144
+#define OMX_VID_DEC_AVC_DEFAULT_FRAME_RATE 15<<16
+#define OMX_VID_DEC_AVC_ROLE "video_decoder.avc"
+/* With libtizonia, port indexes must start at index 0 */
+#define OMX_VID_DEC_AVC_INPUT_PORT_INDEX               0
+#define OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX              1
+#define OMX_VID_DEC_AVC_INPUT_PORT_MIN_BUF_COUNT       8
+#define OMX_VID_DEC_AVC_OUTPUT_PORT_MIN_BUF_COUNT      4
+/* 38016 = (width * height) + ((width * height)/2) */
+#define OMX_VID_DEC_AVC_PORT_MIN_INPUT_BUF_SIZE  38016
+#define OMX_VID_DEC_AVC_PORT_MIN_OUTPUT_BUF_SIZE 345600
+#define OMX_VID_DEC_AVC_PORT_NONCONTIGUOUS       OMX_FALSE
+#define OMX_VID_DEC_AVC_PORT_ALIGNMENT           0
+#define OMX_VID_DEC_AVC_PORT_SUPPLIERPREF        OMX_BufferSupplyInput
+#define OMX_VID_DEC_AVC_TIMESTAMP_INVALID ((OMX_TICKS) -1)
+
+OMX_PTR instantiate_h264d_config_port(OMX_HANDLETYPE ap_hdl);
+OMX_PTR instantiate_h264d_input_port(OMX_HANDLETYPE ap_hdl);
+OMX_PTR instantiate_h264d_output_port(OMX_HANDLETYPE ap_hdl);
+OMX_PTR instantiate_h264d_processor(OMX_HANDLETYPE ap_hdl);
+
+#endif                          /* H264D_H */
diff --git a/src/gallium/state_trackers/omx_tizonia/h264dprc.c b/src/gallium/state_trackers/omx_tizonia/h264dprc.c
new file mode 100644
index 0000000..5882680
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/h264dprc.c
@@ -0,0 +1,1713 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#include <tizplatform.h>
+#include <tizkernel.h>
+#include <tizutils.h>
+
+#include "entrypoint.h"
+#include "h264d.h"
+#include "h264dprc.h"
+#include "h264dprc_decls.h"
+
+#include "vl/vl_video_buffer.h"
+#include "vl/vl_compositor.h"
+#include "util/u_memory.h"
+#include "util/u_surface.h"
+
+#define DPB_MAX_SIZE 5
+
+unsigned dec_frame_delta;
+
+struct dpb_list {
+   struct list_head list;
+   struct pipe_video_buffer *buffer;
+   OMX_TICKS timestamp;
+   int poc;
+};
+
+static const uint8_t Default_4x4_Intra[16] = {
+    6, 13, 20, 28, 13, 20, 28, 32,
+   20, 28, 32, 37, 28, 32, 37, 42
+};
+
+static const uint8_t Default_4x4_Inter[16] = {
+   10, 14, 20, 24, 14, 20, 24, 27,
+   20, 24, 27, 30, 24, 27, 30, 34
+};
+
+static const uint8_t Default_8x8_Intra[64] = {
+    6, 10, 13, 16, 18, 23, 25, 27,
+   10, 11, 16, 18, 23, 25, 27, 29,
+   13, 16, 18, 23, 25, 27, 29, 31,
+   16, 18, 23, 25, 27, 29, 31, 33,
+   18, 23, 25, 27, 29, 31, 33, 36,
+   23, 25, 27, 29, 31, 33, 36, 38,
+   25, 27, 29, 31, 33, 36, 38, 40,
+   27, 29, 31, 33, 36, 38, 40, 42
+};
+
+static const uint8_t Default_8x8_Inter[64] = {
+    9, 13, 15, 17, 19, 21, 22, 24,
+   13, 13, 17, 19, 21, 22, 24, 25,
+   15, 17, 19, 21, 22, 24, 25, 27,
+   17, 19, 21, 22, 24, 25, 27, 28,
+   19, 21, 22, 24, 25, 27, 28, 30,
+   21, 22, 24, 25, 27, 28, 30, 32,
+   22, 24, 25, 27, 28, 30, 32, 33,
+   24, 25, 27, 28, 30, 32, 33, 35
+};
+
+static void h264d_free_input_port_private(OMX_BUFFERHEADERTYPE *buf)
+{
+   struct pipe_video_buffer *vbuf = buf->pInputPortPrivate;
+   if (!vbuf)
+      return;
+
+   vbuf->destroy(vbuf);
+   buf->pInputPortPrivate = NULL;
+}
+
+static void release_input_headers(h264d_prc_t * p_prc) {
+   int i;
+   for (i = 0; i < p_prc->num_in_buffers; i++) {
+      assert(!p_prc->in_port_disabled_);
+      if (p_prc->in_buffers[i]->pInputPortPrivate) {
+         h264d_free_input_port_private(p_prc->in_buffers[i]);
+      }
+      (void) tiz_krn_release_buffer (tiz_get_krn (handleOf (p_prc)),
+                                     OMX_VID_DEC_AVC_INPUT_PORT_INDEX,
+                                     p_prc->in_buffers[i]);
+      p_prc->in_buffers[i] = NULL;
+   }
+   p_prc->p_inhdr_ = NULL;
+   p_prc->num_in_buffers = 0;
+}
+
+static void release_output_header(h264d_prc_t * p_prc) {
+   if (p_prc->p_outhdr_) {
+      assert(!p_prc->out_port_disabled_);
+      (void) tiz_krn_release_buffer (tiz_get_krn (handleOf (p_prc)),
+                                     OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
+                                     p_prc->p_outhdr_);
+      p_prc->p_outhdr_ = NULL;
+   }
+}
+
+static OMX_ERRORTYPE h264d_release_all_headers(h264d_prc_t * p_prc)
+{
+   assert(p_prc);
+   release_input_headers(p_prc);
+   release_output_header(p_prc);
+
+   return OMX_ErrorNone;
+}
+
+static void h264d_buffer_emptied(h264d_prc_t * p_prc, OMX_BUFFERHEADERTYPE * p_hdr)
+{
+   assert(p_prc);
+   assert(p_prc->in_buffers[0] == p_hdr);
+
+   if (!p_prc->out_port_disabled_) {
+      assert (p_hdr->nFilledLen == 0);
+      p_hdr->nOffset = 0;
+
+      if ((p_hdr->nFlags & OMX_BUFFERFLAG_EOS) != 0) {
+         p_prc->eos_ = true;
+      }
+
+      (void) tiz_krn_release_buffer (tiz_get_krn (handleOf (p_prc)), 0, p_hdr);
+      p_prc->p_inhdr_ = NULL;
+      p_prc->in_buffers[0] = NULL;
+   }
+}
+
+static void h264d_buffer_filled(h264d_prc_t * p_prc, OMX_BUFFERHEADERTYPE * p_hdr)
+{
+   assert(p_prc);
+   assert(p_hdr);
+   assert(p_prc->p_outhdr_ == p_hdr);
+
+   if (!p_prc->in_port_disabled_) {
+      p_hdr->nOffset = 0;
+
+      if (p_prc->eos_) {
+         /* EOS has been received and all the input data has been consumed
+          * already, so its time to propagate the EOS flag */
+         p_prc->p_outhdr_->nFlags |= OMX_BUFFERFLAG_EOS;
+         p_prc->eos_ = false;
+      }
+
+      (void) tiz_krn_release_buffer(tiz_get_krn (handleOf (p_prc)),
+                                    OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
+                                    p_hdr);
+      p_prc->p_outhdr_ = NULL;
+   }
+}
+
+static bool h264d_shift_buffers_left(h264d_prc_t * p_prc) {
+   if (--p_prc->num_in_buffers) {
+      p_prc->in_buffers[0] = p_prc->in_buffers[1];
+      p_prc->sizes[0] = p_prc->sizes[1] - dec_frame_delta;
+      p_prc->inputs[0] = p_prc->inputs[1] + dec_frame_delta;
+      p_prc->timestamps[0] = p_prc->timestamps[1];
+
+      return true;
+   }
+   return false;
+}
+
+static OMX_BUFFERHEADERTYPE * get_input_buffer(h264d_prc_t * p_prc) {
+   assert(p_prc);
+
+   if (p_prc->in_port_disabled_) {
+      return NULL;
+   }
+
+   if (p_prc->num_in_buffers > 1) {
+      /* The input buffer wasn't cleared last time. */
+      h264d_buffer_emptied(p_prc, p_prc->in_buffers[0]);
+      if (p_prc->in_buffers[0]) {
+         /* Failed to release buffer */
+         return NULL;
+      }
+      h264d_shift_buffers_left(p_prc);
+   }
+
+   /* Decode_frame expects new buffers each time */
+   bool can_get_new_header = (!p_prc->p_inhdr_) || p_prc->first_buf_in_frame;
+   assert(can_get_new_header);
+   tiz_krn_claim_buffer(tiz_get_krn (handleOf (p_prc)),
+                        OMX_VID_DEC_AVC_INPUT_PORT_INDEX, 0,
+                        &p_prc->p_inhdr_);
+   return p_prc->p_inhdr_;
+}
+
+static OMX_BUFFERHEADERTYPE * get_output_buffer(h264d_prc_t * p_prc) {
+   assert (p_prc);
+
+   if (p_prc->out_port_disabled_) {
+      return NULL;
+   }
+
+   if (!p_prc->p_outhdr_) {
+       tiz_krn_claim_buffer(tiz_get_krn (handleOf (p_prc)),
+                              OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX, 0,
+                              &p_prc->p_outhdr_);
+    }
+    return p_prc->p_outhdr_;
+}
+
+static struct pipe_video_buffer *h264d_flush(h264d_prc_t *p_prc, OMX_TICKS *timestamp)
+{
+   struct dpb_list *entry, *result = NULL;
+   struct pipe_video_buffer *buf;
+
+   /* search for the lowest poc and break on zeros */
+   LIST_FOR_EACH_ENTRY(entry, &p_prc->codec_data.dpb_list, list) {
+
+      if (result && entry->poc == 0)
+         break;
+
+      if (!result || entry->poc < result->poc)
+         result = entry;
+   }
+
+   if (!result)
+      return NULL;
+
+   buf = result->buffer;
+   if (timestamp)
+      *timestamp = result->timestamp;
+
+   --p_prc->codec_data.dpb_num;
+   LIST_DEL(&result->list);
+   FREE(result);
+
+   return buf;
+}
+
+static void h264d_end_frame(h264d_prc_t *p_prc)
+{
+   struct dpb_list *entry;
+   struct pipe_video_buffer *tmp;
+   bool top_field_first;
+   OMX_TICKS timestamp;
+
+   if (!p_prc->frame_started)
+      return;
+
+   p_prc->codec->end_frame(p_prc->codec, p_prc->target, &p_prc->picture.base);
+   p_prc->frame_started = false;
+
+   // TODO: implement frame number handling
+   p_prc->picture.h264.frame_num_list[0] = p_prc->picture.h264.frame_num;
+   p_prc->picture.h264.field_order_cnt_list[0][0] = p_prc->picture.h264.frame_num;
+   p_prc->picture.h264.field_order_cnt_list[0][1] = p_prc->picture.h264.frame_num;
+
+   top_field_first = p_prc->picture.h264.field_order_cnt[0] <  p_prc->picture.h264.field_order_cnt[1];
+
+   if (p_prc->picture.h264.field_pic_flag && p_prc->picture.h264.bottom_field_flag != top_field_first)
+      return;
+
+   /* add the decoded picture to the dpb list */
+   entry = CALLOC_STRUCT(dpb_list);
+   if (!entry)
+      return;
+
+   p_prc->first_buf_in_frame = true;
+   entry->buffer = p_prc->target;
+   entry->timestamp = p_prc->timestamp;
+   entry->poc = MIN2(p_prc->picture.h264.field_order_cnt[0], p_prc->picture.h264.field_order_cnt[1]);
+   LIST_ADDTAIL(&entry->list, &p_prc->codec_data.dpb_list);
+   ++p_prc->codec_data.dpb_num;
+   p_prc->target = NULL;
+   p_prc->picture.h264.field_order_cnt[0] = p_prc->picture.h264.field_order_cnt[1] = INT_MAX;
+
+   if (p_prc->codec_data.dpb_num <= DPB_MAX_SIZE)
+      return;
+
+   tmp = p_prc->in_buffers[0]->pInputPortPrivate;
+   p_prc->in_buffers[0]->pInputPortPrivate = h264d_flush(p_prc, &timestamp);
+   p_prc->in_buffers[0]->nTimeStamp = timestamp;
+   p_prc->target = tmp;
+   p_prc->frame_finished = p_prc->in_buffers[0]->pInputPortPrivate != NULL;
+}
+
+static void scaling_list(struct vl_rbsp *rbsp, uint8_t *scalingList, unsigned sizeOfScalingList,
+                         const uint8_t *defaultList, const uint8_t *fallbackList)
+{
+   unsigned lastScale = 8, nextScale = 8;
+   const int *list;
+   unsigned i;
+
+   /* (pic|seq)_scaling_list_present_flag[i] */
+   if (!vl_rbsp_u(rbsp, 1)) {
+      if (fallbackList)
+         memcpy(scalingList, fallbackList, sizeOfScalingList);
+      return;
+   }
+
+   list = (sizeOfScalingList == 16) ? vl_zscan_normal_16 : vl_zscan_normal;
+   for (i = 0; i < sizeOfScalingList; ++i ) {
+
+      if (nextScale != 0) {
+         signed delta_scale = vl_rbsp_se(rbsp);
+         nextScale = (lastScale + delta_scale + 256) % 256;
+         if (i == 0 && nextScale == 0) {
+            memcpy(scalingList, defaultList, sizeOfScalingList);
+            return;
+         }
+      }
+      scalingList[list[i]] = nextScale == 0 ? lastScale : nextScale;
+      lastScale = scalingList[list[i]];
+   }
+}
+
+static void vui_parameters(struct vl_rbsp *rbsp)
+{
+    // TODO
+}
+
+static struct pipe_h264_pps *pic_parameter_set_id(h264d_prc_t *p_prc, struct vl_rbsp *rbsp)
+{
+   unsigned id = vl_rbsp_ue(rbsp);
+   if (id >= ARRAY_SIZE(p_prc->codec_data.pps))
+      return NULL; /* invalid pic_parameter_set_id */
+
+   return &p_prc->codec_data.pps[id];
+}
+
+static struct pipe_h264_sps *seq_parameter_set_id(h264d_prc_t *p_prc, struct vl_rbsp *rbsp)
+{
+   unsigned id = vl_rbsp_ue(rbsp);
+   if (id >= ARRAY_SIZE(p_prc->codec_data.sps))
+      return NULL; /* invalid seq_parameter_set_id */
+
+   return &p_prc->codec_data.sps[id];
+}
+
+static void seq_parameter_set(h264d_prc_t *p_prc, struct vl_rbsp *rbsp)
+{
+   struct pipe_h264_sps *sps;
+   unsigned profile_idc, level_idc;
+   unsigned i;
+
+   /* Sequence parameter set */
+   profile_idc = vl_rbsp_u(rbsp, 8);
+
+   /* constraint_set0_flag */
+   vl_rbsp_u(rbsp, 1);
+
+   /* constraint_set1_flag */
+   vl_rbsp_u(rbsp, 1);
+
+   /* constraint_set2_flag */
+   vl_rbsp_u(rbsp, 1);
+
+   /* constraint_set3_flag */
+   vl_rbsp_u(rbsp, 1);
+
+   /* constraint_set4_flag */
+   vl_rbsp_u(rbsp, 1);
+
+   /* constraint_set5_flag */
+   vl_rbsp_u(rbsp, 1);
+
+   /* reserved_zero_2bits */
+   vl_rbsp_u(rbsp, 2);
+
+   /* level_idc */
+   level_idc = vl_rbsp_u(rbsp, 8);
+
+   sps = seq_parameter_set_id(p_prc, rbsp);
+   if (!sps)
+      return;
+
+   memset(sps, 0, sizeof(*sps));
+   memset(sps->ScalingList4x4, 16, sizeof(sps->ScalingList4x4));
+   memset(sps->ScalingList8x8, 16, sizeof(sps->ScalingList8x8));
+
+   sps->level_idc = level_idc;
+
+   if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 244 ||
+       profile_idc == 44 || profile_idc == 83 || profile_idc == 86 || profile_idc == 118 ||
+       profile_idc == 128 || profile_idc == 138) {
+
+      sps->chroma_format_idc = vl_rbsp_ue(rbsp);
+
+      if (sps->chroma_format_idc == 3)
+         sps->separate_colour_plane_flag = vl_rbsp_u(rbsp, 1);
+
+      sps->bit_depth_luma_minus8 = vl_rbsp_ue(rbsp);
+
+      sps->bit_depth_chroma_minus8 = vl_rbsp_ue(rbsp);
+      /* qpprime_y_zero_transform_bypass_flag */
+      vl_rbsp_u(rbsp, 1);
+
+      sps->seq_scaling_matrix_present_flag = vl_rbsp_u(rbsp, 1);
+      if (sps->seq_scaling_matrix_present_flag) {
+
+         scaling_list (rbsp, sps->ScalingList4x4[0], 16, Default_4x4_Intra, Default_4x4_Intra);
+         scaling_list (rbsp, sps->ScalingList4x4[1], 16, Default_4x4_Intra, sps->ScalingList4x4[0]);
+         scaling_list (rbsp, sps->ScalingList4x4[2], 16, Default_4x4_Intra, sps->ScalingList4x4[1]);
+         scaling_list (rbsp, sps->ScalingList4x4[3], 16, Default_4x4_Inter, Default_4x4_Inter);
+         scaling_list (rbsp, sps->ScalingList4x4[4], 16, Default_4x4_Inter, sps->ScalingList4x4[3]);
+         scaling_list (rbsp, sps->ScalingList4x4[5], 16, Default_4x4_Inter, sps->ScalingList4x4[4]);
+
+         scaling_list (rbsp, sps->ScalingList8x8[0], 64, Default_8x8_Intra, Default_8x8_Intra);
+         scaling_list (rbsp, sps->ScalingList8x8[1], 64, Default_8x8_Inter, Default_8x8_Inter);
+         if (sps->chroma_format_idc == 3) {
+            scaling_list (rbsp, sps->ScalingList8x8[2], 64, Default_8x8_Intra, sps->ScalingList8x8[0]);
+            scaling_list (rbsp, sps->ScalingList8x8[3], 64, Default_8x8_Inter, sps->ScalingList8x8[1]);
+            scaling_list (rbsp, sps->ScalingList8x8[4], 64, Default_8x8_Intra, sps->ScalingList8x8[2]);
+            scaling_list (rbsp, sps->ScalingList8x8[5], 64, Default_8x8_Inter, sps->ScalingList8x8[3]);
+         }
+      }
+   } else if (profile_idc == 183)
+      sps->chroma_format_idc = 0;
+   else
+      sps->chroma_format_idc = 1;
+
+   sps->log2_max_frame_num_minus4 = vl_rbsp_ue(rbsp);
+
+   sps->pic_order_cnt_type = vl_rbsp_ue(rbsp);
+
+   if (sps->pic_order_cnt_type == 0)
+      sps->log2_max_pic_order_cnt_lsb_minus4 = vl_rbsp_ue(rbsp);
+   else if (sps->pic_order_cnt_type == 1) {
+      sps->delta_pic_order_always_zero_flag = vl_rbsp_u(rbsp, 1);
+
+      sps->offset_for_non_ref_pic = vl_rbsp_se(rbsp);
+
+      sps->offset_for_top_to_bottom_field = vl_rbsp_se(rbsp);
+
+      sps->num_ref_frames_in_pic_order_cnt_cycle = vl_rbsp_ue(rbsp);
+
+      for (i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; ++i)
+         sps->offset_for_ref_frame[i] = vl_rbsp_se(rbsp);
+   }
+
+   sps->max_num_ref_frames = vl_rbsp_ue(rbsp);
+
+   /* gaps_in_frame_num_value_allowed_flag */
+   vl_rbsp_u(rbsp, 1);
+
+   /* pic_width_in_mbs_minus1 */
+   int pic_width_in_samplesl = (vl_rbsp_ue(rbsp) + 1) * 16;
+   p_prc->stream_info.width = pic_width_in_samplesl;
+
+   /* pic_height_in_map_units_minus1 */
+   int pic_height_in_map_units = vl_rbsp_ue(rbsp) + 1;
+
+   sps->frame_mbs_only_flag = vl_rbsp_u(rbsp, 1);
+   if (!sps->frame_mbs_only_flag)
+      sps->mb_adaptive_frame_field_flag = vl_rbsp_u(rbsp, 1);
+
+   int frame_height_in_mbs = (2 - sps->frame_mbs_only_flag) * pic_height_in_map_units;
+   int pic_height_in_mbs = frame_height_in_mbs / ( 1 + p_prc->picture.h264.field_pic_flag );
+   int pic_height_in_samplesl = pic_height_in_mbs * 16;
+   p_prc->stream_info.height = pic_height_in_samplesl;
+
+   sps->direct_8x8_inference_flag = vl_rbsp_u(rbsp, 1);
+
+   /* frame_cropping_flag */
+   if (vl_rbsp_u(rbsp, 1)) {
+      /* frame_crop_left_offset */
+      vl_rbsp_ue(rbsp);
+
+      /* frame_crop_right_offset */
+      vl_rbsp_ue(rbsp);
+
+      /* frame_crop_top_offset */
+      vl_rbsp_ue(rbsp);
+
+      /* frame_crop_bottom_offset */
+      vl_rbsp_ue(rbsp);
+   }
+
+   /* vui_parameters_present_flag */
+   if (vl_rbsp_u(rbsp, 1))
+      vui_parameters(rbsp);
+}
+
+static OMX_ERRORTYPE update_port_parameters(h264d_prc_t * p_prc) {
+   OMX_VIDEO_PORTDEFINITIONTYPE * p_def = NULL;   /* Output port info */
+   h264d_stream_info_t * i_def = NULL; /* Info read from stream */
+
+   p_def = &(p_prc->out_port_def_.format.video);
+   i_def = &(p_prc->stream_info);
+
+   unsigned framesize = i_def->width * i_def->height;
+   p_prc->in_port_def_.format.video.nFrameWidth = i_def->width;
+   p_prc->in_port_def_.format.video.nFrameHeight = i_def->height;
+   p_prc->in_port_def_.nBufferSize = framesize * 512 / (16*16);
+
+   tiz_check_omx(tiz_krn_SetParameter_internal(
+      tiz_get_krn(handleOf(p_prc)), handleOf(p_prc),
+      OMX_IndexParamPortDefinition, &(p_prc->in_port_def_)));
+
+   tiz_srv_issue_event((OMX_PTR) p_prc, OMX_EventPortSettingsChanged,
+                        OMX_VID_DEC_AVC_INPUT_PORT_INDEX,
+                        OMX_IndexParamPortDefinition,
+                        NULL);
+
+   p_def->nFrameWidth = i_def->width;
+   p_def->nFrameHeight = i_def->height;
+   p_def->nStride = i_def->width;
+   p_def->nSliceHeight = i_def->height;
+   p_prc->out_port_def_.nBufferSize = framesize*3/2;
+
+   tiz_check_omx(tiz_krn_SetParameter_internal(
+      tiz_get_krn(handleOf(p_prc)), handleOf(p_prc),
+      OMX_IndexParamPortDefinition, &(p_prc->out_port_def_)));
+
+   tiz_srv_issue_event((OMX_PTR) p_prc, OMX_EventPortSettingsChanged,
+                        OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX,
+                        OMX_IndexParamPortDefinition,
+                        NULL);
+
+   return OMX_ErrorNone;
+}
+
+static void picture_parameter_set(h264d_prc_t *p_prc, struct vl_rbsp *rbsp)
+{
+   struct pipe_h264_sps *sps;
+   struct pipe_h264_pps *pps;
+   unsigned i;
+
+   pps = pic_parameter_set_id(p_prc, rbsp);
+   if (!pps)
+      return;
+
+   memset(pps, 0, sizeof(*pps));
+
+   sps = pps->sps = seq_parameter_set_id(p_prc, rbsp);
+   if (!sps)
+      return;
+
+   memcpy(pps->ScalingList4x4, sps->ScalingList4x4, sizeof(pps->ScalingList4x4));
+   memcpy(pps->ScalingList8x8, sps->ScalingList8x8, sizeof(pps->ScalingList8x8));
+
+   pps->entropy_coding_mode_flag = vl_rbsp_u(rbsp, 1);
+
+   pps->bottom_field_pic_order_in_frame_present_flag = vl_rbsp_u(rbsp, 1);
+
+   pps->num_slice_groups_minus1 = vl_rbsp_ue(rbsp);
+   if (pps->num_slice_groups_minus1 > 0) {
+      pps->slice_group_map_type = vl_rbsp_ue(rbsp);
+
+      if (pps->slice_group_map_type == 0) {
+
+         for (i = 0; i <= pps->num_slice_groups_minus1; ++i)
+            /* run_length_minus1[i] */
+            vl_rbsp_ue(rbsp);
+
+      } else if (pps->slice_group_map_type == 2) {
+
+         for (i = 0; i <= pps->num_slice_groups_minus1; ++i) {
+            /* top_left[i] */
+            vl_rbsp_ue(rbsp);
+
+            /* bottom_right[i] */
+            vl_rbsp_ue(rbsp);
+         }
+
+      } else if (pps->slice_group_map_type >= 3 && pps->slice_group_map_type <= 5) {
+
+         /* slice_group_change_direction_flag */
+         vl_rbsp_u(rbsp, 1);
+
+         pps->slice_group_change_rate_minus1 = vl_rbsp_ue(rbsp);
+
+      } else if (pps->slice_group_map_type == 6) {
+
+         unsigned pic_size_in_map_units_minus1;
+
+         pic_size_in_map_units_minus1 = vl_rbsp_ue(rbsp);
+
+         for (i = 0; i <= pic_size_in_map_units_minus1; ++i)
+            /* slice_group_id[i] */
+            vl_rbsp_u(rbsp, log2(pps->num_slice_groups_minus1 + 1));
+      }
+   }
+
+   pps->num_ref_idx_l0_default_active_minus1 = vl_rbsp_ue(rbsp);
+
+   pps->num_ref_idx_l1_default_active_minus1 = vl_rbsp_ue(rbsp);
+
+   pps->weighted_pred_flag = vl_rbsp_u(rbsp, 1);
+
+   pps->weighted_bipred_idc = vl_rbsp_u(rbsp, 2);
+
+   pps->pic_init_qp_minus26 = vl_rbsp_se(rbsp);
+
+   /* pic_init_qs_minus26 */
+   vl_rbsp_se(rbsp);
+
+   pps->chroma_qp_index_offset = vl_rbsp_se(rbsp);
+
+   pps->deblocking_filter_control_present_flag = vl_rbsp_u(rbsp, 1);
+
+   pps->constrained_intra_pred_flag = vl_rbsp_u(rbsp, 1);
+
+   pps->redundant_pic_cnt_present_flag = vl_rbsp_u(rbsp, 1);
+
+   if (vl_rbsp_more_data(rbsp)) {
+      pps->transform_8x8_mode_flag = vl_rbsp_u(rbsp, 1);
+
+      /* pic_scaling_matrix_present_flag */
+      if (vl_rbsp_u(rbsp, 1)) {
+
+         scaling_list(rbsp, pps->ScalingList4x4[0], 16, Default_4x4_Intra,
+                      sps->seq_scaling_matrix_present_flag ? NULL : Default_4x4_Intra);
+         scaling_list(rbsp, pps->ScalingList4x4[1], 16, Default_4x4_Intra, pps->ScalingList4x4[0]);
+         scaling_list(rbsp, pps->ScalingList4x4[2], 16, Default_4x4_Intra, pps->ScalingList4x4[1]);
+         scaling_list(rbsp, pps->ScalingList4x4[3], 16, Default_4x4_Inter,
+                      sps->seq_scaling_matrix_present_flag ? NULL : Default_4x4_Inter);
+         scaling_list(rbsp, pps->ScalingList4x4[4], 16, Default_4x4_Inter, pps->ScalingList4x4[3]);
+         scaling_list(rbsp, pps->ScalingList4x4[5], 16, Default_4x4_Inter, pps->ScalingList4x4[4]);
+
+         if (pps->transform_8x8_mode_flag) {
+            scaling_list(rbsp, pps->ScalingList8x8[0], 64, Default_8x8_Intra,
+                         sps->seq_scaling_matrix_present_flag ? NULL : Default_8x8_Intra);
+            scaling_list(rbsp, pps->ScalingList8x8[1], 64, Default_8x8_Inter,
+                         sps->seq_scaling_matrix_present_flag ? NULL :  Default_8x8_Inter);
+            if (sps->chroma_format_idc == 3) {
+               scaling_list(rbsp, pps->ScalingList8x8[2], 64, Default_8x8_Intra, pps->ScalingList8x8[0]);
+               scaling_list(rbsp, pps->ScalingList8x8[3], 64, Default_8x8_Inter, pps->ScalingList8x8[1]);
+               scaling_list(rbsp, pps->ScalingList8x8[4], 64, Default_8x8_Intra, pps->ScalingList8x8[2]);
+               scaling_list(rbsp, pps->ScalingList8x8[5], 64, Default_8x8_Inter, pps->ScalingList8x8[3]);
+            }
+         }
+      }
+
+      pps->second_chroma_qp_index_offset = vl_rbsp_se(rbsp);
+   }
+}
+
+static void ref_pic_list_mvc_modification(h264d_prc_t *p_prc, struct vl_rbsp *rbsp)
+{
+   // TODO
+   assert (0);
+}
+
+static void ref_pic_list_modification(h264d_prc_t *p_prc, struct vl_rbsp *rbsp,
+                                      enum pipe_h264_slice_type slice_type)
+{
+   unsigned modification_of_pic_nums_idc;
+
+   if (slice_type != 2 && slice_type != 4) {
+      /* ref_pic_list_modification_flag_l0 */
+      if (vl_rbsp_u(rbsp, 1)) {
+         do {
+            modification_of_pic_nums_idc = vl_rbsp_ue(rbsp);
+            if (modification_of_pic_nums_idc == 0 ||
+                modification_of_pic_nums_idc == 1)
+               /* abs_diff_pic_num_minus1 */
+               vl_rbsp_ue(rbsp);
+            else if (modification_of_pic_nums_idc == 2)
+               /* long_term_pic_num */
+               vl_rbsp_ue(rbsp);
+         } while (modification_of_pic_nums_idc != 3);
+      }
+   }
+
+   if (slice_type == 1) {
+      /* ref_pic_list_modification_flag_l1 */
+      if (vl_rbsp_u(rbsp, 1)) {
+         do {
+            modification_of_pic_nums_idc = vl_rbsp_ue(rbsp);
+            if (modification_of_pic_nums_idc == 0 ||
+                modification_of_pic_nums_idc == 1)
+               /* abs_diff_pic_num_minus1 */
+               vl_rbsp_ue(rbsp);
+            else if (modification_of_pic_nums_idc == 2)
+               /* long_term_pic_num */
+               vl_rbsp_ue(rbsp);
+         } while (modification_of_pic_nums_idc != 3);
+      }
+   }
+}
+
+static void pred_weight_table (h264d_prc_t *p_prc, struct vl_rbsp *rbsp,
+                              struct pipe_h264_sps *sps, enum pipe_h264_slice_type slice_type)
+{
+   unsigned ChromaArrayType = sps->separate_colour_plane_flag ? 0 : sps->chroma_format_idc;
+   unsigned i, j;
+
+   /* luma_log2_weight_denom */
+   vl_rbsp_ue(rbsp);
+
+   if (ChromaArrayType != 0)
+      /* chroma_log2_weight_denom */
+      vl_rbsp_ue(rbsp);
+
+   for (i = 0; i <= p_prc->picture.h264.num_ref_idx_l0_active_minus1; ++i) {
+      /* luma_weight_l0_flag */
+      if (vl_rbsp_u(rbsp, 1)) {
+         /* luma_weight_l0[i] */
+         vl_rbsp_se(rbsp);
+         /* luma_offset_l0[i] */
+         vl_rbsp_se(rbsp);
+      }
+      if (ChromaArrayType != 0) {
+         /* chroma_weight_l0_flag */
+         if (vl_rbsp_u(rbsp, 1)) {
+            for (j = 0; j < 2; ++j) {
+               /* chroma_weight_l0[i][j] */
+               vl_rbsp_se(rbsp);
+               /* chroma_offset_l0[i][j] */
+               vl_rbsp_se(rbsp);
+            }
+         }
+      }
+   }
+
+   if (slice_type == 1) {
+      for (i = 0; i <= p_prc->picture.h264.num_ref_idx_l1_active_minus1; ++i) {
+         /* luma_weight_l1_flag */
+         if (vl_rbsp_u(rbsp, 1)) {
+            /* luma_weight_l1[i] */
+            vl_rbsp_se(rbsp);
+            /* luma_offset_l1[i] */
+            vl_rbsp_se(rbsp);
+         }
+         if (ChromaArrayType != 0) {
+            /* chroma_weight_l1_flag */
+            if (vl_rbsp_u(rbsp, 1)) {
+               for (j = 0; j < 2; ++j) {
+                  /* chroma_weight_l1[i][j] */
+                  vl_rbsp_se(rbsp);
+                  /* chroma_offset_l1[i][j] */
+                  vl_rbsp_se(rbsp);
+               }
+            }
+         }
+      }
+   }
+}
+
+static void dec_ref_pic_marking(h264d_prc_t *p_prc, struct vl_rbsp *rbsp,
+                                bool IdrPicFlag)
+{
+   unsigned memory_management_control_operation;
+
+   if (IdrPicFlag) {
+      /* no_output_of_prior_pics_flag */
+      vl_rbsp_u(rbsp, 1);
+      /* long_term_reference_flag */
+      vl_rbsp_u(rbsp, 1);
+   } else {
+      /* adaptive_ref_pic_marking_mode_flag */
+      if (vl_rbsp_u(rbsp, 1)) {
+         do {
+            memory_management_control_operation = vl_rbsp_ue(rbsp);
+
+            if (memory_management_control_operation == 1 ||
+                memory_management_control_operation == 3)
+               /* difference_of_pic_nums_minus1 */
+               vl_rbsp_ue(rbsp);
+
+            if (memory_management_control_operation == 2)
+               /* long_term_pic_num */
+               vl_rbsp_ue(rbsp);
+
+            if (memory_management_control_operation == 3 ||
+                memory_management_control_operation == 6)
+               /* long_term_frame_idx */
+               vl_rbsp_ue(rbsp);
+
+            if (memory_management_control_operation == 4)
+               /* max_long_term_frame_idx_plus1 */
+               vl_rbsp_ue(rbsp);
+         } while (memory_management_control_operation != 0);
+      }
+   }
+}
+
+static void slice_header(h264d_prc_t *p_prc, struct vl_rbsp *rbsp,
+                         unsigned nal_ref_idc, unsigned nal_unit_type)
+{
+   enum pipe_h264_slice_type slice_type;
+   struct pipe_h264_pps *pps;
+   struct pipe_h264_sps *sps;
+   unsigned frame_num, prevFrameNum;
+   bool IdrPicFlag = nal_unit_type == 5;
+
+   if (IdrPicFlag != p_prc->codec_data.IdrPicFlag)
+      h264d_end_frame(p_prc);
+
+   p_prc->codec_data.IdrPicFlag = IdrPicFlag;
+
+   /* first_mb_in_slice */
+   vl_rbsp_ue(rbsp);
+
+   slice_type = vl_rbsp_ue(rbsp) % 5;
+
+   /* get picture parameter set */
+   pps = pic_parameter_set_id(p_prc, rbsp);
+   if (!pps)
+      return;
+
+   /* get sequence parameter set */
+   sps = pps->sps;
+   if (!sps)
+      return;
+
+   if (pps != p_prc->picture.h264.pps)
+      h264d_end_frame(p_prc);
+
+   p_prc->picture.h264.pps = pps;
+
+   if (sps->separate_colour_plane_flag == 1 )
+      /* colour_plane_id */
+      vl_rbsp_u(rbsp, 2);
+
+   /* frame number handling */
+   frame_num = vl_rbsp_u(rbsp, sps->log2_max_frame_num_minus4 + 4);
+
+   if (frame_num != p_prc->picture.h264.frame_num)
+      h264d_end_frame(p_prc);
+
+   prevFrameNum = p_prc->picture.h264.frame_num;
+   p_prc->picture.h264.frame_num = frame_num;
+
+   p_prc->picture.h264.field_pic_flag = 0;
+   p_prc->picture.h264.bottom_field_flag = 0;
+
+   if (!sps->frame_mbs_only_flag) {
+      unsigned field_pic_flag = vl_rbsp_u(rbsp, 1);
+
+      if (!field_pic_flag && field_pic_flag != p_prc->picture.h264.field_pic_flag)
+         h264d_end_frame(p_prc);
+
+      p_prc->picture.h264.field_pic_flag = field_pic_flag;
+
+      if (p_prc->picture.h264.field_pic_flag) {
+         unsigned bottom_field_flag = vl_rbsp_u(rbsp, 1);
+
+         if (bottom_field_flag != p_prc->picture.h264.bottom_field_flag)
+            h264d_end_frame(p_prc);
+
+         p_prc->picture.h264.bottom_field_flag = bottom_field_flag;
+      }
+   }
+
+   if (IdrPicFlag) {
+      /* set idr_pic_id */
+      unsigned idr_pic_id = vl_rbsp_ue(rbsp);
+
+      if (idr_pic_id != p_prc->codec_data.idr_pic_id)
+         h264d_end_frame(p_prc);
+
+      p_prc->codec_data.idr_pic_id = idr_pic_id;
+   }
+
+   if (sps->pic_order_cnt_type == 0) {
+      /* pic_order_cnt_lsb */
+      unsigned log2_max_pic_order_cnt_lsb = sps->log2_max_pic_order_cnt_lsb_minus4 + 4;
+      unsigned max_pic_order_cnt_lsb = 1 << log2_max_pic_order_cnt_lsb;
+      int pic_order_cnt_lsb = vl_rbsp_u(rbsp, log2_max_pic_order_cnt_lsb);
+      int pic_order_cnt_msb;
+
+      if (pic_order_cnt_lsb != p_prc->codec_data.pic_order_cnt_lsb)
+         h264d_end_frame(p_prc);
+
+      if (IdrPicFlag) {
+         p_prc->codec_data.pic_order_cnt_msb = 0;
+         p_prc->codec_data.pic_order_cnt_lsb = 0;
+      }
+
+      if ((pic_order_cnt_lsb < p_prc->codec_data.pic_order_cnt_lsb) &&
+          (p_prc->codec_data.pic_order_cnt_lsb - pic_order_cnt_lsb) >= (max_pic_order_cnt_lsb / 2))
+         pic_order_cnt_msb = p_prc->codec_data.pic_order_cnt_msb + max_pic_order_cnt_lsb;
+
+      else if ((pic_order_cnt_lsb > p_prc->codec_data.pic_order_cnt_lsb) &&
+          (pic_order_cnt_lsb - p_prc->codec_data.pic_order_cnt_lsb) > (max_pic_order_cnt_lsb / 2))
+         pic_order_cnt_msb = p_prc->codec_data.pic_order_cnt_msb - max_pic_order_cnt_lsb;
+
+      else
+         pic_order_cnt_msb = p_prc->codec_data.pic_order_cnt_msb;
+
+      p_prc->codec_data.pic_order_cnt_msb = pic_order_cnt_msb;
+      p_prc->codec_data.pic_order_cnt_lsb = pic_order_cnt_lsb;
+
+      if (pps->bottom_field_pic_order_in_frame_present_flag && !p_prc->picture.h264.field_pic_flag) {
+         /* delta_pic_oreder_cnt_bottom */
+         unsigned delta_pic_order_cnt_bottom = vl_rbsp_se(rbsp);
+
+         if (delta_pic_order_cnt_bottom != p_prc->codec_data.delta_pic_order_cnt_bottom)
+            h264d_end_frame(p_prc);
+
+         p_prc->codec_data.delta_pic_order_cnt_bottom = delta_pic_order_cnt_bottom;
+      }
+
+      if (!p_prc->picture.h264.field_pic_flag) {
+         p_prc->picture.h264.field_order_cnt[0] = pic_order_cnt_msb + pic_order_cnt_lsb; /* (8-4) */
+         p_prc->picture.h264.field_order_cnt[1] = p_prc->picture.h264.field_order_cnt [0] +
+                                        p_prc->codec_data.delta_pic_order_cnt_bottom;
+      } else if (!p_prc->picture.h264.bottom_field_flag)
+         p_prc->picture.h264.field_order_cnt[0] = pic_order_cnt_msb + pic_order_cnt_lsb;
+      else
+         p_prc->picture.h264.field_order_cnt[1] = pic_order_cnt_msb + pic_order_cnt_lsb;
+
+   } else if (sps->pic_order_cnt_type == 1) {
+      /* delta_pic_order_cnt[0] */
+      unsigned MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
+      unsigned FrameNumOffset, absFrameNum, expectedPicOrderCnt;
+
+      if (!sps->delta_pic_order_always_zero_flag) {
+         unsigned delta_pic_order_cnt[2];
+
+         delta_pic_order_cnt[0] = vl_rbsp_se(rbsp);
+
+         if (delta_pic_order_cnt[0] != p_prc->codec_data.delta_pic_order_cnt[0])
+            h264d_end_frame(p_prc);
+
+         p_prc->codec_data.delta_pic_order_cnt[0] = delta_pic_order_cnt[0];
+
+         if (pps->bottom_field_pic_order_in_frame_present_flag && !p_prc->picture.h264.field_pic_flag) {
+            /* delta_pic_order_cnt[1] */
+            delta_pic_order_cnt[1] = vl_rbsp_se(rbsp);
+
+            if (delta_pic_order_cnt[1] != p_prc->codec_data.delta_pic_order_cnt[1])
+               h264d_end_frame(p_prc);
+
+            p_prc->codec_data.delta_pic_order_cnt[1] = delta_pic_order_cnt[1];
+         }
+      }
+
+      if (IdrPicFlag)
+         FrameNumOffset = 0;
+      else if (prevFrameNum > frame_num)
+         FrameNumOffset = p_prc->codec_data.prevFrameNumOffset + MaxFrameNum;
+      else
+         FrameNumOffset = p_prc->codec_data.prevFrameNumOffset;
+
+      p_prc->codec_data.prevFrameNumOffset = FrameNumOffset;
+
+      if (sps->num_ref_frames_in_pic_order_cnt_cycle != 0)
+         absFrameNum = FrameNumOffset + frame_num;
+      else
+         absFrameNum = 0;
+
+      if (nal_ref_idc == 0 && absFrameNum > 0)
+         absFrameNum = absFrameNum - 1;
+
+      if (absFrameNum > 0) {
+         unsigned picOrderCntCycleCnt = (absFrameNum - 1) / sps->num_ref_frames_in_pic_order_cnt_cycle;
+         unsigned frameNumInPicOrderCntCycle = (absFrameNum - 1) % sps->num_ref_frames_in_pic_order_cnt_cycle;
+         signed ExpectedDeltaPerPicOrderCntCycle = 0;
+         unsigned i;
+
+         for(i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; ++i)
+            ExpectedDeltaPerPicOrderCntCycle += sps->offset_for_ref_frame[i];
+
+         expectedPicOrderCnt = picOrderCntCycleCnt * ExpectedDeltaPerPicOrderCntCycle;
+         for(i = 0; i <= frameNumInPicOrderCntCycle; ++i)
+            expectedPicOrderCnt += sps->offset_for_ref_frame[i];
+
+      } else
+         expectedPicOrderCnt = 0;
+
+      if (nal_ref_idc == 0)
+         expectedPicOrderCnt += sps->offset_for_non_ref_pic;
+
+      if (!p_prc->picture.h264.field_pic_flag) {
+         p_prc->picture.h264.field_order_cnt[0] = expectedPicOrderCnt + p_prc->codec_data.delta_pic_order_cnt[0];
+         p_prc->picture.h264.field_order_cnt[1] = p_prc->picture.h264.field_order_cnt[0] +
+            sps->offset_for_top_to_bottom_field + p_prc->codec_data.delta_pic_order_cnt[1];
+
+      } else if (!p_prc->picture.h264.bottom_field_flag)
+         p_prc->picture.h264.field_order_cnt[0] = expectedPicOrderCnt + p_prc->codec_data.delta_pic_order_cnt[0];
+      else
+         p_prc->picture.h264.field_order_cnt[1] = expectedPicOrderCnt + sps->offset_for_top_to_bottom_field +
+            p_prc->codec_data.delta_pic_order_cnt[0];
+
+   } else if (sps->pic_order_cnt_type == 2) {   /* 8.2.1.3 */
+      unsigned MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
+      unsigned FrameNumOffset, tempPicOrderCnt;
+
+      if (IdrPicFlag)
+         FrameNumOffset = 0;
+      else if (prevFrameNum > frame_num)
+         FrameNumOffset = p_prc->codec_data.prevFrameNumOffset + MaxFrameNum;
+      else
+         FrameNumOffset = p_prc->codec_data.prevFrameNumOffset;
+
+      p_prc->codec_data.prevFrameNumOffset = FrameNumOffset;
+
+      if (IdrPicFlag)
+         tempPicOrderCnt = 0;
+      else if (nal_ref_idc == 0)
+         tempPicOrderCnt = 2 * (FrameNumOffset + frame_num) - 1;
+      else
+         tempPicOrderCnt = 2 * (FrameNumOffset + frame_num);
+
+      if (!p_prc->picture.h264.field_pic_flag) {
+         p_prc->picture.h264.field_order_cnt[0] = tempPicOrderCnt;
+         p_prc->picture.h264.field_order_cnt[1] = tempPicOrderCnt;
+
+      } else if (!p_prc->picture.h264.bottom_field_flag) /* negation not in specs */
+         p_prc->picture.h264.field_order_cnt[0] = tempPicOrderCnt;
+      else
+         p_prc->picture.h264.field_order_cnt[1] = tempPicOrderCnt;
+   }
+
+   if (pps->redundant_pic_cnt_present_flag)
+      /* redundant_pic_cnt */
+      vl_rbsp_ue(rbsp);
+
+   if (slice_type == PIPE_H264_SLICE_TYPE_B)
+      /* direct_spatial_mv_pred_flag */
+      vl_rbsp_u(rbsp, 1);
+
+   p_prc->picture.h264.num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1;
+   p_prc->picture.h264.num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1;
+
+   if (slice_type == PIPE_H264_SLICE_TYPE_P ||
+       slice_type == PIPE_H264_SLICE_TYPE_SP ||
+       slice_type == PIPE_H264_SLICE_TYPE_B) {
+
+      /* num_ref_idx_active_override_flag */
+      if (vl_rbsp_u (rbsp, 1)) {
+         p_prc->picture.h264.num_ref_idx_l0_active_minus1 = vl_rbsp_ue(rbsp);
+
+         if (slice_type == PIPE_H264_SLICE_TYPE_B)
+            p_prc->picture.h264.num_ref_idx_l1_active_minus1 = vl_rbsp_ue(rbsp);
+      }
+   }
+
+   if (nal_unit_type == 20 || nal_unit_type == 21)
+      ref_pic_list_mvc_modification(p_prc, rbsp);
+   else
+      ref_pic_list_modification(p_prc, rbsp, slice_type);
+
+   if ((pps->weighted_pred_flag && (slice_type == PIPE_H264_SLICE_TYPE_P || slice_type == PIPE_H264_SLICE_TYPE_SP)) ||
+       (pps->weighted_bipred_idc == 1 && slice_type == PIPE_H264_SLICE_TYPE_B))
+      pred_weight_table(p_prc, rbsp, sps, slice_type);
+
+   if (nal_ref_idc != 0)
+      dec_ref_pic_marking(p_prc, rbsp, IdrPicFlag);
+
+   if (pps->entropy_coding_mode_flag && slice_type != PIPE_H264_SLICE_TYPE_I && slice_type != PIPE_H264_SLICE_TYPE_SI)
+      /* cabac_init_idc */
+      vl_rbsp_ue(rbsp);
+
+   /* slice_qp_delta */
+   vl_rbsp_se(rbsp);
+
+   if (slice_type == PIPE_H264_SLICE_TYPE_SP || slice_type == PIPE_H264_SLICE_TYPE_SI) {
+      if (slice_type == PIPE_H264_SLICE_TYPE_SP)
+         /* sp_for_switch_flag */
+         vl_rbsp_u(rbsp, 1);
+
+      /*slice_qs_delta */
+      vl_rbsp_se(rbsp);
+   }
+
+   if (pps->deblocking_filter_control_present_flag) {
+      unsigned disable_deblocking_filter_idc = vl_rbsp_ue(rbsp);
+
+      if (disable_deblocking_filter_idc != 1) {
+         /* slice_alpha_c0_offset_div2 */
+         vl_rbsp_se(rbsp);
+
+         /* slice_beta_offset_div2 */
+         vl_rbsp_se(rbsp);
+      }
+   }
+
+   if (pps->num_slice_groups_minus1 > 0 && pps->slice_group_map_type >= 3 && pps->slice_group_map_type <= 5)
+      /* slice_group_change_cycle */
+      vl_rbsp_u(rbsp, 2);
+}
+
+static void h264d_need_target(h264d_prc_t *p_prc)
+{
+   struct pipe_video_buffer templat = {};
+   struct vl_screen *omx_screen;
+   struct pipe_screen *pscreen;
+
+   omx_screen = p_prc->screen;
+   assert(omx_screen);
+
+   pscreen = omx_screen->pscreen;
+   assert(pscreen);
+
+   if (!p_prc->target) {
+      memset(&templat, 0, sizeof(templat));
+
+      templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
+      templat.width = p_prc->codec->width;
+      templat.height = p_prc->codec->height;
+      templat.buffer_format = pscreen->get_video_param(
+            pscreen,
+            PIPE_VIDEO_PROFILE_UNKNOWN,
+            PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
+            PIPE_VIDEO_CAP_PREFERED_FORMAT
+      );
+      templat.interlaced = pscreen->get_video_param(
+          pscreen,
+          PIPE_VIDEO_PROFILE_UNKNOWN,
+          PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
+          PIPE_VIDEO_CAP_PREFERS_INTERLACED
+      );
+
+      p_prc->target = p_prc->pipe->create_video_buffer(p_prc->pipe, &templat);
+   }
+}
+
+static void h264d_begin_frame(h264d_prc_t *p_prc)
+{
+   //TODO: sane buffer handling
+
+   if (p_prc->frame_started)
+      return;
+
+   /* Set codec if not already set */
+   if (!p_prc->codec) {
+      struct pipe_video_codec templat = {};
+      tiz_port_t * port;  //Possibly a better way to do this exists
+      port = tiz_krn_get_port(tiz_get_krn(handleOf(p_prc)), OMX_VID_DEC_AVC_INPUT_PORT_INDEX);
+
+      templat.profile = p_prc->profile;
+      templat.entrypoint = PIPE_VIDEO_ENTRYPOINT_BITSTREAM;
+      templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
+      templat.max_references = p_prc->picture.h264.num_ref_frames;
+      templat.expect_chunked_decode = true;
+      templat.width = port->portdef_.format.video.nFrameWidth;
+      templat.height = port->portdef_.format.video.nFrameHeight;
+      templat.level = p_prc->picture.h264.pps->sps->level_idc;
+
+      p_prc->codec = p_prc->pipe->create_video_codec(p_prc->pipe, &templat);
+   }
+
+   /* Set target screen */
+   h264d_need_target(p_prc);
+
+   if (p_prc->first_buf_in_frame)
+      p_prc->timestamp = p_prc->timestamps[0];
+   p_prc->first_buf_in_frame = false;
+
+   p_prc->picture.h264.num_ref_frames = p_prc->picture.h264.pps->sps->max_num_ref_frames;
+
+   p_prc->picture.h264.slice_count = 0;
+   p_prc->codec->begin_frame(p_prc->codec, p_prc->target, &p_prc->picture.base);
+   p_prc->frame_started = true;
+}
+
+static void decode_buffer(h264d_prc_t *p_prc, struct vl_vlc *vlc, unsigned min_bits_left)
+{
+   unsigned nal_ref_idc, nal_unit_type;
+
+   if (!vl_vlc_search_byte(vlc, vl_vlc_bits_left(vlc) - min_bits_left, 0x00))
+      return;
+
+   if (vl_vlc_peekbits(vlc, 24) != 0x000001) {
+      vl_vlc_eatbits(vlc, 8);
+      return;
+   }
+
+   if (p_prc->slice) {
+      unsigned bytes = p_prc->bytes_left - (vl_vlc_bits_left (vlc) / 8);
+      ++p_prc->picture.h264.slice_count;
+      p_prc->codec->decode_bitstream(p_prc->codec, p_prc->target, &p_prc->picture.base,
+                                    1, &p_prc->slice, &bytes);
+      p_prc->slice = NULL;
+   }
+
+   vl_vlc_eatbits(vlc, 24);
+
+   /* forbidden_zero_bit */
+   vl_vlc_eatbits(vlc, 1);
+
+   nal_ref_idc = vl_vlc_get_uimsbf(vlc, 2);
+
+   if (nal_ref_idc != p_prc->codec_data.nal_ref_idc &&
+       (nal_ref_idc * p_prc->codec_data.nal_ref_idc) == 0)
+      h264d_end_frame(p_prc);
+
+   p_prc->codec_data.nal_ref_idc = nal_ref_idc;
+
+   nal_unit_type = vl_vlc_get_uimsbf(vlc, 5);
+
+   if (nal_unit_type != 1 && nal_unit_type != 5)
+      h264d_end_frame(p_prc);
+
+   if (nal_unit_type == 7) {
+      struct vl_rbsp rbsp;
+      vl_rbsp_init(&rbsp, vlc, ~0);
+      seq_parameter_set(p_prc, &rbsp);
+      update_port_parameters(p_prc);
+
+   } else if (nal_unit_type == 8) {
+      struct vl_rbsp rbsp;
+      vl_rbsp_init(&rbsp, vlc, ~0);
+      picture_parameter_set(p_prc, &rbsp);
+
+   } else if (nal_unit_type == 1 || nal_unit_type == 5) {
+      /* Coded slice of a non-IDR or IDR picture */
+      unsigned bits = vl_vlc_valid_bits(vlc);
+      unsigned bytes = bits / 8 + 4;
+      struct vl_rbsp rbsp;
+      uint8_t buf[8];
+      const void *ptr = buf;
+      unsigned i;
+
+      buf[0] = 0x0;
+      buf[1] = 0x0;
+      buf[2] = 0x1;
+      buf[3] = (nal_ref_idc << 5) | nal_unit_type;
+      for (i = 4; i < bytes; ++i)
+         buf[i] = vl_vlc_peekbits(vlc, bits) >> ((bytes - i - 1) * 8);
+
+      p_prc->bytes_left = (vl_vlc_bits_left(vlc) - bits) / 8;
+      p_prc->slice = vlc->data;
+
+      vl_rbsp_init(&rbsp, vlc, 128);
+      slice_header(p_prc, &rbsp, nal_ref_idc, nal_unit_type);
+
+      h264d_begin_frame(p_prc);
+
+      ++p_prc->picture.h264.slice_count;
+      p_prc->codec->decode_bitstream(p_prc->codec, p_prc->target, &p_prc->picture.base,
+                                    1, &ptr, &bytes);
+   }
+
+   /* resync to byte boundary */
+   vl_vlc_eatbits(vlc, vl_vlc_valid_bits(vlc) % 8);
+}
+
+static void reset_stream_parameters(h264d_prc_t * ap_prc)
+{
+   assert(ap_prc);
+   TIZ_INIT_OMX_PORT_STRUCT(ap_prc->in_port_def_,
+                            OMX_VID_DEC_AVC_INPUT_PORT_INDEX);
+   TIZ_INIT_OMX_PORT_STRUCT(ap_prc->out_port_def_,
+                            OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX);
+   ap_prc->p_inhdr_ = 0;
+   ap_prc->num_in_buffers = 0;
+   ap_prc->first_buf_in_frame = true;
+   ap_prc->eos_ = false;
+   ap_prc->frame_finished = false;
+   ap_prc->frame_started = false;
+   ap_prc->picture.h264.field_order_cnt[0] = ap_prc->picture.h264.field_order_cnt[1] = INT_MAX;
+}
+
+static void h264d_deint(h264d_prc_t *p_prc, struct pipe_video_buffer *src_buf,
+                        struct pipe_video_buffer *dst_buf)
+{
+   struct vl_compositor *compositor = &p_prc->compositor;
+   struct vl_compositor_state *s = &p_prc->cstate;
+   struct pipe_surface **dst_surface;
+   struct u_rect dst_rect;
+
+   dst_surface = dst_buf->get_surfaces(dst_buf);
+   vl_compositor_clear_layers(s);
+
+   dst_rect.x0 = 0;
+   dst_rect.x1 = src_buf->width;
+   dst_rect.y0 = 0;
+   dst_rect.y1 = src_buf->height;
+
+   vl_compositor_set_yuv_layer(s, compositor, 0, src_buf, NULL, NULL, true);
+   vl_compositor_set_layer_dst_area(s, 0, &dst_rect);
+   vl_compositor_render(s, compositor, dst_surface[0], NULL, false);
+
+   dst_rect.x1 /= 2;
+   dst_rect.y1 /= 2;
+
+   vl_compositor_set_yuv_layer(s, compositor, 0, src_buf, NULL, NULL, false);
+   vl_compositor_set_layer_dst_area(s, 0, &dst_rect);
+   vl_compositor_render(s, compositor, dst_surface[1], NULL, false);
+}
+
+static void h264d_fill_output(h264d_prc_t *p_prc, struct pipe_video_buffer *buf,
+                              OMX_BUFFERHEADERTYPE* output)
+{
+   tiz_port_t *port = tiz_krn_get_port(tiz_get_krn(handleOf(p_prc)), OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX);
+   OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->portdef_.format.video;
+
+   struct pipe_sampler_view **views;
+   unsigned i, j;
+   unsigned width, height;
+
+   views = buf->get_sampler_view_planes(buf);
+
+   for (i = 0; i < 2 /* NV12 */; i++) {
+      if (!views[i]) continue;
+      width = def->nFrameWidth;
+      height = def->nFrameHeight;
+      vl_video_buffer_adjust_size(&width, &height, i, buf->chroma_format, buf->interlaced);
+      for (j = 0; j < views[i]->texture->array_size; ++j) {
+         struct pipe_box box = {0, 0, j, width, height, 1};
+         struct pipe_transfer *transfer;
+         uint8_t *map, *dst;
+         map = p_prc->pipe->transfer_map(p_prc->pipe, views[i]->texture, 0,
+                  PIPE_TRANSFER_READ, &box, &transfer);
+         if (!map)
+            return;
+
+         dst = ((uint8_t*)output->pBuffer + output->nOffset) + j * def->nStride +
+               i * def->nFrameWidth * def->nFrameHeight;
+         util_copy_rect(dst,
+            views[i]->texture->format,
+            def->nStride * views[i]->texture->array_size, 0, 0,
+            box.width, box.height, map, transfer->stride, 0, 0);
+
+         pipe_transfer_unmap(p_prc->pipe, transfer);
+      }
+   }
+}
+
+static void h264d_frame_decoded(h264d_prc_t *p_prc, OMX_BUFFERHEADERTYPE* input,
+                                OMX_BUFFERHEADERTYPE* output)
+{
+   OMX_TICKS timestamp;
+
+   if (!input->pInputPortPrivate) {
+      input->pInputPortPrivate = h264d_flush(p_prc, &timestamp);
+      if (timestamp != OMX_VID_DEC_AVC_TIMESTAMP_INVALID)
+         input->nTimeStamp = timestamp;
+   }
+
+   if (input->pInputPortPrivate) {
+      if (output->pInputPortPrivate && !p_prc->disable_tunnel) {
+         struct pipe_video_buffer *tmp, *vbuf, *new_vbuf;
+
+         tmp = output->pOutputPortPrivate;
+         vbuf = input->pInputPortPrivate;
+         if (vbuf->interlaced) {
+            /* re-allocate the progressive buffer */
+            tiz_port_t *port;
+            struct pipe_video_buffer templat = {};
+
+            port = tiz_krn_get_port(tiz_get_krn(handleOf (p_prc)), OMX_VID_DEC_AVC_INPUT_PORT_INDEX);
+            memset(&templat, 0, sizeof(templat));
+            templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
+            templat.width = port->portdef_.format.video.nFrameWidth;
+            templat.height = port->portdef_.format.video.nFrameHeight;
+            templat.buffer_format = PIPE_FORMAT_NV12;
+            templat.interlaced = false;
+            new_vbuf = p_prc->pipe->create_video_buffer(p_prc->pipe, &templat);
+
+            /* convert the interlaced to the progressive */
+            h264d_deint(p_prc, input->pInputPortPrivate, new_vbuf);
+            p_prc->pipe->flush(p_prc->pipe, NULL, 0);
+
+            /* set the progrssive buffer for next round */
+            vbuf->destroy(vbuf);
+            input->pInputPortPrivate = new_vbuf;
+         }
+         output->pOutputPortPrivate = input->pInputPortPrivate;
+         input->pInputPortPrivate = tmp;
+      } else {
+         h264d_fill_output(p_prc, input->pInputPortPrivate, output);
+      }
+      output->nFilledLen = output->nAllocLen;
+      output->nTimeStamp = input->nTimeStamp;
+   }
+
+   if (p_prc->eos_ && input->pInputPortPrivate)
+      h264d_free_input_port_private(input);
+   else
+      input->nFilledLen = 0;
+}
+
+/* Replacement for bellagio's omx_base_filter_BufferMgmtFunction */
+static void h264d_manage_buffers(h264d_prc_t* p_prc) {
+   bool next_is_eos = p_prc->num_in_buffers == 2 ? !!(p_prc->in_buffers[1]->nFlags & OMX_BUFFERFLAG_EOS) : false;
+   h264d_frame_decoded(p_prc, p_prc->in_buffers[0], p_prc->p_outhdr_);
+
+   p_prc->p_outhdr_->nTimeStamp = p_prc->in_buffers[0]->nTimeStamp;
+
+   /* Realase output buffer if filled or eos
+      Keep if two input buffers are being decoded */
+   if ((!next_is_eos) && ((p_prc->p_outhdr_->nFilledLen > 0) || p_prc->eos_)) {
+      h264d_buffer_filled(p_prc, p_prc->p_outhdr_);
+   }
+
+   /* Release input buffer if possible */
+   if (p_prc->in_buffers[0]->nFilledLen == 0) {
+      h264d_buffer_emptied(p_prc, p_prc->in_buffers[0]);
+   }
+}
+
+static OMX_ERRORTYPE decode_frame(h264d_prc_t *p_prc,
+                                  OMX_BUFFERHEADERTYPE *in_buf)
+{
+   unsigned i = p_prc->num_in_buffers++;
+   p_prc->in_buffers[i] = in_buf;
+   p_prc->sizes[i] = in_buf->nFilledLen;
+   p_prc->inputs[i] = in_buf->pBuffer;
+   p_prc->timestamps[i] = in_buf->nTimeStamp;
+
+   while (p_prc->num_in_buffers > (!!(in_buf->nFlags & OMX_BUFFERFLAG_EOS) ? 0 : 1)) {
+      p_prc->eos_ = !!(p_prc->in_buffers[0]->nFlags & OMX_BUFFERFLAG_EOS);
+      unsigned min_bits_left = p_prc->eos_ ? 32 : MAX2(in_buf->nFilledLen * 8, 32);
+      struct vl_vlc vlc;
+
+      vl_vlc_init(&vlc, p_prc->num_in_buffers, p_prc->inputs, p_prc->sizes);
+
+      if (p_prc->slice)
+         p_prc->bytes_left = vl_vlc_bits_left(&vlc) / 8;
+
+      while (vl_vlc_bits_left (&vlc) > min_bits_left) {
+         decode_buffer(p_prc, &vlc, min_bits_left);
+         vl_vlc_fillbits(&vlc);
+      }
+
+      if (p_prc->slice) {
+         unsigned bytes = p_prc->bytes_left - vl_vlc_bits_left(&vlc) / 8;
+
+         p_prc->codec->decode_bitstream(p_prc->codec, p_prc->target, &p_prc->picture.base,
+                                 1, &p_prc->slice, &bytes);
+
+         if (p_prc->num_in_buffers)
+            p_prc->slice = p_prc->inputs[1];
+         else
+            p_prc->slice = NULL;
+      }
+
+      if (p_prc->eos_ && p_prc->frame_started)
+         h264d_end_frame(p_prc);
+
+      if (p_prc->frame_finished) {
+         p_prc->frame_finished = false;
+         h264d_manage_buffers(p_prc);
+      } else if (p_prc->eos_) {
+         h264d_free_input_port_private(p_prc->in_buffers[0]);
+         h264d_manage_buffers(p_prc);
+      } else {
+         p_prc->in_buffers[0]->nFilledLen = 0;
+         h264d_buffer_emptied(p_prc, p_prc->in_buffers[0]);
+      }
+
+      if (p_prc->out_port_disabled_) {
+         /* In case out port is disabled, h264d_buffer_emptied will fail to release input port.
+          * We need to wait before shifting the buffers in that case and check in
+          * get_input_buffer when out port is enabled to release and shift the buffers.
+          * Infinite looping occurs if buffer is not released */
+         if (p_prc->num_in_buffers == 2) {
+            /* Set the delta value for use in get_input_buffer before exiting */
+            dec_frame_delta = MIN2((min_bits_left - vl_vlc_bits_left(&vlc)) / 8, p_prc->sizes[1]);
+         }
+         break;
+      }
+
+      h264d_shift_buffers_left(p_prc);
+   }
+
+   return OMX_ErrorNone;
+}
+
+/*
+ * h264dprc
+ */
+
+static void * h264d_prc_ctor(void *ap_obj, va_list * app)
+{
+   h264d_prc_t *p_prc = super_ctor(typeOf (ap_obj, "h264dprc"), ap_obj, app);
+   assert(p_prc);
+   p_prc->p_inhdr_ = 0;
+   p_prc->p_outhdr_ = 0;
+   p_prc->first_buf_in_frame = true;
+   p_prc->eos_ = false;
+   p_prc->in_port_disabled_   = false;
+   p_prc->out_port_disabled_   = false;
+   p_prc->picture.base.profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
+   p_prc->profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
+   reset_stream_parameters(p_prc);
+
+   return p_prc;
+}
+
+static void * h264d_prc_dtor(void *ap_obj)
+{
+   return super_dtor(typeOf(ap_obj, "h264dprc"), ap_obj);
+}
+
+static OMX_ERRORTYPE h264d_prc_allocate_resources(void *ap_obj, OMX_U32 a_pid)
+{
+   h264d_prc_t *p_prc = ap_obj;
+   struct pipe_screen *screen;
+
+   assert (p_prc);
+
+   p_prc->screen = omx_get_screen();
+   if (!p_prc->screen)
+      return OMX_ErrorInsufficientResources;
+
+   screen = p_prc->screen->pscreen;
+   p_prc->pipe = screen->context_create(screen, p_prc->screen, 0);
+   if (!p_prc->pipe)
+      return OMX_ErrorInsufficientResources;
+
+   if (!vl_compositor_init(&p_prc->compositor, p_prc->pipe)) {
+      p_prc->pipe->destroy(p_prc->pipe);
+      p_prc->pipe = NULL;
+      return OMX_ErrorInsufficientResources;
+   }
+
+   if (!vl_compositor_init_state(&p_prc->cstate, p_prc->pipe)) {
+      vl_compositor_cleanup(&p_prc->compositor);
+      p_prc->pipe->destroy(p_prc->pipe);
+      p_prc->pipe = NULL;
+      return OMX_ErrorInsufficientResources;
+   }
+
+   LIST_INITHEAD(&p_prc->codec_data.dpb_list);
+
+   return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE h264d_prc_deallocate_resources(void *ap_obj)
+{
+   h264d_prc_t *p_prc = ap_obj;
+   assert(p_prc);
+
+
+   if (p_prc->pipe) {
+      vl_compositor_cleanup_state(&p_prc->cstate);
+      vl_compositor_cleanup(&p_prc->compositor);
+      p_prc->pipe->destroy(p_prc->pipe);
+   }
+
+   if (p_prc->screen)
+      omx_put_screen();
+
+   return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE h264d_prc_prepare_to_transfer(void *ap_obj, OMX_U32 a_pid)
+{
+   h264d_prc_t *p_prc = ap_obj;
+   assert(p_prc);
+
+   TIZ_INIT_OMX_PORT_STRUCT(p_prc->in_port_def_,
+                            OMX_VID_DEC_AVC_INPUT_PORT_INDEX);
+   tiz_check_omx(
+      tiz_api_GetParameter(tiz_get_krn(handleOf(p_prc)), handleOf(p_prc),
+                           OMX_IndexParamPortDefinition, &(p_prc->in_port_def_)));
+
+   TIZ_INIT_OMX_PORT_STRUCT(p_prc->out_port_def_,
+                            OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX);
+   tiz_check_omx(
+      tiz_api_GetParameter(tiz_get_krn(handleOf(p_prc)), handleOf(p_prc),
+                           OMX_IndexParamPortDefinition, &(p_prc->out_port_def_)));
+
+   p_prc->first_buf_in_frame = true;
+   p_prc->eos_ = false;
+   return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE h264d_prc_transfer_and_process(void *ap_obj, OMX_U32 a_pid)
+{
+   return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE h264d_prc_stop_and_return(void *ap_obj)
+{
+   h264d_prc_t *p_prc = (h264d_prc_t *) ap_obj;
+   return h264d_release_all_headers (p_prc);
+}
+
+static OMX_ERRORTYPE h264d_prc_buffers_ready(const void *ap_obj)
+{
+   h264d_prc_t *p_prc = (h264d_prc_t *) ap_obj;
+   OMX_BUFFERHEADERTYPE *in_buf = NULL;
+   OMX_BUFFERHEADERTYPE *out_buf = NULL;
+
+   assert(p_prc);
+
+   /* Set parameters if start of stream */
+   if (!p_prc->eos_ && p_prc->first_buf_in_frame && (in_buf = get_input_buffer(p_prc))) {
+      decode_frame(p_prc, in_buf);
+   }
+
+   /* Don't get input buffer if output buffer not found */
+   while (!p_prc->eos_ && (out_buf = get_output_buffer(p_prc)) && (in_buf = get_input_buffer(p_prc))) {
+      if (!p_prc->out_port_disabled_) {
+         decode_frame(p_prc, in_buf);
+      }
+   }
+
+   return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE h264d_prc_port_flush(const void *ap_obj, OMX_U32 a_pid)
+{
+   h264d_prc_t *p_prc = (h264d_prc_t *) ap_obj;
+   if (OMX_ALL == a_pid || OMX_VID_DEC_AVC_INPUT_PORT_INDEX == a_pid) {
+      release_input_headers(p_prc);
+      reset_stream_parameters(p_prc);
+   }
+   if (OMX_ALL == a_pid || OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX == a_pid) {
+      release_output_header(p_prc);
+   }
+   return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE h264d_prc_port_disable(const void *ap_obj, OMX_U32 a_pid)
+{
+   h264d_prc_t *p_prc = (h264d_prc_t *) ap_obj;
+   assert(p_prc);
+   if (OMX_ALL == a_pid || OMX_VID_DEC_AVC_INPUT_PORT_INDEX == a_pid) {
+      /* Release all buffers */
+      h264d_release_all_headers(p_prc);
+      reset_stream_parameters(p_prc);
+      p_prc->in_port_disabled_ = true;
+   }
+   if (OMX_ALL == a_pid || OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX == a_pid) {
+      release_output_header(p_prc);
+      p_prc->out_port_disabled_ = true;
+   }
+   return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE h264d_prc_port_enable(const void *ap_obj, OMX_U32 a_pid)
+{
+   h264d_prc_t * p_prc = (h264d_prc_t *) ap_obj;
+   assert(p_prc);
+   if (OMX_ALL == a_pid || OMX_VID_DEC_AVC_INPUT_PORT_INDEX == a_pid) {
+      if (p_prc->in_port_disabled_) {
+         reset_stream_parameters(p_prc);
+         p_prc->in_port_disabled_ = false;
+      }
+   }
+   if (OMX_ALL == a_pid || OMX_VID_DEC_AVC_OUTPUT_PORT_INDEX == a_pid) {
+      p_prc->out_port_disabled_ = false;
+   }
+   return OMX_ErrorNone;
+}
+
+/*
+ * h264d_prc_class
+ */
+
+static void * h264d_prc_class_ctor(void *ap_obj, va_list * app)
+{
+   /* NOTE: Class methods might be added in the future. None for now. */
+   return super_ctor(typeOf(ap_obj, "h264dprc_class"), ap_obj, app);
+}
+
+/*
+ * initialization
+ */
+
+void * h264d_prc_class_init(void * ap_tos, void * ap_hdl)
+{
+   void * tizprc = tiz_get_type(ap_hdl, "tizprc");
+   void * h264dprc_class = factory_new
+      /* TIZ_CLASS_COMMENT: class type, class name, parent, size */
+      (classOf(tizprc), "h264dprc_class", classOf(tizprc),
+       sizeof(h264d_prc_class_t),
+       /* TIZ_CLASS_COMMENT: */
+       ap_tos, ap_hdl,
+       /* TIZ_CLASS_COMMENT: class constructor */
+       ctor, h264d_prc_class_ctor,
+       /* TIZ_CLASS_COMMENT: stop value*/
+       0);
+   return h264dprc_class;
+}
+
+void * h264d_prc_init(void * ap_tos, void * ap_hdl)
+{
+   void * tizprc = tiz_get_type(ap_hdl, "tizprc");
+   void * h264dprc_class = tiz_get_type(ap_hdl, "h264dprc_class");
+   TIZ_LOG_CLASS (h264dprc_class);
+   void * h264dprc = factory_new
+     /* TIZ_CLASS_COMMENT: class type, class name, parent, size */
+     (h264dprc_class, "h264dprc", tizprc, sizeof(h264d_prc_t),
+      /* TIZ_CLASS_COMMENT: */
+      ap_tos, ap_hdl,
+      /* TIZ_CLASS_COMMENT: class constructor */
+      ctor, h264d_prc_ctor,
+      /* TIZ_CLASS_COMMENT: class destructor */
+      dtor, h264d_prc_dtor,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_srv_allocate_resources, h264d_prc_allocate_resources,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_srv_deallocate_resources, h264d_prc_deallocate_resources,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_srv_prepare_to_transfer, h264d_prc_prepare_to_transfer,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_srv_transfer_and_process, h264d_prc_transfer_and_process,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_srv_stop_and_return, h264d_prc_stop_and_return,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_prc_buffers_ready, h264d_prc_buffers_ready,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_prc_port_flush, h264d_prc_port_flush,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_prc_port_disable, h264d_prc_port_disable,
+      /* TIZ_CLASS_COMMENT: */
+      tiz_prc_port_enable, h264d_prc_port_enable,
+      /* TIZ_CLASS_COMMENT: stop value*/
+      0);
+
+   return h264dprc;
+}
diff --git a/src/gallium/state_trackers/omx_tizonia/h264dprc.h b/src/gallium/state_trackers/omx_tizonia/h264dprc.h
new file mode 100644
index 0000000..08af549
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/h264dprc.h
@@ -0,0 +1,31 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef H264DPRC_H
+#define H264DPRC_H
+
+void * h264d_prc_class_init(void * ap_tos, void * ap_hdl);
+void * h264d_prc_init(void * ap_tos, void * ap_hdl);
+
+#endif                          /* H264DPRC_H */
diff --git a/src/gallium/state_trackers/omx_tizonia/h264dprc_decls.h b/src/gallium/state_trackers/omx_tizonia/h264dprc_decls.h
new file mode 100644
index 0000000..9a58324
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/h264dprc_decls.h
@@ -0,0 +1,108 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef H264DPRC_DECLS_H
+#define H264DPRC_DECLS_H
+
+#include <tizonia/OMX_Core.h>
+
+#include <tizprc_decls.h>
+#include <tizport_decls.h>
+
+#include "util/list.h"
+
+#include "pipe/p_video_state.h"
+
+#include "vl/vl_rbsp.h"
+#include "vl/vl_zscan.h"
+#include "vl/vl_compositor.h"
+
+typedef struct h264d_prc_class h264d_prc_class_t;
+struct h264d_prc_class
+{
+   /* Class */
+   const tiz_prc_class_t _;
+   /* NOTE: Class methods might be added in the future */
+};
+
+typedef struct h264d_stream_info h264d_stream_info_t;
+struct h264d_stream_info
+{
+   unsigned int width;
+   unsigned int height;
+};
+
+typedef struct h264d_prc h264d_prc_t;
+struct h264d_prc
+{
+   /* Object */
+   const tiz_prc_t _;
+   OMX_BUFFERHEADERTYPE *in_buffers[2];
+   OMX_BUFFERHEADERTYPE *p_inhdr_;
+   OMX_BUFFERHEADERTYPE *p_outhdr_;
+   OMX_PARAM_PORTDEFINITIONTYPE in_port_def_;
+   OMX_PARAM_PORTDEFINITIONTYPE out_port_def_;
+   const void *inputs[2];
+   unsigned sizes[2];
+   OMX_TICKS timestamps[2];
+   OMX_TICKS timestamp;
+   bool eos_;
+   bool in_port_disabled_;
+   bool out_port_disabled_;
+   struct vl_screen *screen;
+   struct pipe_context *pipe;
+   struct pipe_video_codec *codec;
+   struct pipe_video_buffer *target;
+   enum pipe_video_profile profile;
+   struct {
+      unsigned nal_ref_idc;
+      bool IdrPicFlag;
+      unsigned idr_pic_id;
+      unsigned pic_order_cnt_lsb;
+      unsigned pic_order_cnt_msb;
+      unsigned delta_pic_order_cnt_bottom;
+      unsigned delta_pic_order_cnt[2];
+      unsigned prevFrameNumOffset;
+      struct pipe_h264_sps sps[32];
+      struct pipe_h264_pps pps[256];
+      struct list_head dpb_list;
+      unsigned dpb_num;
+   } codec_data;
+   union {
+      struct pipe_picture_desc base;
+      struct pipe_h264_picture_desc h264;
+   } picture;
+   h264d_stream_info_t stream_info;
+   unsigned num_in_buffers;
+   bool first_buf_in_frame;
+   bool frame_finished;
+   bool frame_started;
+   unsigned bytes_left;
+   const void *slice;
+   bool disable_tunnel;
+   struct vl_compositor compositor;
+   struct vl_compositor_state cstate;
+};
+
+#endif
diff --git a/src/gallium/state_trackers/omx_tizonia/names.h b/src/gallium/state_trackers/omx_tizonia/names.h
new file mode 100644
index 0000000..edde7df
--- /dev/null
+++ b/src/gallium/state_trackers/omx_tizonia/names.h
@@ -0,0 +1,30 @@ 
+/**************************************************************************
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef OMX_TIZ_NAMES_H
+#define OMX_TIZ_NAMES_H
+
+#define OMX_VID_COMP_NAME "OMX.mesa.video.all"
+
+#endif

Comments

Emil Velikov Aug. 11, 2017, 12:35 p.m.
On 11 August 2017 at 05:31, Gurkirpal Singh <gurkirpal204@gmail.com> wrote:

> --- /dev/null
> +++ b/src/gallium/state_trackers/omx_tizonia/entrypoint.c
> @@ -0,0 +1,152 @@
> +/**************************************************************************
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the
> + * "Software"), to deal in the Software without restriction, including
> + * without limitation the rights to use, copy, modify, merge, publish,
> + * distribute, sub license, and/or sell copies of the Software, and to
> + * permit persons to whom the Software is furnished to do so, subject to
> + * the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the
> + * next paragraph) shall be included in all copies or substantial portions
> + * of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
> + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
> + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
> + * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
> + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
> + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
> + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
> + *
> + **************************************************************************/
> +
This file looks quite similar to the omx(bellagio) one. Did you copy
it from there by any chance?
Please try to preserve the copyright blob, for files that are copied.

Thanks
Emil