Add pvrvideosink element

PVRVideoSink uses PVR2D library to blit images.

Author: Alessandro Decina <alessandro.decina@collabora.co.uk>
Author: Luciana Fujii <luciana.fujii@collabora.co.uk>

14 files changed, 5725 insertions, 0 deletions

diff --git a/sys/pvr2d/Makefile.am b/sys/pvr2d/Makefile.am
new file mode 100644
index 000000000..b45071063
--- /dev/null
+++ b/sys/pvr2d/Makefile.am
@@ -0,0 +1,22 @@
+plugin_LTLIBRARIES = libgstpvr.la
+
+libgstpvr_la_SOURCES = \
+	gstpvr.c \
+	gstpvrbufferpool.c \
+	gstpvrvideosink.c
+
+libgstpvr_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_CFLAGS) $(PVR_CFLAGS)
+
+libgstpvr_la_LIBADD = $(GST_LIBS) $(GST_BASE_LIBS) \
+	$(GST_PLUGINS_BASE_LIBS) $(X11_LIBS) -lgstvideo-$(GST_MAJORMINOR) \
+	-lgstinterfaces-$(GST_MAJORMINOR) -lpvr2d -lpvrPVR2D_DRIWSEGL\
+	$(PVR_LIBS) \
+	$(LIBM)
+
+libgstpvr_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+libgstpvr_la_LIBTOOLFLAGS = --tag=disable-static
+
+noinst_HEADERS = \
+	gstpvr.h \
+	gstpvrbufferpool.h \
+	gstpvrvideosink.h
diff --git a/sys/pvr2d/gstpvr.c b/sys/pvr2d/gstpvr.c
new file mode 100644
index 000000000..0112d1ee7
--- /dev/null
+++ b/sys/pvr2d/gstpvr.c
@@ -0,0 +1,85 @@
+/*
+ * GStreamer
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "gstpvr.h"
+#include "gstpvrvideosink.h"
+
+GST_DEBUG_CATEGORY (gst_debug_pvrvideosink);
+
+static gboolean
+plugin_init (GstPlugin * plugin)
+{
+  GST_DEBUG_CATEGORY_INIT (gst_debug_pvrvideosink, "pvrvideosink", 0,
+      "pvrvideosink");
+
+  return gst_element_register (plugin, "pvrvideosink", GST_RANK_PRIMARY,
+      GST_TYPE_PVRVIDEOSINK);
+}
+
+void *
+gst_ducati_alloc_1d (gint sz)
+{
+  MemAllocBlock block = {
+    .pixelFormat = PIXEL_FMT_PAGE,
+    .dim.len = sz,
+  };
+  return MemMgr_Alloc (&block, 1);
+}
+
+void *
+gst_ducati_alloc_2d (gint width, gint height, guint * sz)
+{
+  MemAllocBlock block[] = { {
+          .pixelFormat = PIXEL_FMT_8BIT,
+          .dim = {.area = {
+                      .width = width,
+                      .height = ALIGN2 (height, 1),
+                  }},
+      .stride = 4096}, {
+        .pixelFormat = PIXEL_FMT_16BIT,
+        .dim = {.area = {
+                    .width = width,
+                    .height = ALIGN2 (height, 1) / 2,
+                }},
+      .stride = 4096}
+  };
+  if (sz) {
+    *sz = (4096 * ALIGN2 (height, 1) * 3) / 2;
+  }
+  return MemMgr_Alloc (block, 2);
+}
+
+/* PACKAGE: this is usually set by autotools depending on some _INIT macro
+ * in configure.ac and then written into and defined in config.h, but we can
+ * just set it ourselves here in case someone doesn't use autotools to
+ * compile this code. GST_PLUGIN_DEFINE needs PACKAGE to be defined.
+ */
+#ifndef PACKAGE
+#  define PACKAGE "ducati"
+#endif
+
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
+    GST_VERSION_MINOR,
+    "pvr",
+    "Pvr2d based plugin",
+    plugin_init, VERSION, "LGPL", "GStreamer", "http://gstreamer.net/")
diff --git a/sys/pvr2d/gstpvr.h b/sys/pvr2d/gstpvr.h
new file mode 100644
index 000000000..d2c57af00
--- /dev/null
+++ b/sys/pvr2d/gstpvr.h
@@ -0,0 +1,42 @@
+/*
+ * GStreamer
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __GST_DUCATI_H__
+#define __GST_DUCATI_H__
+
+#include <stdint.h>
+#include <string.h>
+
+#include <tiler.h>
+#include <tilermem.h>
+#include <memmgr.h>
+
+#include <gst/gst.h>
+
+G_BEGIN_DECLS
+
+/* align x to next highest multiple of 2^n */
+#define ALIGN2(x,n)   (((x) + ((1 << (n)) - 1)) & ~((1 << (n)) - 1))
+
+void * gst_ducati_alloc_1d (gint sz);
+void * gst_ducati_alloc_2d (gint width, gint height, guint * sz);
+
+G_END_DECLS
+
+#endif /* __GST_DUCATI_H__ */
diff --git a/sys/pvr2d/gstpvrbufferpool.c b/sys/pvr2d/gstpvrbufferpool.c
new file mode 100644
index 000000000..03bcafb68
--- /dev/null
+++ b/sys/pvr2d/gstpvrbufferpool.c
@@ -0,0 +1,320 @@
+/*
+ * GStreamer
+ * Copyright (c) 2010, Texas Instruments Incorporated
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "gstpvrbufferpool.h"
+
+GST_DEBUG_CATEGORY_EXTERN (gst_debug_pvrvideosink);
+#define GST_CAT_DEFAULT gst_debug_pvrvideosink
+
+/*
+ * GstDucatiBuffer
+ */
+
+static GstBufferClass *buffer_parent_class;
+
+/* Get the original buffer, or whatever is the best output buffer.
+ * Consumes the input reference, produces the output reference
+ */
+GstBuffer *
+gst_ducati_buffer_get (GstDucatiBuffer * self)
+{
+  if (self->orig) {
+    // TODO copy to orig buffer.. if needed.
+    gst_buffer_unref (self->orig);
+    self->orig = NULL;
+  }
+  return GST_BUFFER (self);
+}
+
+PVR2DMEMINFO *
+gst_ducati_buffer_get_meminfo (GstDucatiBuffer * self)
+{
+  return self->src_mem;
+}
+
+
+static GstDucatiBuffer *
+gst_ducati_buffer_new (GstPvrBufferPool * pool)
+{
+  PVR2DERROR pvr_error;
+  GstDucatiBuffer *self = (GstDucatiBuffer *)
+      gst_mini_object_new (GST_TYPE_DUCATIBUFFER);
+
+  GST_LOG_OBJECT (pool->element, "creating buffer %p in pool %p", self, pool);
+
+  self->pool = (GstPvrBufferPool *)
+      gst_mini_object_ref (GST_MINI_OBJECT (pool));
+
+  GST_BUFFER_DATA (self) = gst_ducati_alloc_1d (pool->size);
+  GST_BUFFER_SIZE (self) = pool->size;
+  GST_LOG_OBJECT (pool->element, "width=%d, height=%d and size=%d",
+      pool->padded_width, pool->padded_height, pool->size);
+
+  pvr_error =
+      PVR2DMemWrap (pool->pvr_context, GST_BUFFER_DATA (self), 0, pool->size,
+      NULL, &(self->src_mem));
+  if (pvr_error != PVR2D_OK) {
+    GST_LOG_OBJECT (pool->element, "Failed to Wrap buffer memory"
+        "returned %d", pvr_error);
+  } else {
+    self->wrapped = TRUE;
+  }
+
+  gst_buffer_set_caps (GST_BUFFER (self), pool->caps);
+
+  return self;
+}
+
+
+static void
+gst_ducati_buffer_finalize (GstDucatiBuffer * self)
+{
+  PVR2DERROR pvr_error;
+  GstPvrBufferPool *pool = self->pool;
+  gboolean resuscitated = FALSE;
+
+  GST_LOG_OBJECT (pool->element, "finalizing buffer %p", self);
+
+  GST_PVR_BUFFERPOOL_LOCK (pool);
+  g_queue_remove (pool->used_buffers, self);
+  if (pool->running) {
+    resuscitated = TRUE;
+
+    GST_LOG_OBJECT (pool->element, "reviving buffer %p", self);
+
+    g_queue_push_head (pool->free_buffers, self);
+  } else {
+    GST_LOG_OBJECT (pool->element, "the pool is shutting down");
+  }
+  GST_PVR_BUFFERPOOL_UNLOCK (pool);
+
+  if (resuscitated) {
+    GST_LOG_OBJECT (pool->element, "reviving buffer %p, %d", self, index);
+    gst_buffer_ref (GST_BUFFER (self));
+    GST_BUFFER_SIZE (self) = 0;
+  }
+
+  if (!resuscitated) {
+    GST_LOG_OBJECT (pool->element,
+        "buffer %p (data %p, len %u) not recovered, freeing",
+        self, GST_BUFFER_DATA (self), GST_BUFFER_SIZE (self));
+
+    if (self->wrapped) {
+      pvr_error = PVR2DMemFree (pool->pvr_context, self->src_mem);
+      if (pvr_error != PVR2D_OK) {
+        GST_ERROR_OBJECT (pool->element, "Failed to Unwrap buffer memory"
+            "returned %d", pvr_error);
+      }
+      self->wrapped = FALSE;
+    }
+    MemMgr_Free ((void *) GST_BUFFER_DATA (self));
+    GST_BUFFER_DATA (self) = NULL;
+    gst_mini_object_unref (GST_MINI_OBJECT (pool));
+    GST_MINI_OBJECT_CLASS (buffer_parent_class)->finalize (GST_MINI_OBJECT
+        (self));
+  }
+}
+
+static void
+gst_ducati_buffer_class_init (gpointer g_class, gpointer class_data)
+{
+  GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class);
+
+  buffer_parent_class = g_type_class_peek_parent (g_class);
+
+  mini_object_class->finalize = (GstMiniObjectFinalizeFunction)
+      GST_DEBUG_FUNCPTR (gst_ducati_buffer_finalize);
+}
+
+GType
+gst_ducati_buffer_get_type (void)
+{
+  static GType type;
+
+  if (G_UNLIKELY (type == 0)) {
+    static const GTypeInfo info = {
+      .class_size = sizeof (GstBufferClass),
+      .class_init = gst_ducati_buffer_class_init,
+      .instance_size = sizeof (GstDucatiBuffer),
+    };
+    type = g_type_register_static (GST_TYPE_BUFFER,
+        "GstDucatiBufferPvrsink", &info, 0);
+  }
+  return type;
+}
+
+/*
+ * GstDucatiBufferPool
+ */
+
+static GstMiniObjectClass *bufferpool_parent_class = NULL;
+
+/** create new bufferpool
+ * @element : the element that owns this pool
+ * @caps:  the caps to set on the buffer
+ * @num_buffers:  the requested number of buffers in the pool
+ */
+GstPvrBufferPool *
+gst_pvr_bufferpool_new (GstElement * element, GstCaps * caps, gint num_buffers,
+    gint size, PVR2DCONTEXTHANDLE pvr_context)
+{
+  GstPvrBufferPool *self = (GstPvrBufferPool *)
+      gst_mini_object_new (GST_TYPE_PVRBUFFERPOOL);
+  GstStructure *s = gst_caps_get_structure (caps, 0);
+
+  self->element = gst_object_ref (element);
+  gst_structure_get_int (s, "width", &self->padded_width);
+  gst_structure_get_int (s, "height", &self->padded_height);
+  self->caps = gst_caps_ref (caps);
+  self->size = size;
+  self->pvr_context = pvr_context;
+
+  self->free_buffers = g_queue_new ();
+  self->used_buffers = g_queue_new ();
+  self->lock = g_mutex_new ();
+  self->running = TRUE;
+
+  return self;
+}
+
+static void
+unwrap_buffer (gpointer buffer, gpointer user_data)
+{
+  PVR2DERROR pvr_error;
+  GstDucatiBuffer *buf = GST_DUCATIBUFFER (buffer);
+  GstPvrBufferPool *pool = (GstPvrBufferPool *) user_data;
+
+  if (buf->wrapped) {
+    pvr_error = PVR2DMemFree (pool->pvr_context, buf->src_mem);
+    if (pvr_error != PVR2D_OK) {
+      GST_ERROR_OBJECT (pool->element, "Failed to Unwrap buffer memory"
+          "returned %d", pvr_error);
+    }
+    buf->wrapped = FALSE;
+  }
+}
+
+void
+gst_pvr_bufferpool_stop_running (GstPvrBufferPool * self, gboolean unwrap)
+{
+  gboolean empty = FALSE;
+
+  g_return_if_fail (self);
+
+  GST_PVR_BUFFERPOOL_LOCK (self);
+  self->running = FALSE;
+  GST_PVR_BUFFERPOOL_UNLOCK (self);
+
+  GST_DEBUG_OBJECT (self->element, "free available buffers");
+
+  /* free all buffers on the freelist */
+  while (!empty) {
+    GstDucatiBuffer *buf;
+    GST_PVR_BUFFERPOOL_LOCK (self);
+    buf = g_queue_pop_head (self->free_buffers);
+    GST_PVR_BUFFERPOOL_UNLOCK (self);
+    if (buf)
+      gst_buffer_unref (GST_BUFFER (buf));
+    else
+      empty = TRUE;
+  }
+
+  if (unwrap)
+    g_queue_foreach (self->used_buffers, unwrap_buffer, self);
+
+  gst_mini_object_unref (GST_MINI_OBJECT (self));
+}
+
+/** get buffer from bufferpool, allocate new buffer if needed */
+GstDucatiBuffer *
+gst_pvr_bufferpool_get (GstPvrBufferPool * self, GstBuffer * orig)
+{
+  GstDucatiBuffer *buf = NULL;
+
+  g_return_val_if_fail (self, NULL);
+
+  GST_PVR_BUFFERPOOL_LOCK (self);
+  if (self->running) {
+    /* re-use a buffer off the freelist if any are available
+     */
+    buf = g_queue_pop_head (self->free_buffers);
+    if (!buf)
+      buf = gst_ducati_buffer_new (self);
+    buf->orig = orig;
+    g_queue_push_head (self->used_buffers, buf);
+  }
+  GST_PVR_BUFFERPOOL_UNLOCK (self);
+
+  if (buf && orig) {
+    GST_BUFFER_TIMESTAMP (buf) = GST_BUFFER_TIMESTAMP (orig);
+    GST_BUFFER_DURATION (buf) = GST_BUFFER_DURATION (orig);
+  }
+  GST_BUFFER_SIZE (buf) = self->size;
+
+  return buf;
+}
+
+static void
+gst_pvr_bufferpool_finalize (GstPvrBufferPool * self)
+{
+  GST_DEBUG_OBJECT (self->element, "destroy bufferpool");
+  g_mutex_free (self->lock);
+  self->lock = NULL;
+
+  g_queue_free (self->free_buffers);
+  self->free_buffers = NULL;
+  g_queue_free (self->used_buffers);
+  self->used_buffers = NULL;
+
+  gst_caps_unref (self->caps);
+  self->caps = NULL;
+  gst_object_unref (self->element);
+  self->element = NULL;
+
+  GST_MINI_OBJECT_CLASS (bufferpool_parent_class)->finalize (GST_MINI_OBJECT
+      (self));
+}
+
+static void
+gst_pvr_bufferpool_class_init (gpointer g_class, gpointer class_data)
+{
+  GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class);
+
+  bufferpool_parent_class = g_type_class_peek_parent (g_class);
+
+  mini_object_class->finalize = (GstMiniObjectFinalizeFunction)
+      GST_DEBUG_FUNCPTR (gst_pvr_bufferpool_finalize);
+}
+
+GType
+gst_pvr_bufferpool_get_type (void)
+{
+  static GType type;
+
+  if (G_UNLIKELY (type == 0)) {
+    static const GTypeInfo info = {
+      .class_size = sizeof (GstMiniObjectClass),
+      .class_init = gst_pvr_bufferpool_class_init,
+      .instance_size = sizeof (GstPvrBufferPool),
+    };
+    type = g_type_register_static (GST_TYPE_MINI_OBJECT,
+        "GstPvrBufferPool", &info, 0);
+  }
+  return type;
+}
diff --git a/sys/pvr2d/gstpvrbufferpool.h b/sys/pvr2d/gstpvrbufferpool.h
new file mode 100644
index 000000000..1d90472b6
--- /dev/null
+++ b/sys/pvr2d/gstpvrbufferpool.h
@@ -0,0 +1,89 @@
+/*
+ * GStreamer
+ * Copyright (c) 2010, 2011 Texas Instruments Incorporated
+ * Copyright (c) 2011, Collabora Ltda
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation
+ * version 2.1 of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __GSTPVRBUFFERPOOL_H__
+#define __GSTPVRBUFFERPOOL_H__
+
+#include "gstpvr.h"
+#include <pvr2d.h>
+
+G_BEGIN_DECLS
+
+GType gst_ducati_buffer_get_type (void);
+#define GST_TYPE_DUCATIBUFFER (gst_ducati_buffer_get_type())
+#define GST_IS_DUCATIBUFFER(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_DUCATIBUFFER))
+#define GST_DUCATIBUFFER(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_DUCATIBUFFER, GstDucatiBuffer))
+
+GType gst_pvr_bufferpool_get_type (void);
+#define GST_TYPE_PVRBUFFERPOOL (gst_pvr_bufferpool_get_type())
+#define GST_IS_PVRBUFFERPOOL(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_PVRBUFFERPOOL))
+#define GST_PVRBUFFERPOOL(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_PVRBUFFERPOOL, \
+                               GstPvrBufferPool))
+
+typedef struct _GstPvrBufferPool GstPvrBufferPool;
+typedef struct _GstDucatiBuffer GstDucatiBuffer;
+
+struct _GstPvrBufferPool
+{
+  GstMiniObject parent;
+
+  /* output (padded) size including any codec padding: */
+  gint padded_width, padded_height;
+  gint size;
+  PVR2DCONTEXTHANDLE pvr_context;
+
+  GstCaps *caps;
+  GMutex *lock;
+  gboolean running;  /* with lock */
+  GstElement *element;  /* the element that owns us.. */
+  GQueue *free_buffers;
+  GQueue *used_buffers;
+  guint buffer_count;
+};
+
+GstPvrBufferPool * gst_pvr_bufferpool_new (GstElement * element,
+    GstCaps * caps, gint num_buffers, gint size,
+    PVR2DCONTEXTHANDLE pvr_context);
+void gst_pvr_bufferpool_stop_running (GstPvrBufferPool * pool, gboolean unwrap);
+GstDucatiBuffer * gst_pvr_bufferpool_get (GstPvrBufferPool * self,
+    GstBuffer * orig);
+
+#define GST_PVR_BUFFERPOOL_LOCK(self)     g_mutex_lock ((self)->lock)
+#define GST_PVR_BUFFERPOOL_UNLOCK(self)   g_mutex_unlock ((self)->lock)
+
+struct _GstDucatiBuffer {
+  GstBuffer parent;
+
+  GstPvrBufferPool *pool; /* buffer-pool that this buffer belongs to */
+  GstBuffer       *orig;     /* original buffer, if we need to copy output */
+  PVR2DMEMINFO *src_mem; /* Memory wrapped by pvr */
+  gboolean wrapped;
+};
+
+GstBuffer * gst_ducati_buffer_get (GstDucatiBuffer * self);
+PVR2DMEMINFO * gst_ducati_buffer_get_meminfo (GstDucatiBuffer * self);
+
+G_END_DECLS
+
+#endif /* __GSTPVRBUFFERPOOL_H__ */
diff --git a/sys/pvr2d/gstpvrvideosink.c b/sys/pvr2d/gstpvrvideosink.c
new file mode 100644
index 000000000..3bfa3ad2d
--- /dev/null
+++ b/sys/pvr2d/gstpvrvideosink.c
@@ -0,0 +1,1548 @@
+/* GStreamer
+ *
+ * Copyright (C) 2011 Collabora Ltda
+ * Copyright (C) 2011 Texas Instruments
+ *  @author: Luciana Fujii Pontello <luciana.fujii@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/* Object header */
+#include "gstpvrvideosink.h"
+
+#include "gstpvrbufferpool.h"
+#include <gst/video/gstvideosink.h>
+#include <gst/interfaces/xoverlay.h>
+
+/* Debugging category */
+#include <gst/gstinfo.h>
+
+#define LINUX
+#include <dri2_ws.h>
+#include <services.h>
+#include <img_defs.h>
+#include <servicesext.h>
+
+#define DEFAULT_QUEUE_SIZE 12
+#define DEFAULT_MIN_QUEUED_BUFS 1
+
+GST_DEBUG_CATEGORY_EXTERN (gst_debug_pvrvideosink);
+#define GST_CAT_DEFAULT gst_debug_pvrvideosink
+
+#define PVR2DMEMINFO_INITIALISE(d, s) \
+{ \
+  (d)->hPrivateData = (IMG_VOID *)(s); \
+  (d)->hPrivateMapData = (IMG_VOID *)(s->hKernelMemInfo); \
+  (d)->ui32DevAddr = (IMG_UINT32) (s)->sDevVAddr.uiAddr; \
+  (d)->ui32MemSize = (s)->uAllocSize; \
+  (d)->pBase = (s)->pvLinAddr;\
+  (d)->ulFlags = (s)->ui32Flags;\
+}
+
+/* end of internal definitions */
+
+static void gst_pvrvideosink_reset (GstPVRVideoSink * pvrvideosink);
+static GstFlowReturn gst_pvrvideosink_buffer_alloc (GstBaseSink * bsink,
+    guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);
+static void gst_pvrvideosink_xwindow_draw_borders (GstPVRVideoSink *
+    pvrvideosink, GstXWindow * xwindow, GstVideoRectangle rect);
+static void gst_pvrvideosink_expose (GstXOverlay * overlay);
+static void gst_pvrvideosink_xwindow_destroy (GstPVRVideoSink * pvrvideosink,
+    GstXWindow * xwindow);
+
+static GstStaticPadTemplate gst_pvrvideosink_sink_template_factory =
+GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS ("video/x-raw-yuv, "
+        "format = (fourcc) NV12, "
+        "width = " GST_VIDEO_SIZE_RANGE ", "
+        "height = " GST_VIDEO_SIZE_RANGE ", "
+        "framerate = " GST_VIDEO_FPS_RANGE));
+
+enum
+{
+  PROP_0,
+  PROP_FORCE_ASPECT_RATIO,
+  PROP_WINDOW_WIDTH,
+  PROP_WINDOW_HEIGHT
+};
+
+static GstVideoSinkClass *parent_class = NULL;
+
+/* ============================================================= */
+/*                                                               */
+/*                       Private Methods                         */
+/*                                                               */
+/* ============================================================= */
+
+/* pvrvideo buffers */
+
+#define GST_TYPE_PVRVIDEO_BUFFER (gst_pvrvideo_buffer_get_type())
+
+#define GST_IS_PVRVIDEO_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_PVRVIDEO_BUFFER))
+#define GST_PVRVIDEO_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_PVRVIDEO_BUFFER, GstPVRVideoBuffer))
+#define GST_PVRVIDEO_BUFFER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_PVRVIDEO_BUFFER, GstPVRVideoBufferClass))
+
+static void
+gst_pvrvideosink_xwindow_update_geometry (GstPVRVideoSink * pvrvideosink)
+{
+  XWindowAttributes attr;
+  WSEGLError glerror;
+  WSEGLDrawableParams source_params;
+  PVRSRV_CLIENT_MEM_INFO *client_mem_info;
+
+  /* Update the window geometry */
+  g_mutex_lock (pvrvideosink->dcontext->x_lock);
+  if (G_UNLIKELY (pvrvideosink->xwindow == NULL)) {
+    g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+    return;
+  }
+  pvrvideosink->redraw_borders = TRUE;
+
+  XGetWindowAttributes (pvrvideosink->dcontext->x_display,
+      pvrvideosink->xwindow->window, &attr);
+
+  pvrvideosink->xwindow->width = attr.width;
+  pvrvideosink->xwindow->height = attr.height;
+
+  if (!pvrvideosink->have_render_rect) {
+    pvrvideosink->render_rect.x = pvrvideosink->render_rect.y = 0;
+    pvrvideosink->render_rect.w = attr.width;
+    pvrvideosink->render_rect.h = attr.height;
+  }
+  if (pvrvideosink->dcontext != NULL) {
+    glerror =
+        pvrvideosink->dcontext->
+        wsegl_table->pfnWSEGL_DeleteDrawable (pvrvideosink->dcontext->
+        drawable_handle);
+    if (glerror != WSEGL_SUCCESS) {
+      GST_ERROR_OBJECT (pvrvideosink, "Error destroying drawable");
+      return;
+    }
+    glerror =
+        pvrvideosink->dcontext->
+        wsegl_table->pfnWSEGL_CreateWindowDrawable (pvrvideosink->dcontext->
+        display_handle, pvrvideosink->dcontext->glconfig,
+        &pvrvideosink->dcontext->drawable_handle,
+        (NativeWindowType) pvrvideosink->xwindow->window,
+        &pvrvideosink->dcontext->rotation);
+    if (glerror != WSEGL_SUCCESS) {
+      GST_ERROR_OBJECT (pvrvideosink, "Error creating drawable");
+      return;
+    }
+    glerror =
+        pvrvideosink->dcontext->
+        wsegl_table->pfnWSEGL_GetDrawableParameters (pvrvideosink->dcontext->
+        drawable_handle, &source_params, &pvrvideosink->render_params);
+    if (glerror != WSEGL_SUCCESS) {
+      GST_ERROR_OBJECT (pvrvideosink, "Error getting Drawable params");
+      return;
+    }
+
+    client_mem_info =
+        (PVRSRV_CLIENT_MEM_INFO *) pvrvideosink->render_params.hPrivateData;
+    PVR2DMEMINFO_INITIALISE (&pvrvideosink->dcontext->dst_mem, client_mem_info);
+  }
+
+  g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+}
+
+/* This function handles XEvents that might be in the queue. It generates
+   GstEvent that will be sent upstream in the pipeline to handle interactivity
+   and navigation. It will also listen for configure events on the window to
+   trigger caps renegotiation so on the fly software scaling can work. */
+static void
+gst_pvrvideosink_handle_xevents (GstPVRVideoSink * pvrvideosink)
+{
+  XEvent e;
+  gboolean exposed = FALSE;
+  gboolean configured = FALSE;
+
+  g_mutex_lock (pvrvideosink->flow_lock);
+  g_mutex_lock (pvrvideosink->dcontext->x_lock);
+
+  /* Handle Expose */
+  while (XCheckWindowEvent (pvrvideosink->dcontext->x_display,
+          pvrvideosink->xwindow->window, ExposureMask | StructureNotifyMask,
+          &e)) {
+    switch (e.type) {
+      case Expose:
+        exposed = TRUE;
+        break;
+      case ConfigureNotify:
+        g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+        gst_pvrvideosink_xwindow_update_geometry (pvrvideosink);
+        g_mutex_lock (pvrvideosink->dcontext->x_lock);
+        configured = TRUE;
+        break;
+      default:
+        break;
+    }
+  }
+
+  if (exposed || configured) {
+    g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+    g_mutex_unlock (pvrvideosink->flow_lock);
+
+    gst_pvrvideosink_expose (GST_X_OVERLAY (pvrvideosink));
+
+    g_mutex_lock (pvrvideosink->flow_lock);
+    g_mutex_lock (pvrvideosink->dcontext->x_lock);
+  }
+
+  /* Handle Display events */
+  while (XPending (pvrvideosink->dcontext->x_display)) {
+    XNextEvent (pvrvideosink->dcontext->x_display, &e);
+
+    switch (e.type) {
+      case ClientMessage:{
+        Atom wm_delete;
+
+        wm_delete = XInternAtom (pvrvideosink->dcontext->x_display,
+            "WM_DELETE_WINDOW", True);
+        if (wm_delete != None && wm_delete == (Atom) e.xclient.data.l[0]) {
+          /* Handle window deletion by posting an error on the bus */
+          GST_ELEMENT_ERROR (pvrvideosink, RESOURCE, NOT_FOUND,
+              ("Output window was closed"), (NULL));
+
+          g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+          gst_pvrvideosink_xwindow_destroy (pvrvideosink,
+              pvrvideosink->xwindow);
+          pvrvideosink->xwindow = NULL;
+          g_mutex_lock (pvrvideosink->dcontext->x_lock);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+  g_mutex_unlock (pvrvideosink->flow_lock);
+}
+
+static gpointer
+gst_pvrvideosink_event_thread (GstPVRVideoSink * pvrvideosink)
+{
+  GST_OBJECT_LOCK (pvrvideosink);
+  while (pvrvideosink->running) {
+    GST_OBJECT_UNLOCK (pvrvideosink);
+
+    if (pvrvideosink->xwindow) {
+      gst_pvrvideosink_handle_xevents (pvrvideosink);
+    }
+    g_usleep (G_USEC_PER_SEC / 20);
+
+    GST_OBJECT_LOCK (pvrvideosink);
+  }
+  GST_OBJECT_UNLOCK (pvrvideosink);
+
+  return NULL;
+}
+
+static void
+gst_pvrvideosink_manage_event_thread (GstPVRVideoSink * pvrvideosink)
+{
+  GThread *thread = NULL;
+
+  /* don't start the thread too early */
+  if (pvrvideosink->dcontext == NULL) {
+    return;
+  }
+
+  GST_OBJECT_LOCK (pvrvideosink);
+  if (!pvrvideosink->event_thread) {
+    /* Setup our event listening thread */
+    GST_DEBUG_OBJECT (pvrvideosink, "run xevent thread");
+    pvrvideosink->running = TRUE;
+    pvrvideosink->event_thread = g_thread_create (
+        (GThreadFunc) gst_pvrvideosink_event_thread, pvrvideosink, TRUE, NULL);
+  }
+  GST_OBJECT_UNLOCK (pvrvideosink);
+
+  /* Wait for our event thread to finish */
+  if (thread)
+    g_thread_join (thread);
+}
+
+
+static GstDrawContext *
+gst_pvrvideosink_get_dcontext (GstPVRVideoSink * pvrvideosink)
+{
+  GstDrawContext *dcontext;
+  PVR2DERROR pvr_error;
+  gint refresh_rate;
+  DRI2WSDisplay *displayImpl;
+  WSEGLError glerror;
+  const WSEGLCaps *glcaps;
+
+  dcontext = g_new0 (GstDrawContext, 1);
+  dcontext->p_blt_info = 0;
+  dcontext->x_lock = g_mutex_new ();
+
+  dcontext->p_blt_info = g_new0 (PVR2D_3DBLT_EXT, 1);
+  if (!dcontext->p_blt_info) {
+    GST_ERROR_OBJECT (pvrvideosink, "Alloc of bltinfo failed");
+    return NULL;
+  }
+  dcontext->p_blt2d_info = g_new0 (PVR2DBLTINFO, 1);
+
+  dcontext->x_display = XOpenDisplay (NULL);
+
+  dcontext->wsegl_table = WSEGL_GetFunctionTablePointer ();
+  glerror = dcontext->wsegl_table->pfnWSEGL_IsDisplayValid (
+      (NativeDisplayType) dcontext->x_display);
+
+  if (glerror != WSEGL_SUCCESS) {
+    GST_ERROR_OBJECT (pvrvideosink, "Display is not valid");
+    return NULL;
+  }
+
+  glerror = dcontext->wsegl_table->pfnWSEGL_InitialiseDisplay (
+      (NativeDisplayType) dcontext->x_display, &dcontext->display_handle,
+      &glcaps, &dcontext->glconfig);
+  if (glerror != WSEGL_SUCCESS) {
+    GST_ERROR_OBJECT (pvrvideosink, "Error initializing display");
+    return NULL;
+  }
+
+  displayImpl = (DRI2WSDisplay *) dcontext->display_handle;
+  dcontext->pvr_context = displayImpl->hContext;
+
+  pvr_error = PVR2DGetScreenMode (dcontext->pvr_context,
+      &dcontext->display_format, &dcontext->display_width,
+      &dcontext->display_height, &dcontext->stride, &refresh_rate);
+  if (pvr_error != PVR2D_OK) {
+    GST_ERROR_OBJECT (pvrvideosink, "Failed) to get screen mode"
+        "returned %d", pvr_error);
+    return NULL;
+  }
+  dcontext->screen_num = DefaultScreen (dcontext->x_display);
+  dcontext->black = XBlackPixel (dcontext->x_display, dcontext->screen_num);
+
+  return dcontext;
+}
+
+static void
+gst_pvrvideosink_xwindow_set_title (GstPVRVideoSink * pvrvideosink,
+    GstXWindow * xwindow, const gchar * media_title)
+{
+  if (media_title) {
+    g_free (pvrvideosink->media_title);
+    pvrvideosink->media_title = g_strdup (media_title);
+  }
+  if (xwindow) {
+    /* we have a window */
+    if (xwindow->internal) {
+      XTextProperty xproperty;
+      const gchar *app_name;
+      const gchar *title = NULL;
+      gchar *title_mem = NULL;
+
+      /* set application name as a title */
+      app_name = g_get_application_name ();
+
+      if (app_name && pvrvideosink->media_title) {
+        title = title_mem = g_strconcat (pvrvideosink->media_title, " : ",
+            app_name, NULL);
+      } else if (app_name) {
+        title = app_name;
+      } else if (pvrvideosink->media_title) {
+        title = pvrvideosink->media_title;
+      }
+
+      if (title) {
+        if ((XStringListToTextProperty (((char **) &title), 1,
+                    &xproperty)) != 0) {
+          XSetWMName (pvrvideosink->dcontext->x_display, xwindow->window,
+              &xproperty);
+          XFree (xproperty.value);
+        }
+
+        g_free (title_mem);
+      }
+    }
+  }
+}
+
+static GstXWindow *
+gst_pvrvideosink_create_window (GstPVRVideoSink * pvrvideosink, gint width,
+    gint height)
+{
+  WSEGLError glerror;
+  WSEGLDrawableParams source_params;
+  Window root;
+  GstXWindow *xwindow;
+  GstDrawContext *dcontext;
+  XGCValues values;
+  Atom wm_delete;
+  PVRSRV_CLIENT_MEM_INFO *client_mem_info;
+
+  GST_DEBUG_OBJECT (pvrvideosink, "begin");
+
+  dcontext = pvrvideosink->dcontext;
+  xwindow = g_new0 (GstXWindow, 1);
+
+  xwindow->internal = TRUE;
+  pvrvideosink->render_rect.x = pvrvideosink->render_rect.y = 0;
+  pvrvideosink->render_rect.w = width;
+  pvrvideosink->render_rect.h = height;
+  xwindow->width = width;
+  xwindow->height = height;
+  xwindow->internal = TRUE;
+
+  g_mutex_lock (pvrvideosink->dcontext->x_lock);
+
+  root = DefaultRootWindow (dcontext->x_display);
+  xwindow->window = XCreateSimpleWindow (dcontext->x_display, root, 0, 0,
+      width, height, 2, 2, pvrvideosink->dcontext->black);
+  XSelectInput (dcontext->x_display, xwindow->window,
+      ExposureMask | StructureNotifyMask);
+
+  /* Tell the window manager we'd like delete client messages instead of
+   * being killed */
+  wm_delete = XInternAtom (pvrvideosink->dcontext->x_display,
+      "WM_DELETE_WINDOW", True);
+  if (wm_delete != None) {
+    (void) XSetWMProtocols (pvrvideosink->dcontext->x_display, xwindow->window,
+        &wm_delete, 1);
+  }
+
+  XMapWindow (dcontext->x_display, xwindow->window);
+
+  /* We have to do that to prevent X from redrawing the background on
+   * ConfigureNotify. This takes away flickering of video when resizing. */
+  XSetWindowBackgroundPixmap (pvrvideosink->dcontext->x_display,
+      xwindow->window, None);
+
+  gst_pvrvideosink_xwindow_set_title (pvrvideosink, xwindow, NULL);
+
+  xwindow->gc = XCreateGC (pvrvideosink->dcontext->x_display,
+      xwindow->window, 0, &values);
+
+  g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+
+  glerror =
+      dcontext->wsegl_table->pfnWSEGL_CreateWindowDrawable (dcontext->
+      display_handle, dcontext->glconfig, &(dcontext->drawable_handle),
+      (NativeWindowType) xwindow->window, &(dcontext->rotation));
+
+  if (glerror != WSEGL_SUCCESS) {
+    GST_ERROR_OBJECT (pvrvideosink, "Error creating drawable");
+    return NULL;
+  }
+  glerror =
+      dcontext->wsegl_table->pfnWSEGL_GetDrawableParameters (dcontext->
+      drawable_handle, &source_params, &pvrvideosink->render_params);
+  client_mem_info =
+      (PVRSRV_CLIENT_MEM_INFO *) pvrvideosink->render_params.hPrivateData;
+  PVR2DMEMINFO_INITIALISE (&dcontext->dst_mem, client_mem_info);
+
+  GST_DEBUG_OBJECT (pvrvideosink, "end");
+  return xwindow;
+}
+
+static void
+gst_pvrvideosink_blit (GstPVRVideoSink * pvrvideosink, GstBuffer * buffer)
+{
+  PVR2DERROR pvr_error;
+  GstDrawContext *dcontext = pvrvideosink->dcontext;
+  GstCaps *caps;
+  GstStructure *structure;
+  gint video_width;
+  gint video_height;
+  gboolean ret;
+  gboolean draw_border = FALSE;
+  PPVR2D_3DBLT_EXT p_blt_3d;
+  PVR2DMEMINFO *src_mem;
+  PVR2DFORMAT pvr_format = pvrvideosink->format == GST_VIDEO_FORMAT_NV12 ?
+      PVR2D_YUV420_2PLANE : PVR2D_ARGB8888;
+  GstVideoRectangle result;
+
+  GST_DEBUG_OBJECT (pvrvideosink, "begin");
+  g_mutex_lock (pvrvideosink->flow_lock);
+  if (buffer == NULL)
+    buffer = pvrvideosink->current_buffer;
+
+  if (buffer == NULL) {
+    g_mutex_unlock (pvrvideosink->flow_lock);
+    return;
+  }
+
+  caps = GST_BUFFER_CAPS (buffer);
+  src_mem = gst_ducati_buffer_get_meminfo ((GstDucatiBuffer *) buffer);
+  p_blt_3d = dcontext->p_blt_info;
+
+  structure = gst_caps_get_structure (caps, 0);
+  ret = gst_structure_get_int (structure, "width", &video_width);
+  ret &= gst_structure_get_int (structure, "height", &video_height);
+  if (!ret) {
+    GST_ERROR_OBJECT (pvrvideosink, "Failed to get dimensions of the buffer");
+    goto done;
+  }
+
+  g_mutex_lock (pvrvideosink->dcontext->x_lock);
+
+  /* Draw borders when displaying the first frame. After this
+     draw borders only on expose event or after a size change. */
+  if (!(pvrvideosink->current_buffer) || pvrvideosink->redraw_borders) {
+    draw_border = TRUE;
+  }
+
+  /* Store a reference to the last image we put, lose the previous one */
+  if (buffer && pvrvideosink->current_buffer != buffer) {
+    if (pvrvideosink->current_buffer) {
+      GST_LOG_OBJECT (pvrvideosink, "unreffing %p",
+          pvrvideosink->current_buffer);
+      gst_buffer_unref (GST_BUFFER_CAST (pvrvideosink->current_buffer));
+    }
+    GST_LOG_OBJECT (pvrvideosink, "reffing %p as our current buffer", buffer);
+    pvrvideosink->current_buffer = gst_buffer_ref (buffer);
+  }
+
+  if (pvrvideosink->keep_aspect) {
+    GstVideoRectangle src, dst;
+
+    src.w = GST_VIDEO_SINK_WIDTH (pvrvideosink);
+    src.h = GST_VIDEO_SINK_HEIGHT (pvrvideosink);
+    dst.w = pvrvideosink->render_rect.w;
+    dst.h = pvrvideosink->render_rect.h;
+    gst_video_sink_center_rect (src, dst, &result, TRUE);
+    result.x += pvrvideosink->render_rect.x;
+    result.y += pvrvideosink->render_rect.y;
+  } else {
+    memcpy (&result, &pvrvideosink->render_rect, sizeof (GstVideoRectangle));
+  }
+
+  p_blt_3d->sDst.pSurfMemInfo = &dcontext->dst_mem;
+  p_blt_3d->sDst.SurfOffset = 0;
+  p_blt_3d->sDst.Stride =
+      gst_video_format_get_row_stride (GST_VIDEO_FORMAT_BGRx, 0,
+      pvrvideosink->render_params.ui32Stride);
+  p_blt_3d->sDst.Format = PVR2D_ARGB8888;
+  p_blt_3d->sDst.SurfWidth = pvrvideosink->xwindow->width;
+  p_blt_3d->sDst.SurfHeight = pvrvideosink->xwindow->height;
+
+  p_blt_3d->rcDest.left = result.x;
+  p_blt_3d->rcDest.top = result.y;
+  p_blt_3d->rcDest.right = result.w + result.x;
+  p_blt_3d->rcDest.bottom = result.h + result.y;
+
+  p_blt_3d->sSrc.pSurfMemInfo = src_mem;
+  p_blt_3d->sSrc.SurfOffset = 0;
+  p_blt_3d->sSrc.Stride = pvrvideosink->rowstride;
+  p_blt_3d->sSrc.Format = pvr_format;
+  p_blt_3d->sSrc.SurfWidth = video_width;
+  p_blt_3d->sSrc.SurfHeight = video_height;
+
+  p_blt_3d->rcSource.left = 0;
+  p_blt_3d->rcSource.top = 0;
+  p_blt_3d->rcSource.right = video_width;
+  p_blt_3d->rcSource.bottom = video_height;
+
+  p_blt_3d->hUseCode = NULL;
+
+  if (pvrvideosink->format == GST_VIDEO_FORMAT_NV12)
+    p_blt_3d->bDisableDestInput = TRUE;
+  else
+    /* blit fails for RGB without this... not sure why yet... */
+    p_blt_3d->bDisableDestInput = FALSE;
+
+  pvr_error = PVR2DBlt3DExt (pvrvideosink->dcontext->pvr_context,
+      dcontext->p_blt_info);
+
+  switch (pvr_error) {
+    case PVR2D_OK:
+      break;
+    case PVR2DERROR_DEVICE_UNAVAILABLE:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, device unavailable");
+      goto done;
+      break;
+    case PVR2DERROR_INVALID_CONTEXT:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, invalid context");
+      goto done;
+      break;
+    case PVR2DERROR_INVALID_PARAMETER:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, invalid parameter");
+      goto done;
+      break;
+    case PVR2DERROR_HW_FEATURE_NOT_SUPPORTED:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, "
+          "hardware feature not supported");
+      goto done;
+      break;
+    case PVR2DERROR_GENERIC_ERROR:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, generic error");
+      goto done;
+      break;
+    default:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, "
+          "undefined error %d", pvr_error);
+      goto done;
+      break;
+  }
+  dcontext->wsegl_table->pfnWSEGL_SwapDrawable (dcontext->drawable_handle, 1);
+
+  if (draw_border) {
+    gst_pvrvideosink_xwindow_draw_borders (pvrvideosink, pvrvideosink->xwindow,
+        result);
+    pvrvideosink->redraw_borders = FALSE;
+  }
+  g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+
+done:
+  GST_DEBUG_OBJECT (pvrvideosink, "end");
+  g_mutex_unlock (pvrvideosink->flow_lock);
+}
+
+static void
+gst_pvrvideosink_destroy_drawable (GstPVRVideoSink * pvrvideosink)
+{
+  if (pvrvideosink->dcontext != NULL) {
+    if (pvrvideosink->dcontext->drawable_handle)
+      pvrvideosink->dcontext->
+          wsegl_table->pfnWSEGL_DeleteDrawable (pvrvideosink->dcontext->
+          drawable_handle);
+
+    pvrvideosink->dcontext->wsegl_table->pfnWSEGL_CloseDisplay (pvrvideosink->
+        dcontext->display_handle);
+  }
+}
+
+/* We are called with the x_lock taken */
+static void
+gst_pvrvideosink_pvrfill_rectangle (GstPVRVideoSink * pvrvideosink,
+    GstVideoRectangle rect)
+{
+  PVR2DERROR pvr_error;
+  PPVR2DBLTINFO p_blt2d_info = 0;
+  GstDrawContext *dcontext = pvrvideosink->dcontext;
+
+  GST_DEBUG_OBJECT (pvrvideosink, "begin");
+
+  p_blt2d_info = dcontext->p_blt2d_info;
+
+  p_blt2d_info->pDstMemInfo = &dcontext->dst_mem;
+  p_blt2d_info->BlitFlags = PVR2D_BLIT_DISABLE_ALL;
+  p_blt2d_info->DstOffset = 0;
+  p_blt2d_info->CopyCode = PVR2DROPclear;
+  p_blt2d_info->DstStride =
+      gst_video_format_get_row_stride (GST_VIDEO_FORMAT_BGRx, 0,
+      pvrvideosink->render_params.ui32Stride);
+  p_blt2d_info->DstFormat = PVR2D_ARGB8888;
+  p_blt2d_info->DstSurfWidth = pvrvideosink->xwindow->width;
+  p_blt2d_info->DstSurfHeight = pvrvideosink->xwindow->height;
+  p_blt2d_info->DstX = rect.x;
+  p_blt2d_info->DstY = rect.y;
+  p_blt2d_info->DSizeX = rect.w;
+  p_blt2d_info->DSizeY = rect.h;
+
+  pvr_error = PVR2DBlt (pvrvideosink->dcontext->pvr_context, p_blt2d_info);
+
+  switch (pvr_error) {
+    case PVR2D_OK:
+      break;
+    case PVR2DERROR_DEVICE_UNAVAILABLE:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, device unavailable");
+      goto done;
+      break;
+    case PVR2DERROR_INVALID_CONTEXT:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, invalid context");
+      goto done;
+      break;
+    case PVR2DERROR_INVALID_PARAMETER:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, invalid parameter");
+      goto done;
+      break;
+    case PVR2DERROR_HW_FEATURE_NOT_SUPPORTED:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, "
+          "hardware feature not supported");
+      goto done;
+      break;
+    case PVR2DERROR_GENERIC_ERROR:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, generic error");
+      goto done;
+      break;
+    default:
+      GST_ERROR_OBJECT (pvrvideosink, "Failed to blit, "
+          "undefined error %d", pvr_error);
+      goto done;
+      break;
+  }
+  dcontext->wsegl_table->pfnWSEGL_SwapDrawable (dcontext->drawable_handle, 1);
+
+done:
+  GST_DEBUG_OBJECT (pvrvideosink, "end");
+}
+
+/* We are called with the x_lock taken */
+static void
+gst_pvrvideosink_xwindow_draw_borders (GstPVRVideoSink * pvrvideosink,
+    GstXWindow * xwindow, GstVideoRectangle rect)
+{
+  gint t1, t2;
+  GstVideoRectangle result;
+
+  g_return_if_fail (GST_IS_PVRVIDEOSINK (pvrvideosink));
+  g_return_if_fail (xwindow != NULL);
+
+  /* Left border */
+  result.x = pvrvideosink->render_rect.x;
+  result.y = pvrvideosink->render_rect.y;
+  result.w = rect.x - pvrvideosink->render_rect.x;
+  result.h = pvrvideosink->render_rect.h;
+  if (rect.x > pvrvideosink->render_rect.x)
+    gst_pvrvideosink_pvrfill_rectangle (pvrvideosink, result);
+
+  /* Right border */
+  t1 = rect.x + rect.w;
+  t2 = pvrvideosink->render_rect.x + pvrvideosink->render_rect.w;
+  result.x = t1;
+  result.y = pvrvideosink->render_rect.y;
+  result.w = t2 - t1;
+  result.h = pvrvideosink->render_rect.h;
+  if (t1 < t2)
+    gst_pvrvideosink_pvrfill_rectangle (pvrvideosink, result);
+
+  /* Top border */
+  result.x = pvrvideosink->render_rect.x;
+  result.y = pvrvideosink->render_rect.y;
+  result.w = pvrvideosink->render_rect.w;
+  result.h = rect.y - pvrvideosink->render_rect.y;
+  if (rect.y > pvrvideosink->render_rect.y)
+    gst_pvrvideosink_pvrfill_rectangle (pvrvideosink, result);
+
+  /* Bottom border */
+  t1 = rect.y + rect.h;
+  t2 = pvrvideosink->render_rect.y + pvrvideosink->render_rect.h;
+  result.x = pvrvideosink->render_rect.x;
+  result.y = t1;
+  result.w = pvrvideosink->render_rect.w;
+  result.h = t2 - t1;
+  if (t1 < t2)
+    gst_pvrvideosink_pvrfill_rectangle (pvrvideosink, result);
+}
+
+/* Element stuff */
+
+static gboolean
+gst_pvrvideosink_setcaps (GstBaseSink * bsink, GstCaps * caps)
+{
+  GstPVRVideoSink *pvrvideosink;
+  gboolean ret = TRUE;
+  GstStructure *structure;
+  gint new_width, new_height;
+  const GValue *fps;
+  GstQuery *query;
+
+  pvrvideosink = GST_PVRVIDEOSINK (bsink);
+
+  GST_DEBUG_OBJECT (pvrvideosink,
+      "sinkconnect possible caps with given caps %", caps);
+
+  structure = gst_caps_get_structure (caps, 0);
+
+  ret = gst_video_format_parse_caps_strided (caps, &pvrvideosink->format,
+      &new_width, &new_height, &pvrvideosink->rowstride);
+  if (pvrvideosink->rowstride == 0)
+    pvrvideosink->rowstride =
+        gst_video_format_get_row_stride (pvrvideosink->format, 0, new_width);
+  fps = gst_structure_get_value (structure, "framerate");
+  ret &= (fps != NULL);
+  if (!ret) {
+    GST_ERROR_OBJECT (pvrvideosink, "problem at parsing caps");
+    return FALSE;
+  }
+
+  if (pvrvideosink->current_caps) {
+    GST_DEBUG_OBJECT (pvrvideosink, "already have caps set");
+    if (gst_caps_is_equal (pvrvideosink->current_caps, caps)) {
+      GST_DEBUG_OBJECT (pvrvideosink, "caps are equal!");
+      return TRUE;
+    }
+    GST_DEBUG_OBJECT (pvrvideosink, "caps are different");
+  }
+
+  g_mutex_lock (pvrvideosink->pool_lock);
+  if (pvrvideosink->buffer_pool) {
+    if (!gst_caps_is_equal (pvrvideosink->buffer_pool->caps, caps)) {
+      GST_INFO_OBJECT (pvrvideosink, "in set caps, pool->caps != caps");
+      gst_pvr_bufferpool_stop_running (pvrvideosink->buffer_pool, FALSE);
+      pvrvideosink->buffer_pool = NULL;
+    }
+  }
+  g_mutex_unlock (pvrvideosink->pool_lock);
+
+  /* query to find if anyone upstream using these buffers has any
+   * minimum requirements:
+   */
+  query = gst_query_new_buffers (caps);
+  if (gst_element_query (GST_ELEMENT (pvrvideosink), query)) {
+    gint min_buffers;
+
+    gst_query_parse_buffers_count (query, &min_buffers);
+
+    GST_DEBUG_OBJECT (pvrvideosink, "min_buffers=%d", min_buffers);
+
+    /* XXX need to account for some buffers used by queue, etc.. probably
+     * queue should handle query, pass on to sink pad, and then add some
+     * number of buffers to the min, so this value is dynamic depending
+     * on the pipeline?
+     */
+    if (min_buffers != -1) {
+      min_buffers += 3 + pvrvideosink->min_queued_bufs;
+      pvrvideosink->num_buffers_can_change = FALSE;
+    }
+
+    if (min_buffers > pvrvideosink->num_buffers) {
+      pvrvideosink->num_buffers = min_buffers;
+    }
+  }
+  gst_query_unref (query);
+
+  /* Notify application to set xwindow id now */
+  g_mutex_lock (pvrvideosink->flow_lock);
+  if (!pvrvideosink->xwindow) {
+    g_mutex_unlock (pvrvideosink->flow_lock);
+    gst_x_overlay_prepare_xwindow_id (GST_X_OVERLAY (pvrvideosink));
+  } else {
+    g_mutex_unlock (pvrvideosink->flow_lock);
+  }
+  GST_VIDEO_SINK_WIDTH (pvrvideosink) = new_width;
+  GST_VIDEO_SINK_HEIGHT (pvrvideosink) = new_height;
+
+  g_mutex_lock (pvrvideosink->flow_lock);
+  if (!pvrvideosink->xwindow)
+    pvrvideosink->xwindow = gst_pvrvideosink_create_window (pvrvideosink,
+        new_width, new_height);
+  g_mutex_unlock (pvrvideosink->flow_lock);
+
+  pvrvideosink->fps_n = gst_value_get_fraction_numerator (fps);
+  pvrvideosink->fps_d = gst_value_get_fraction_denominator (fps);
+
+  pvrvideosink->current_caps = gst_caps_ref (caps);
+
+  return TRUE;
+}
+
+static GstCaps *
+gst_pvrvideosink_getcaps (GstBaseSink * bsink)
+{
+  GstPVRVideoSink *pvrvideosink;
+  GstCaps *caps;
+
+  pvrvideosink = GST_PVRVIDEOSINK (bsink);
+
+  caps = gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SINK
+          (pvrvideosink)->sinkpad));
+  return caps;
+}
+
+static GstStateChangeReturn
+gst_pvrvideosink_change_state (GstElement * element, GstStateChange transition)
+{
+  GstPVRVideoSink *pvrvideosink;
+  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
+  GstDrawContext *dcontext;
+
+  pvrvideosink = GST_PVRVIDEOSINK (element);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_NULL_TO_READY:
+      if (pvrvideosink->dcontext == NULL) {
+        dcontext = gst_pvrvideosink_get_dcontext (pvrvideosink);
+        if (dcontext == NULL)
+          return GST_STATE_CHANGE_FAILURE;
+        GST_OBJECT_LOCK (pvrvideosink);
+        pvrvideosink->dcontext = dcontext;
+        GST_OBJECT_UNLOCK (pvrvideosink);
+      }
+      gst_pvrvideosink_manage_event_thread (pvrvideosink);
+      break;
+    case GST_STATE_CHANGE_READY_TO_PAUSED:
+      g_mutex_lock (pvrvideosink->pool_lock);
+      pvrvideosink->pool_invalid = FALSE;
+      g_mutex_unlock (pvrvideosink->pool_lock);
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      g_mutex_lock (pvrvideosink->pool_lock);
+      pvrvideosink->pool_invalid = TRUE;
+      g_mutex_unlock (pvrvideosink->pool_lock);
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
+      break;
+    default:
+      break;
+  }
+
+  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
+
+  switch (transition) {
+    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
+      break;
+    case GST_STATE_CHANGE_PAUSED_TO_READY:
+      pvrvideosink->fps_n = 0;
+      pvrvideosink->fps_d = 1;
+      GST_VIDEO_SINK_WIDTH (pvrvideosink) = 0;
+      GST_VIDEO_SINK_HEIGHT (pvrvideosink) = 0;
+      break;
+    case GST_STATE_CHANGE_READY_TO_NULL:
+      gst_pvrvideosink_reset (pvrvideosink);
+      break;
+    default:
+      break;
+  }
+
+  return ret;
+}
+
+static void
+gst_pvrvideosink_get_times (GstBaseSink * bsink, GstBuffer * buf,
+    GstClockTime * start, GstClockTime * end)
+{
+  GstPVRVideoSink *pvrvideosink;
+
+  pvrvideosink = GST_PVRVIDEOSINK (bsink);
+
+  if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
+    *start = GST_BUFFER_TIMESTAMP (buf);
+    if (GST_BUFFER_DURATION_IS_VALID (buf)) {
+      *end = *start + GST_BUFFER_DURATION (buf);
+    } else {
+      if (pvrvideosink->fps_n > 0) {
+        *end = *start +
+            gst_util_uint64_scale_int (GST_SECOND, pvrvideosink->fps_d,
+            pvrvideosink->fps_n);
+      }
+    }
+  }
+}
+
+static GstFlowReturn
+gst_pvrvideosink_show_frame (GstBaseSink * vsink, GstBuffer * buf)
+{
+  GstPVRVideoSink *pvrvideosink;
+  GstBuffer *newbuf = NULL;
+  g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
+
+  pvrvideosink = GST_PVRVIDEOSINK (vsink);
+
+  GST_DEBUG_OBJECT (pvrvideosink, "render buffer: %p", buf);
+
+  if (!GST_IS_BUFFER (buf)) {
+    GstFlowReturn ret;
+
+    /* special case check for sub-buffers:  In certain cases, places like
+     * GstBaseTransform, which might check that the buffer is writable
+     * before copying metadata, timestamp, and such, will find that the
+     * buffer has more than one reference to it.  In these cases, they
+     * will create a sub-buffer with an offset=0 and length equal to the
+     * original buffer size.
+     *
+     * This could happen in two scenarios: (1) a tee in the pipeline, and
+     * (2) because the refcnt is incremented in gst_mini_object_free()
+     * before the finalize function is called, and decremented after it
+     * returns..  but returning this buffer to the buffer pool in the
+     * finalize function, could wake up a thread blocked in _buffer_alloc()
+     * which could run and get a buffer w/ refcnt==2 before the thread
+     * originally unref'ing the buffer returns from finalize function and
+     * decrements the refcnt back to 1!
+     */
+    if (buf->parent &&
+        (GST_BUFFER_DATA (buf) == GST_BUFFER_DATA (buf->parent)) &&
+        (GST_BUFFER_SIZE (buf) == GST_BUFFER_SIZE (buf->parent))) {
+      GST_DEBUG_OBJECT (pvrvideosink, "I have a sub-buffer!");
+      return gst_pvrvideosink_show_frame (vsink, buf->parent);
+    }
+
+    GST_DEBUG_OBJECT (pvrvideosink,
+        "slow-path.. I got a %s so I need to memcpy",
+        g_type_name (G_OBJECT_TYPE (buf)));
+
+    ret = gst_pvrvideosink_buffer_alloc (GST_BASE_SINK (vsink),
+        GST_BUFFER_OFFSET (buf), GST_BUFFER_SIZE (buf), GST_BUFFER_CAPS (buf),
+        &newbuf);
+
+    if (GST_FLOW_OK != ret) {
+      GST_DEBUG_OBJECT (pvrvideosink, "dropping frame!!");
+      return GST_FLOW_OK;
+    }
+
+    memcpy (GST_BUFFER_DATA (newbuf),
+        GST_BUFFER_DATA (buf),
+        MIN (GST_BUFFER_SIZE (newbuf), GST_BUFFER_SIZE (buf)));
+
+    GST_DEBUG_OBJECT (pvrvideosink, "render copied buffer: %p", newbuf);
+
+    buf = newbuf;
+  }
+
+  gst_pvrvideosink_blit (pvrvideosink, buf);
+
+  if (newbuf) {
+    gst_buffer_unref (newbuf);
+  }
+
+  return GST_FLOW_OK;
+}
+
+
+/* Buffer management
+ *
+ * The buffer_alloc function must either return a buffer with given size and
+ * caps or create a buffer with different caps attached to the buffer. This
+ * last option is called reverse negotiation, ie, where the sink suggests a
+ * different format from the upstream peer. 
+ *
+ * We try to do reverse negotiation when our geometry changes and we like a
+ * resized buffer.
+ */
+static GstFlowReturn
+gst_pvrvideosink_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size,
+    GstCaps * caps, GstBuffer ** buf)
+{
+  GstPVRVideoSink *pvrvideosink;
+  GstDucatiBuffer *pvrvideo = NULL;
+  GstStructure *structure = NULL;
+  GstFlowReturn ret = GST_FLOW_OK;
+  gint width, height;
+
+  pvrvideosink = GST_PVRVIDEOSINK (bsink);
+
+  GST_DEBUG_OBJECT (pvrvideosink, "begin");
+
+  if (G_UNLIKELY (!caps)) {
+    GST_WARNING_OBJECT (pvrvideosink,
+        "have no caps, doing fallback allocation");
+    *buf = NULL;
+    ret = GST_FLOW_OK;
+    goto beach;
+  }
+
+  g_mutex_lock (pvrvideosink->pool_lock);
+  if (G_UNLIKELY (pvrvideosink->pool_invalid)) {
+    GST_DEBUG_OBJECT (pvrvideosink, "the pool is flushing");
+    ret = GST_FLOW_WRONG_STATE;
+    g_mutex_unlock (pvrvideosink->pool_lock);
+    goto beach;
+  } else {
+    g_mutex_unlock (pvrvideosink->pool_lock);
+  }
+
+  GST_LOG_OBJECT (pvrvideosink,
+      "a buffer of %d bytes was requested with caps %" GST_PTR_FORMAT
+      " and offset %" G_GUINT64_FORMAT, size, caps, offset);
+
+  /* get struct to see what is requested */
+  structure = gst_caps_get_structure (caps, 0);
+  if (!gst_structure_get_int (structure, "width", &width) ||
+      !gst_structure_get_int (structure, "height", &height)) {
+    GST_WARNING_OBJECT (pvrvideosink, "invalid caps for buffer allocation %"
+        GST_PTR_FORMAT, caps);
+    ret = GST_FLOW_NOT_NEGOTIATED;
+    goto beach;
+  }
+
+  g_mutex_lock (pvrvideosink->pool_lock);
+  /* initialize the buffer pool if not initialized yet */
+  if (G_UNLIKELY (!pvrvideosink->buffer_pool ||
+          pvrvideosink->buffer_pool->size != size)) {
+    if (pvrvideosink->buffer_pool) {
+      GST_INFO_OBJECT (pvrvideosink, "in buffer alloc, pool->size != size");
+      gst_pvr_bufferpool_stop_running (pvrvideosink->buffer_pool, FALSE);
+    }
+
+    GST_LOG_OBJECT (pvrvideosink, "Creating a buffer pool with %d buffers",
+        pvrvideosink->num_buffers);
+    if (!(pvrvideosink->buffer_pool =
+            gst_pvr_bufferpool_new (GST_ELEMENT (pvrvideosink),
+                caps, pvrvideosink->num_buffers, size,
+                pvrvideosink->dcontext->pvr_context))) {
+      g_mutex_unlock (pvrvideosink->pool_lock);
+      return GST_FLOW_ERROR;
+    }
+  }
+  pvrvideo = gst_pvr_bufferpool_get (pvrvideosink->buffer_pool, NULL);
+  g_mutex_unlock (pvrvideosink->pool_lock);
+
+  *buf = GST_BUFFER_CAST (pvrvideo);
+
+beach:
+  return ret;
+}
+
+/* Interfaces stuff */
+
+static gboolean
+gst_pvrvideosink_interface_supported (GstImplementsInterface * iface,
+    GType type)
+{
+  if (type == GST_TYPE_X_OVERLAY)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+static void
+gst_pvrvideosink_interface_init (GstImplementsInterfaceClass * klass)
+{
+  klass->supported = gst_pvrvideosink_interface_supported;
+}
+
+/* This function destroys a GstXWindow */
+static void
+gst_pvrvideosink_xwindow_destroy (GstPVRVideoSink * pvrvideosink,
+    GstXWindow * xwindow)
+{
+  g_return_if_fail (xwindow != NULL);
+
+  g_mutex_lock (pvrvideosink->dcontext->x_lock);
+
+  /* If we did not create that window we just free the GC and let it live */
+  if (xwindow->internal)
+    XDestroyWindow (pvrvideosink->dcontext->x_display, xwindow->window);
+  else
+    XSelectInput (pvrvideosink->dcontext->x_display, xwindow->window, 0);
+
+  XFreeGC (pvrvideosink->dcontext->x_display, xwindow->gc);
+
+  XSync (pvrvideosink->dcontext->x_display, FALSE);
+
+  g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+
+  g_free (xwindow);
+}
+
+static void
+gst_pvrvideosink_set_window_handle (GstXOverlay * overlay, guintptr id)
+{
+  XID xwindow_id = id;
+  GstPVRVideoSink *pvrvideosink = GST_PVRVIDEOSINK (overlay);
+  GstXWindow *xwindow = NULL;
+
+  g_return_if_fail (GST_IS_PVRVIDEOSINK (pvrvideosink));
+
+  g_mutex_lock (pvrvideosink->flow_lock);
+
+  /* If we already use that window return */
+  if (pvrvideosink->xwindow && (xwindow_id == pvrvideosink->xwindow->window)) {
+    g_mutex_unlock (pvrvideosink->flow_lock);
+    return;
+  }
+
+  /* If the element has not initialized the X11 context try to do so */
+  if (!pvrvideosink->dcontext && !(pvrvideosink->dcontext =
+          gst_pvrvideosink_get_dcontext (pvrvideosink))) {
+    g_mutex_unlock (pvrvideosink->flow_lock);
+    /* we have thrown a GST_ELEMENT_ERROR now */
+    return;
+  }
+
+  /* Clear image pool as the images are unusable anyway */
+  g_mutex_lock (pvrvideosink->pool_lock);
+  if (pvrvideosink->buffer_pool) {
+    gst_pvr_bufferpool_stop_running (pvrvideosink->buffer_pool, FALSE);
+    pvrvideosink->buffer_pool = NULL;
+  }
+  g_mutex_unlock (pvrvideosink->pool_lock);
+
+  /* If a window is there already we destroy it */
+  if (pvrvideosink->xwindow) {
+    gst_pvrvideosink_xwindow_destroy (pvrvideosink, pvrvideosink->xwindow);
+    pvrvideosink->xwindow = NULL;
+  }
+
+  /* If the xid is 0 we will create an internal one in buffer_alloc */
+  if (xwindow_id != 0) {
+    XWindowAttributes attr;
+    WSEGLError glerror;
+    WSEGLDrawableParams source_params;
+    PVRSRV_CLIENT_MEM_INFO *client_mem_info;
+
+    xwindow = g_new0 (GstXWindow, 1);
+    xwindow->window = xwindow_id;
+
+    /* Set the event we want to receive and create a GC */
+    g_mutex_lock (pvrvideosink->dcontext->x_lock);
+
+    XGetWindowAttributes (pvrvideosink->dcontext->x_display, xwindow->window,
+        &attr);
+
+    xwindow->width = attr.width;
+    xwindow->height = attr.height;
+    xwindow->internal = FALSE;
+    if (!pvrvideosink->have_render_rect) {
+      pvrvideosink->render_rect.x = pvrvideosink->render_rect.y = 0;
+      pvrvideosink->render_rect.w = attr.width;
+      pvrvideosink->render_rect.h = attr.height;
+    }
+    XSelectInput (pvrvideosink->dcontext->x_display, xwindow->window,
+        ExposureMask | StructureNotifyMask);
+
+    XSetWindowBackgroundPixmap (pvrvideosink->dcontext->x_display,
+        xwindow->window, None);
+
+    XMapWindow (pvrvideosink->dcontext->x_display, xwindow->window);
+    xwindow->gc = XCreateGC (pvrvideosink->dcontext->x_display,
+        xwindow->window, 0, NULL);
+    g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+
+    glerror =
+        pvrvideosink->dcontext->
+        wsegl_table->pfnWSEGL_CreateWindowDrawable (pvrvideosink->dcontext->
+        display_handle, pvrvideosink->dcontext->glconfig,
+        &(pvrvideosink->dcontext->drawable_handle),
+        (NativeWindowType) xwindow->window,
+        &(pvrvideosink->dcontext->rotation));
+
+    if (glerror != WSEGL_SUCCESS) {
+      GST_ERROR_OBJECT (pvrvideosink, "Error creating drawable");
+      return;
+    }
+    glerror =
+        pvrvideosink->dcontext->
+        wsegl_table->pfnWSEGL_GetDrawableParameters (pvrvideosink->dcontext->
+        drawable_handle, &source_params, &pvrvideosink->render_params);
+
+    client_mem_info =
+        (PVRSRV_CLIENT_MEM_INFO *) pvrvideosink->render_params.hPrivateData;
+    PVR2DMEMINFO_INITIALISE (&pvrvideosink->dcontext->dst_mem, client_mem_info);
+  }
+
+  if (xwindow)
+    pvrvideosink->xwindow = xwindow;
+
+  g_mutex_unlock (pvrvideosink->flow_lock);
+}
+
+static void
+gst_pvrvideosink_expose (GstXOverlay * overlay)
+{
+  GstPVRVideoSink *pvrvideosink = GST_PVRVIDEOSINK (overlay);
+
+  gst_pvrvideosink_blit (pvrvideosink, NULL);
+}
+
+static void
+gst_pvrvideosink_set_event_handling (GstXOverlay * overlay,
+    gboolean handle_events)
+{
+  GstPVRVideoSink *pvrvideosink = GST_PVRVIDEOSINK (overlay);
+
+  g_mutex_lock (pvrvideosink->flow_lock);
+
+  if (G_UNLIKELY (!pvrvideosink->xwindow)) {
+    g_mutex_unlock (pvrvideosink->flow_lock);
+    return;
+  }
+
+  g_mutex_lock (pvrvideosink->dcontext->x_lock);
+
+  XSelectInput (pvrvideosink->dcontext->x_display,
+      pvrvideosink->xwindow->window, ExposureMask | StructureNotifyMask);
+
+  g_mutex_unlock (pvrvideosink->dcontext->x_lock);
+
+  g_mutex_unlock (pvrvideosink->flow_lock);
+}
+
+static void
+gst_pvrvideosink_set_render_rectangle (GstXOverlay * overlay, gint x, gint y,
+    gint width, gint height)
+{
+  GstPVRVideoSink *pvrvideosink = GST_PVRVIDEOSINK (overlay);
+
+  /* FIXME: how about some locking? */
+  if (width >= 0 && height >= 0) {
+    pvrvideosink->render_rect.x = x;
+    pvrvideosink->render_rect.y = y;
+    pvrvideosink->render_rect.w = width;
+    pvrvideosink->render_rect.h = height;
+    pvrvideosink->have_render_rect = TRUE;
+  } else {
+    pvrvideosink->render_rect.x = 0;
+    pvrvideosink->render_rect.y = 0;
+    pvrvideosink->render_rect.w = pvrvideosink->xwindow->width;
+    pvrvideosink->render_rect.h = pvrvideosink->xwindow->height;
+    pvrvideosink->have_render_rect = FALSE;
+  }
+}
+
+static void
+gst_pvrvideosink_xoverlay_init (GstXOverlayClass * iface)
+{
+  iface->set_window_handle = gst_pvrvideosink_set_window_handle;
+  iface->expose = gst_pvrvideosink_expose;
+  iface->handle_events = gst_pvrvideosink_set_event_handling;
+  iface->set_render_rectangle = gst_pvrvideosink_set_render_rectangle;
+}
+
+/* =========================================== */
+/*                                             */
+/*              Init & Class init              */
+/*                                             */
+/* =========================================== */
+
+static void
+gst_pvrvideosink_set_property (GObject * object, guint prop_id,
+    const GValue * value, GParamSpec * pspec)
+{
+  GstPVRVideoSink *pvrvideosink;
+
+  g_return_if_fail (GST_IS_PVRVIDEOSINK (object));
+
+  pvrvideosink = GST_PVRVIDEOSINK (object);
+
+  switch (prop_id) {
+    case PROP_FORCE_ASPECT_RATIO:
+      pvrvideosink->keep_aspect = g_value_get_boolean (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_pvrvideosink_get_property (GObject * object, guint prop_id,
+    GValue * value, GParamSpec * pspec)
+{
+  GstPVRVideoSink *pvrvideosink;
+
+  g_return_if_fail (GST_IS_PVRVIDEOSINK (object));
+
+  pvrvideosink = GST_PVRVIDEOSINK (object);
+
+  switch (prop_id) {
+    case PROP_FORCE_ASPECT_RATIO:
+      g_value_set_boolean (value, pvrvideosink->keep_aspect);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void
+gst_pvrvideosink_dcontext_clear (GstPVRVideoSink * pvrvideosink)
+{
+  GstDrawContext *dcontext;
+
+  GST_OBJECT_LOCK (pvrvideosink);
+  if (!pvrvideosink->dcontext) {
+    GST_OBJECT_UNLOCK (pvrvideosink);
+    return;
+  }
+
+  dcontext = pvrvideosink->dcontext;
+  pvrvideosink->dcontext = NULL;
+  GST_OBJECT_UNLOCK (pvrvideosink);
+
+  if (dcontext->p_blt_info)
+    g_free (dcontext->p_blt_info);
+
+  g_mutex_lock (dcontext->x_lock);
+  XCloseDisplay (dcontext->x_display);
+  g_mutex_unlock (dcontext->x_lock);
+  g_mutex_free (dcontext->x_lock);
+
+  g_free (dcontext);
+}
+
+static void
+gst_pvrvideosink_reset (GstPVRVideoSink * pvrvideosink)
+{
+  GThread *thread;
+
+  GST_OBJECT_LOCK (pvrvideosink);
+  pvrvideosink->running = FALSE;
+  thread = pvrvideosink->event_thread;
+  pvrvideosink->event_thread = NULL;
+  GST_OBJECT_UNLOCK (pvrvideosink);
+
+  if (thread)
+    g_thread_join (thread);
+
+  if (pvrvideosink->current_buffer) {
+    gst_buffer_unref (pvrvideosink->current_buffer);
+    pvrvideosink->current_buffer = NULL;
+  }
+
+  g_mutex_lock (pvrvideosink->pool_lock);
+  pvrvideosink->pool_invalid = TRUE;
+  if (pvrvideosink->buffer_pool) {
+    gst_pvr_bufferpool_stop_running (pvrvideosink->buffer_pool, TRUE);
+    pvrvideosink->buffer_pool = NULL;
+  }
+  g_mutex_unlock (pvrvideosink->pool_lock);
+  memset (&pvrvideosink->render_params, 0, sizeof (WSEGLDrawableParams));
+
+  pvrvideosink->render_rect.x = pvrvideosink->render_rect.y = 0;
+  pvrvideosink->render_rect.w = pvrvideosink->render_rect.h = 0;
+  pvrvideosink->have_render_rect = FALSE;
+
+  gst_pvrvideosink_destroy_drawable (pvrvideosink);
+
+  if (pvrvideosink->xwindow) {
+    gst_pvrvideosink_xwindow_destroy (pvrvideosink, pvrvideosink->xwindow);
+    pvrvideosink->xwindow = NULL;
+  }
+
+  gst_pvrvideosink_dcontext_clear (pvrvideosink);
+}
+
+static void
+gst_pvrvideosink_finalize (GObject * object)
+{
+  GstPVRVideoSink *pvrvideosink;
+
+  pvrvideosink = GST_PVRVIDEOSINK (object);
+
+  gst_pvrvideosink_reset (pvrvideosink);
+
+  if (pvrvideosink->flow_lock) {
+    g_mutex_free (pvrvideosink->flow_lock);
+    pvrvideosink->flow_lock = NULL;
+  }
+  if (pvrvideosink->pool_lock) {
+    g_mutex_free (pvrvideosink->pool_lock);
+    pvrvideosink->pool_lock = NULL;
+  }
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gst_pvrvideosink_init (GstPVRVideoSink * pvrvideosink)
+{
+  pvrvideosink->running = FALSE;
+
+  pvrvideosink->fps_n = 0;
+  pvrvideosink->fps_d = 1;
+
+  pvrvideosink->flow_lock = g_mutex_new ();
+  pvrvideosink->pool_lock = g_mutex_new ();
+  pvrvideosink->buffer_pool = NULL;
+  pvrvideosink->pool_invalid = TRUE;
+
+  pvrvideosink->keep_aspect = FALSE;
+  pvrvideosink->current_caps = NULL;
+  pvrvideosink->num_buffers = DEFAULT_QUEUE_SIZE;
+  pvrvideosink->num_buffers_can_change = TRUE;
+  pvrvideosink->min_queued_bufs = DEFAULT_MIN_QUEUED_BUFS;
+  pvrvideosink->dcontext = NULL;
+  pvrvideosink->xwindow = NULL;
+  pvrvideosink->redraw_borders = TRUE;
+  pvrvideosink->current_buffer = NULL;
+  pvrvideosink->event_thread = NULL;
+  memset (&pvrvideosink->render_params, 0, sizeof (WSEGLDrawableParams));
+}
+
+static void
+gst_pvrvideosink_base_init (gpointer g_class)
+{
+  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+
+  gst_element_class_set_details_simple (element_class,
+      "PVR Video sink", "Sink/Video",
+      "A PVR videosink",
+      "Luciana Fujii Pontello <luciana.fujii@collabora.co.uk");
+
+  gst_element_class_add_pad_template (element_class,
+      gst_static_pad_template_get (&gst_pvrvideosink_sink_template_factory));
+}
+
+static void
+gst_pvrvideosink_class_init (GstPVRVideoSinkClass * klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+  GstBaseSinkClass *gstbasesink_class;
+
+  gobject_class = (GObjectClass *) klass;
+  gstelement_class = (GstElementClass *) klass;
+  gstbasesink_class = (GstBaseSinkClass *) klass;
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  gobject_class->finalize = gst_pvrvideosink_finalize;
+  gobject_class->set_property = gst_pvrvideosink_set_property;
+  gobject_class->get_property = gst_pvrvideosink_get_property;
+
+  g_object_class_install_property (gobject_class, PROP_FORCE_ASPECT_RATIO,
+      g_param_spec_boolean ("force-aspect-ratio", "Force aspect ratio",
+          "When enabled, reverse caps negotiation (scaling) will respect "
+          "original aspect ratio", FALSE,
+          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+  gstelement_class->change_state = gst_pvrvideosink_change_state;
+
+  gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_pvrvideosink_setcaps);
+  gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_pvrvideosink_getcaps);
+  gstbasesink_class->buffer_alloc =
+      GST_DEBUG_FUNCPTR (gst_pvrvideosink_buffer_alloc);
+  gstbasesink_class->get_times = GST_DEBUG_FUNCPTR (gst_pvrvideosink_get_times);
+
+  gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_pvrvideosink_show_frame);
+}
+
+/* ============================================================= */
+/*                                                               */
+/*                       Public Methods                          */
+/*                                                               */
+/* ============================================================= */
+
+/* =========================================== */
+/*                                             */
+/*          Object typing & Creation           */
+/*                                             */
+/* =========================================== */
+
+GType
+gst_pvrvideosink_get_type (void)
+{
+  static GType pvrvideosink_type = 0;
+
+  if (!pvrvideosink_type) {
+    static const GTypeInfo pvrvideosink_info = {
+      sizeof (GstPVRVideoSinkClass),
+      gst_pvrvideosink_base_init,
+      NULL,
+      (GClassInitFunc) gst_pvrvideosink_class_init,
+      NULL,
+      NULL,
+      sizeof (GstPVRVideoSink), 0, (GInstanceInitFunc) gst_pvrvideosink_init,
+    };
+    static const GInterfaceInfo iface_info = {
+      (GInterfaceInitFunc) gst_pvrvideosink_interface_init, NULL, NULL,
+    };
+    static const GInterfaceInfo overlay_info = {
+      (GInterfaceInitFunc) gst_pvrvideosink_xoverlay_init, NULL, NULL,
+    };
+
+    pvrvideosink_type = g_type_register_static (GST_TYPE_VIDEO_SINK,
+        "GstPVRVideoSink", &pvrvideosink_info, 0);
+
+    g_type_add_interface_static (pvrvideosink_type,
+        GST_TYPE_IMPLEMENTS_INTERFACE, &iface_info);
+    g_type_add_interface_static (pvrvideosink_type, GST_TYPE_X_OVERLAY,
+        &overlay_info);
+  }
+
+  return pvrvideosink_type;
+}
diff --git a/sys/pvr2d/gstpvrvideosink.h b/sys/pvr2d/gstpvrvideosink.h
new file mode 100644
index 000000000..45f6a129e
--- /dev/null
+++ b/sys/pvr2d/gstpvrvideosink.h
@@ -0,0 +1,157 @@
+/* GStreamer
+ *
+ * Copyright (C) 2011 - Collabora Ltda
+ * Copyright (C) 2011 - Texas Instruments
+ *  @author: Luciana Fujii Pontello <luciana.fujii@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GST_PVRVIDEOSINK_H__
+#define __GST_PVRVIDEOSINK_H__
+
+#include <gst/video/gstvideosink.h>
+#include <gst/video/video.h>
+#include "gstpvrbufferpool.h"
+
+#include <string.h>
+#include <math.h>
+#include <pvr2d.h>
+#include <EGL/egl.h>
+#include <wsegl.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+G_BEGIN_DECLS
+#define GST_TYPE_PVRVIDEOSINK (gst_pvrvideosink_get_type())
+#define GST_PVRVIDEOSINK(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_PVRVIDEOSINK, GstPVRVideoSink))
+#define GST_PVRVIDEOSINK_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_PVRVIDEOSINK, GstPVRVideoSinkClass))
+#define GST_IS_PVRVIDEOSINK(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_PVRVIDEOSINK))
+#define GST_IS_PVRVIDEOSINK_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_PVRVIDEOSINK))
+typedef struct _GstDrawContext GstDrawContext;
+typedef struct _GstXWindow GstXWindow;
+
+typedef struct _GstPVRVideoBuffer GstPVRVideoBuffer;
+typedef struct _GstPVRVideoBufferClass GstPVRVideoBufferClass;
+
+typedef struct _GstPVRVideoSink GstPVRVideoSink;
+typedef struct _GstPVRVideoSinkClass GstPVRVideoSinkClass;
+
+struct _GstDrawContext
+{
+  /* PVR2D */
+  PVR2DCONTEXTHANDLE pvr_context;
+  PVR2DMEMINFO dst_mem;
+  PPVR2D_3DBLT_EXT p_blt_info;
+  PPVR2DBLTINFO p_blt2d_info;
+
+  long stride;
+  PVR2DFORMAT display_format;
+  long display_width;
+  long display_height;
+
+  /* WSEGL */
+  const WSEGL_FunctionTable *wsegl_table;
+
+  WSEGLDisplayHandle display_handle;
+  const WSEGLCaps **glcaps;
+  WSEGLConfig *glconfig;
+  WSEGLDrawableHandle drawable_handle;
+  WSEGLRotationAngle rotation;
+
+  GMutex *x_lock;
+  Display *x_display;
+  gint screen_num;
+  gulong black;
+};
+
+struct _GstXWindow
+{
+  Window window;
+  gint width, height;
+  gboolean internal;
+  GC gc;
+};
+
+
+/**
+ * GstPVRVideoSink:
+ * @running: used to inform @event_thread if it should run/shutdown
+ * @fps_n: the framerate fraction numerator
+ * @fps_d: the framerate fraction denominator
+ * @flow_lock: used to protect data flow routines from external calls such as
+ * events from @event_thread or methods from the #GstXOverlay interface
+ * @pool_lock: used to protect the buffer pool
+ * @x_lock: used to protect X calls
+ * @buffer_pool: a list of #GstPVRVideoBuffer that could be reused at next buffer
+ * allocation call
+ * @keep_aspect: used to remember if reverse negotiation scaling should respect
+ * aspect ratio
+ *
+ * The #GstPVRVideoSink data structure.
+ */
+struct _GstPVRVideoSink
+{
+  /* Our element stuff */
+  GstVideoSink videosink;
+
+  gboolean running;
+
+  /* Framerate numerator and denominator */
+  GstVideoFormat format;
+  gint fps_n;
+  gint fps_d;
+  gint rowstride;
+
+  GThread *event_thread;
+  GMutex *flow_lock;
+
+  GMutex *pool_lock;
+  GstPvrBufferPool *buffer_pool;
+  gboolean pool_invalid;
+  gint num_buffers;
+  gboolean num_buffers_can_change;
+  gint min_queued_bufs;
+
+  gboolean keep_aspect;
+
+  GstCaps *current_caps;
+  GstDrawContext *dcontext;
+  GstXWindow *xwindow;
+
+  GstVideoRectangle render_rect;
+  gboolean have_render_rect;
+
+  gchar *media_title;
+  gboolean redraw_borders;
+  GstBuffer *current_buffer;
+
+  WSEGLDrawableParams render_params;
+};
+
+struct _GstPVRVideoSinkClass
+{
+  GstVideoSinkClass parent_class;
+};
+
+GType gst_pvrvideosink_get_type (void);
+
+G_END_DECLS
+#endif /* __GST_PVRVIDEOSINK_H__ */
diff --git a/sys/pvr2d/pvr_includes/dri2_ws.h b/sys/pvr2d/pvr_includes/dri2_ws.h
new file mode 100755
index 000000000..743d5bb9c
--- /dev/null
+++ b/sys/pvr2d/pvr_includes/dri2_ws.h
@@ -0,0 +1,176 @@
+/**********************************************************************

+*

+* Copyright(c) Imagination Technologies Ltd.

+*

+* The contents of this file are subject to the MIT license as set out below.

+*

+* 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 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.

+* 

+* This License is also included in this distribution in the file called 

+* "COPYING".

+* 

+******************************************************************************/

+

+

+

+#if !defined(__DRI2_WS_H__)

+#define __DRI2_WS_H__

+

+#define DRI2WS_DISPFLAG_DEFAULT_DISPLAY 0x00000001

+

+/*

+// Constants (macros) related to back-buffering.

+*/

+

+#define XWS_FLIP_BUFFERS		3

+#define DRI2_FLIP_BUFFERS_NUM	XWS_FLIP_BUFFERS

+#define XWS_FLIP_BUFFER_INDEX	(XWS_MAX_FLIP_BUFFERS - 1)

+

+#define XWS_BLIT_BUFFERS		2

+#define DRI2_BLIT_BUFFERS_NUM	XWS_BLIT_BUFFERS

+#define XWS_BLIT_BUFFER_INDEX	(XWS_MAX_BLIT_BUFFERS - 1)

+

+#if 0

+#define MIN(a,b) ((a)<(b)?(a):(b))

+#define MAX(a,b) ((a)>(b)?(a):(b))

+#endif

+

+#define	XWS_MAX_BUFFERS MAX(XWS_FLIP_BUFFERS, XWS_BLIT_BUFFERS)

+#define	DRI2_MAX_BUFFERS_NUM  	XWS_MAX_BUFFERS

+

+

+#define __DRI_BUFFER_EMPTY 103

+

+/** Used for ugly ugly ugly swap interval passing to dri2 driver and receiving current frame index */

+#define __DRI_BUFFER_PVR_CTRL  	  0x80 /* 100000XX <- last 2 bits for swap interval value */

+#define __DRI_BUFFER_PVR_CTRL_RET 0x90 /* 11000000 */

+

+

+

+#define DRI2_BACK_BUFFER_EXPORT_TYPE_BUFFERS 1

+#define DRI2_BACK_BUFFER_EXPORT_TYPE_SWAPCHAIN 2

+

+#define UNREFERENCED_PARAMETER(x) (x) = (x)

+

+

+/*

+ * Structure used to pass information about back buffers between client application and

+ * X.Org. Watch out for equivalent structure in pvr_video lib 

+ */

+typedef struct _PVRDRI2BackBuffersExport_

+{

+	/* Type of export. _BUFFERS mean set of handles, _SWAPCHAIN mean Swap chain ID */

+	unsigned int	ui32Type;   

+	PVR2D_HANDLE 	hBuffers[DRI2_MAX_BUFFERS_NUM];

+	unsigned int	ui32BuffersCount;

+	unsigned int	ui32SwapChainID;

+} PVRDRI2BackBuffersExport;

+

+/*

+// Private window system display information

+*/

+typedef struct DRI2WS_Display_TAG

+{

+	unsigned int			ui32RefCount;

+	

+	Display				*display;

+	int				screen;

+	unsigned int			ui32Flags;

+

+	unsigned int			ui32Width;

+	unsigned int			ui32Height;

+	unsigned int			ui32StrideInBytes;

+	unsigned int			ui32BytesPerPixel;

+	WSEGLPixelFormat		ePixelFormat;

+

+	PVR2DFORMAT				ePVR2DPixelFormat;

+	PVR2DCONTEXTHANDLE		hContext;

+	PVR2DMEMINFO			*psMemInfo;

+

+	int				iDRMfd;

+} DRI2WSDisplay;

+

+

+typedef enum DRI2WS_DrawableType_TAG 

+{

+	DRI2_DRAWABLE_UNKNOWN = 0,

+	DRI2_DRAWABLE_WINDOW = 1,

+	DRI2_DRAWABLE_PIXMAP = 2,

+} DRI2WS_DrawableType;

+

+

+/*

+// Private window system drawable information

+*/

+typedef struct DRI2WS_Drawable_TAG

+{

+	DRI2WS_DrawableType	eDrawableType;

+

+	Window				nativeWin;

+

+	/** Index of current render-to back buffer (received from Xserver) */

+	unsigned int		ui32BackBufferCurrent;

+

+	/** Number of buffers */

+	unsigned int		ui32BackBufferNum;

+

+	/** Swap interval (works only in fliping/fullscreen case, values 0-3) */

+	unsigned int		ui32SwapInterval;

+

+	/** PVR2D Handles received from Xserver (back buffers export structure) */

+	PVR2D_HANDLE		hPVR2DBackBufferExport;

+

+	/** Stamp of current back buffer */

+	unsigned char		ucBackBufferExportStamp;

+

+	/** Array of PVR2D Handles received from Xserver (our back buffers) */

+	PVR2D_HANDLE		hPVR2DBackBuffer[XWS_MAX_BUFFERS];

+

+	/** Array of PVR2D mapped back buffers */

+	PVR2DMEMINFO 		*psMemBackBuffer[XWS_MAX_BUFFERS];

+

+	/** Stamp of current back buffer */

+	unsigned char		ucFrontBufferStamp;

+

+	/** Array of PVR2D Handles received from Xserver (our back buffers) */

+	PVR2D_HANDLE		hPVR2DFrontBuffer;

+

+	/** Array of PVR2D mapped back buffers */

+	PVR2DMEMINFO 		*psMemFrontBuffer;

+

+	/** ID of flip/swap chain received from X.Org */

+	unsigned int		ui32FlipChainID;

+

+	/** PVR2D Handle of flip chain used to get buffers to draw to */

+	PVR2DFLIPCHAINHANDLE 	hFlipChain;

+

+	int					iWidth;

+	int					iHeight;

+

+	WSEGLPixelFormat	ePixelFormat;

+	unsigned int		ui32BytesPerPixel;

+	unsigned int		ui32StrideInPixels;

+	unsigned int		ui32StrideInBytes;

+	PVR2DFORMAT			ePVR2DPixelFormat;

+

+	DRI2WSDisplay		*psXWSDisplay;

+

+} DRI2WSDrawable;

+

+#endif /* __DRI2_WS_H__ */

diff --git a/sys/pvr2d/pvr_includes/img_defs.h b/sys/pvr2d/pvr_includes/img_defs.h
new file mode 100755
index 000000000..64db71105
--- /dev/null
+++ b/sys/pvr2d/pvr_includes/img_defs.h
@@ -0,0 +1,123 @@
+/**********************************************************************

+*

+* Copyright(c) Imagination Technologies Ltd.

+*

+* The contents of this file are subject to the MIT license as set out below.

+*

+* 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 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.

+* 

+* This License is also included in this distribution in the file called 

+* "COPYING".

+* 

+******************************************************************************/

+

+

+

+#if !defined (__IMG_DEFS_H__)

+#define __IMG_DEFS_H__

+

+#include "img_types.h"

+

+typedef		enum	img_tag_TriStateSwitch

+{

+	IMG_ON		=	0x00,

+	IMG_OFF,

+	IMG_IGNORE

+

+} img_TriStateSwitch, * img_pTriStateSwitch;

+

+#define		IMG_SUCCESS				0

+

+#define		IMG_NO_REG				1

+

+#if defined (NO_INLINE_FUNCS)

+	#define	INLINE

+	#define	FORCE_INLINE

+#else

+#if defined (__cplusplus)

+	#define INLINE					inline

+	#define	FORCE_INLINE			inline

+#else

+#if	!defined(INLINE)

+	#define	INLINE					__inline

+#endif

+	#define	FORCE_INLINE			static __inline

+#endif

+#endif

+

+

+#ifndef PVR_UNREFERENCED_PARAMETER

+#define	PVR_UNREFERENCED_PARAMETER(param) (param) = (param)

+#endif

+

+#ifdef __GNUC__

+#define unref__ __attribute__ ((unused))

+#else

+#define unref__

+#endif

+

+#ifndef _TCHAR_DEFINED

+#if defined(UNICODE)

+typedef unsigned short		TCHAR, *PTCHAR, *PTSTR;

+#else	

+typedef char				TCHAR, *PTCHAR, *PTSTR;

+#endif	

+#define _TCHAR_DEFINED

+#endif 

+

+

+			#if defined(__linux__) || defined(__METAG)

+

+				#define IMG_CALLCONV

+				#define IMG_INTERNAL	__attribute__((visibility("hidden")))

+				#define IMG_EXPORT		__attribute__((visibility("default")))

+				#define IMG_IMPORT

+				#define IMG_RESTRICT	__restrict__

+

+			#else

+					#error("define an OS")

+			#endif

+

+#ifndef IMG_ABORT

+	#define IMG_ABORT()	abort()

+#endif

+

+#ifndef IMG_MALLOC

+	#define IMG_MALLOC(A)		malloc	(A)

+#endif

+

+#ifndef IMG_FREE

+	#define IMG_FREE(A)			free	(A)

+#endif

+

+#define IMG_CONST const

+

+#if defined(__GNUC__)

+#define IMG_FORMAT_PRINTF(x,y)		__attribute__((format(printf,x,y)))

+#else

+#define IMG_FORMAT_PRINTF(x,y)

+#endif

+

+#if defined (_WIN64)

+#define IMG_UNDEF	(~0ULL)

+#else

+#define IMG_UNDEF	(~0UL)

+#endif

+

+#endif 

diff --git a/sys/pvr2d/pvr_includes/img_types.h b/sys/pvr2d/pvr_includes/img_types.h
new file mode 100755
index 000000000..c312c8374
--- /dev/null
+++ b/sys/pvr2d/pvr_includes/img_types.h
@@ -0,0 +1,143 @@
+/**********************************************************************

+*

+* Copyright(c) Imagination Technologies Ltd.

+*

+* The contents of this file are subject to the MIT license as set out below.

+*

+* 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 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.

+* 

+* This License is also included in this distribution in the file called 

+* "COPYING".

+* 

+******************************************************************************/

+

+

+

+#ifndef __IMG_TYPES_H__

+#define __IMG_TYPES_H__

+

+#if !defined(IMG_ADDRSPACE_CPUVADDR_BITS)

+#define IMG_ADDRSPACE_CPUVADDR_BITS		32

+#endif

+

+#if !defined(IMG_ADDRSPACE_PHYSADDR_BITS)

+#define IMG_ADDRSPACE_PHYSADDR_BITS		32

+#endif

+

+typedef unsigned int	IMG_UINT,	*IMG_PUINT;

+typedef signed int		IMG_INT,	*IMG_PINT;

+

+typedef unsigned char	IMG_UINT8,	*IMG_PUINT8;

+typedef unsigned char	IMG_BYTE,	*IMG_PBYTE;

+typedef signed char		IMG_INT8,	*IMG_PINT8;

+typedef char			IMG_CHAR,	*IMG_PCHAR;

+

+typedef unsigned short	IMG_UINT16,	*IMG_PUINT16;

+typedef signed short	IMG_INT16,	*IMG_PINT16;

+#if !defined(IMG_UINT32_IS_ULONG)

+typedef unsigned int	IMG_UINT32,	*IMG_PUINT32;

+typedef signed int		IMG_INT32,	*IMG_PINT32;

+#else

+typedef unsigned long	IMG_UINT32,	*IMG_PUINT32;

+typedef signed long		IMG_INT32,	*IMG_PINT32;

+#endif

+#if !defined(IMG_UINT32_MAX)

+	#define IMG_UINT32_MAX 0xFFFFFFFFUL

+#endif

+

+	#if (defined(LINUX) || defined(__METAG))

+#if !defined(USE_CODE)

+		typedef unsigned long long		IMG_UINT64,	*IMG_PUINT64;

+		typedef long long 				IMG_INT64,	*IMG_PINT64;

+#endif

+	#else

+

+		#error("define an OS")

+

+	#endif

+

+#if !(defined(LINUX) && defined (__KERNEL__))

+typedef float			IMG_FLOAT,	*IMG_PFLOAT;

+typedef double			IMG_DOUBLE, *IMG_PDOUBLE;

+#endif

+

+typedef	enum tag_img_bool

+{

+	IMG_FALSE		= 0,

+	IMG_TRUE		= 1,

+	IMG_FORCE_ALIGN = 0x7FFFFFFF

+} IMG_BOOL, *IMG_PBOOL;

+

+typedef void            IMG_VOID, *IMG_PVOID;

+

+typedef IMG_INT32       IMG_RESULT;

+

+#if defined(_WIN64)

+typedef unsigned __int64 IMG_UINTPTR_T;

+#else

+typedef unsigned int     IMG_UINTPTR_T;

+#endif

+

+typedef IMG_PVOID       IMG_HANDLE;

+

+typedef void**          IMG_HVOID,	* IMG_PHVOID;

+

+typedef IMG_UINT32		IMG_SIZE_T;

+

+#define IMG_NULL        0 

+

+typedef IMG_UINT32      IMG_SID;

+

+

+typedef IMG_PVOID IMG_CPU_VIRTADDR;

+

+typedef struct _IMG_DEV_VIRTADDR

+{

+	

+	IMG_UINT32  uiAddr;

+#define IMG_CAST_TO_DEVVADDR_UINT(var)		(IMG_UINT32)(var)

+	

+} IMG_DEV_VIRTADDR;

+

+typedef struct _IMG_CPU_PHYADDR

+{

+	

+	IMG_UINTPTR_T uiAddr;

+} IMG_CPU_PHYADDR;

+

+typedef struct _IMG_DEV_PHYADDR

+{

+#if IMG_ADDRSPACE_PHYSADDR_BITS == 32

+	

+	IMG_UINTPTR_T uiAddr;

+#else

+	IMG_UINT32 uiAddr;

+	IMG_UINT32 uiHighAddr;

+#endif

+} IMG_DEV_PHYADDR;

+

+typedef struct _IMG_SYS_PHYADDR

+{

+	

+	IMG_UINTPTR_T uiAddr;

+} IMG_SYS_PHYADDR;

+

+#include "img_defs.h"

+

+#endif	

diff --git a/sys/pvr2d/pvr_includes/pvr2d.h b/sys/pvr2d/pvr_includes/pvr2d.h
new file mode 100755
index 000000000..5dce7cf11
--- /dev/null
+++ b/sys/pvr2d/pvr_includes/pvr2d.h
@@ -0,0 +1,669 @@
+/**********************************************************************

+*

+* Copyright(c) Imagination Technologies Ltd.

+*

+* The contents of this file are subject to the MIT license as set out below.

+*

+* 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 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.

+* 

+* This License is also included in this distribution in the file called 

+* "COPYING".

+* 

+******************************************************************************/

+

+

+

+/******************************************************************************

+Modifications :-

+$Log: pvr2d.h $

+

+ --- Revision Logs Removed --- 

+******************************************************************************/

+

+#ifndef _PVR2D_H_

+#define _PVR2D_H_

+

+#ifdef __cplusplus

+extern "C" {

+#endif 

+

+/* PVR2D Platform-specific definitions */

+#if defined (__linux__)

+#define PVR2D_EXPORT __attribute__((visibility("default")))

+#define PVR2D_IMPORT

+#else

+#define PVR2D_EXPORT

+#define PVR2D_IMPORT

+#endif

+

+/* PVR2D header revision */

+#define PVR2D_REV_MAJOR		3

+#define PVR2D_REV_MINOR		5

+

+/* Basic types */

+typedef enum

+{

+	PVR2D_FALSE = 0,

+	PVR2D_TRUE

+} PVR2D_BOOL;

+

+typedef void* PVR2D_HANDLE;

+

+typedef char             PVR2D_CHAR,	*PVR2D_PCHAR;

+typedef unsigned char    PVR2D_UCHAR,	*PVR2D_PUCHAR;

+typedef int              PVR2D_INT,		*PVR2D_PINT;

+typedef unsigned int     PVR2D_UINT,	*PVR2D_PUINT;

+typedef long             PVR2D_LONG,	*PVR2D_PLONG;

+typedef unsigned long    PVR2D_ULONG,	*PVR2D_PULONG;

+

+typedef void             PVR2D_VOID,	*PVR2D_PVOID;

+

+

+/* error codes */

+typedef enum

+{

+	PVR2D_OK = 0,

+	PVR2DERROR_INVALID_PARAMETER = -1,

+	PVR2DERROR_DEVICE_UNAVAILABLE = -2,

+	PVR2DERROR_INVALID_CONTEXT = -3,

+	PVR2DERROR_MEMORY_UNAVAILABLE = -4,

+	PVR2DERROR_DEVICE_NOT_PRESENT = -5,

+	PVR2DERROR_IOCTL_ERROR = -6,

+	PVR2DERROR_GENERIC_ERROR = -7,

+	PVR2DERROR_BLT_NOTCOMPLETE = -8,

+	PVR2DERROR_HW_FEATURE_NOT_SUPPORTED = -9,

+	PVR2DERROR_NOT_YET_IMPLEMENTED = -10,

+	PVR2DERROR_MAPPING_FAILED = -11

+}PVR2DERROR;

+

+/* 32 bit PVR2D pixel format specifier */

+typedef unsigned long PVR2DFORMAT;

+

+/* Standard PVR2D pixel formats */

+#define	PVR2D_1BPP						0x00UL // 1bpp mask surface or palletized 1 bit source with 2x32 bit CLUT

+#define	PVR2D_RGB565					0x01UL // Common rgb 565 format

+#define	PVR2D_ARGB4444					0x02UL // Common argb 4444 format

+#define	PVR2D_RGB888					0x03UL // Common rgb 888 format (not supported)

+#define	PVR2D_ARGB8888					0x04UL // Common argb 8888 format

+#define	PVR2D_ARGB1555					0x05UL // Common argb 1555 format

+#define	PVR2D_ALPHA8					0x06UL // Alpha-only 8 bit per pixel (used with a constant fill colour)

+#define	PVR2D_ALPHA4					0x07UL // Alpha-only 4 bits per pixel (used with a constant fill colour)

+#define	PVR2D_PAL2						0x08UL // Palletized 2 bit format (requires   4x32 bit CLUT)

+#define	PVR2D_PAL4						0x09UL // Palletized 4 bit format (requires  16x32 bit CLUT)

+#define	PVR2D_PAL8						0x0AUL // Palletized 8 bit format (requires 256x32 bit CLUT)

+#define PVR2D_U8						0x10UL // monochrome unsigned 8 bit

+#define PVR2D_U88						0x11UL // monochrome unsigned 16 bit

+#define PVR2D_S8						0x12UL // signed 8 bit

+#define PVR2D_YUV422_YUYV				0x13UL // YUV 422 low-high byte order Y0UY1V

+#define PVR2D_YUV422_UYVY				0x14UL // YUV 422 low-high byte order UY0VY1

+#define PVR2D_YUV422_YVYU				0x15UL // YUV 422 low-high byte order Y0VY1U

+#define PVR2D_YUV422_VYUY				0x16UL // YUV 422 low-high byte order VY0UY1

+#define PVR2D_YUV420_2PLANE				0x17UL // YUV420 2 Plane

+#define PVR2D_YUV420_3PLANE				0x18UL // YUV420 3 Plane

+#define PVR2D_2101010ARGB				0x19UL // 32 bit 2 10 10 10 

+#define PVR2D_888RSGSBS					0x1AUL

+#define PVR2D_16BPP_RAW					0x1BUL // 16 bit raw (no format conversion)

+#define PVR2D_32BPP_RAW					0x1CUL // 32 bit raw

+#define PVR2D_64BPP_RAW					0x1DUL // 64 bit raw

+#define PVR2D_128BPP_RAW				0x1EUL // 128 bit raw

+

+#define	PVR2D_NO_OF_FORMATS				0x1FUL

+

+/* Format modifier bit field (DstFormat and SrcFormat bits 16..23) */

+#define PVR2D_FORMAT_MASK				0x0000FFFFUL	// PVR2D Format bits

+#define PVR2D_FORMAT_LAYOUT_MASK		0x000F0000UL	// Format layout (strided / twiddled / tiled)

+#define PVR2D_FORMAT_FLAGS_MASK			0x0FF00000UL	// Surface Flags mask

+

+/* Layout */

+#define PVR2D_FORMAT_LAYOUT_SHIFT		16

+#define PVR2D_FORMAT_LAYOUT_STRIDED		0x00000000UL

+#define PVR2D_FORMAT_LAYOUT_TILED		0x00010000UL

+#define PVR2D_FORMAT_LAYOUT_TWIDDLED	0x00020000UL

+

+/*

+	PVR2D_SURFACE_PDUMP

+	This flag requests a surface pdump, to capture the pixel state after host writes.

+	Not needed if the surface state has resulted from previous SGX 2D/3D core writes.

+*/

+#define PVR2D_SURFACE_PDUMP				0x00100000UL	// calls PVRSRVPDumpMem to capture the surface (pdump builds only) 

+

+/*

+	Low level 3D format extension - for blts via the 3D core only.

+	If the top bit of the format field is set then PVR2D reads it as a PVRSRV_PIXEL_FORMAT.

+	The outcome is hardware dependant.

+	There is no guarantee that any specific PVRSRV format will be supported.

+*/

+#define PVR2D_FORMAT_PVRSRV				0x80000000

+

+/* wrap surface type */

+typedef enum

+{

+	PVR2D_WRAPFLAG_NONCONTIGUOUS = 0,

+	PVR2D_WRAPFLAG_CONTIGUOUS = 1,

+

+}PVR2DWRAPFLAGS;

+

+#define	PVR2D_CONTEXT_FLAGS_PRIORITY_MASK			0x00000003

+

+#define	PVR2D_CONTEXT_FLAGS_LOW_PRIORITY_CONTEXT	1

+#define	PVR2D_CONTEXT_FLAGS_NORMAL_PRIORITY_CONTEXT	0

+#define	PVR2D_CONTEXT_FLAGS_HIGH_PRIORITY_CONTEXT	2

+

+/* flags for control information of additional blits */

+typedef enum

+{

+	PVR2D_BLIT_DISABLE_ALL					= 0x00000000,	/* disable all additional controls */

+	PVR2D_BLIT_CK_ENABLE					= 0x00000001,	/* enable colour key */

+	PVR2D_BLIT_GLOBAL_ALPHA_ENABLE			= 0x00000002,	/* enable standard global alpha */

+	PVR2D_BLIT_PERPIXEL_ALPHABLEND_ENABLE	= 0x00000004,	/* enable per-pixel alpha bleding */

+	PVR2D_BLIT_PAT_SURFACE_ENABLE			= 0x00000008,	/* enable pattern surf (disable fill) */

+	PVR2D_BLIT_FULLY_SPECIFIED_ALPHA_ENABLE	= 0x00000010,	/* enable fully specified alpha */

+	PVR2D_BLIT_ROT_90						= 0x00000020,	/* apply 90 degree rotation to the blt */

+	PVR2D_BLIT_ROT_180						= 0x00000040,	/* apply 180 degree rotation to the blt */

+	PVR2D_BLIT_ROT_270						= 0x00000080,	/* apply 270 degree rotation to the blt */

+	PVR2D_BLIT_COPYORDER_TL2BR				= 0x00000100,	/* copy order overrides */

+	PVR2D_BLIT_COPYORDER_BR2TL				= 0x00000200,

+	PVR2D_BLIT_COPYORDER_TR2BL				= 0x00000400,

+	PVR2D_BLIT_COPYORDER_BL2TR				= 0x00000800,

+	PVR2D_BLIT_COLKEY_SOURCE				= 0x00001000,	/* Key colour is on the source surface */

+	PVR2D_BLIT_COLKEY_DEST					= 0x00002000,	/* Key colour is on the destination surface */

+	PVR2D_BLIT_COLKEY_MASKED				= 0x00004000,	/* Mask enabled for colour key */

+	PVR2D_BLIT_COLKEY_OP_PASS				= 0x00008000,	/* Colour key op = pass */

+	PVR2D_BLIT_COLKEY_OP_REJECT				= 0x00010000,	/* Colour key op = reject */

+	PVR2D_BLIT_PATH_2DCORE					= 0x00100000,	/* Blt via dedicated 2D Core or PTLA */

+	PVR2D_BLIT_PATH_3DCORE					= 0x00200000,	/* Blt via 3D Core */

+	PVR2D_BLIT_PATH_SWBLT					= 0x00400000,	/* Blt via host software */

+	PVR2D_BLIT_NO_SRC_SYNC_INFO				= 0x00800000,	/* Dont send a source sync info*/

+	PVR2D_BLIT_ISSUE_STATUS_UPDATES			= 0x01000000,	/* Issue status updates */

+

+} PVR2DBLITFLAGS;

+

+/* standard alpha-blending functions, AlphaBlendingFunc field of PVR2DBLTINFO */

+typedef enum

+{

+	PVR2D_ALPHA_OP_SRC_DSTINV = 1,	/* source alpha : Cdst = Csrc*Asrc + Cdst*(1-Asrc) */

+	PVR2D_ALPHA_OP_SRCP_DSTINV = 2	/* premultiplied source alpha : Cdst = Csrc + Cdst*(1-Asrc) */

+} PVR2D_ALPHABLENDFUNC;

+

+/* blend ops for fully specified alpha (SGX 2D Core only) */

+typedef enum

+{

+	PVR2D_BLEND_OP_ZERO = 0,

+	PVR2D_BLEND_OP_ONE = 1,

+	PVR2D_BLEND_OP_SRC = 2,

+	PVR2D_BLEND_OP_DST = 3,

+	PVR2D_BLEND_OP_GLOBAL = 4,

+	PVR2D_BLEND_OP_SRC_PLUS_GLOBAL = 5,

+	PVR2D_BLEND_OP_DST_PLUS_GLOBAL = 6

+}PVR2D_BLEND_OP;

+

+/* SGX 2D Core Fully specified alpha blend :	pAlpha field of PVR2DBLTINFO structure		*/

+/* a fully specified Alpha Blend operation is defined as									*/

+/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (ALPHA_3 * DST (ALPHA))							*/

+/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (ALPHA_4 * DST (RGB))								*/

+/* if the pre-multiplication stage is enabled then the equations become the following:		*/

+/* PRE_MUL     = ((SRC(A)) * (Global Alpha Value))											*/

+/* DST (ALPHA) = (ALPHA_1 * SRC (ALPHA)) + (PRE_MUL * DST (ALPHA))							*/

+/* DST (RGB)   = (ALPHA_2 * SRC (RGB)) + (PRE_MUL * DST (RGB))								*/

+/* if the transparent source alpha stage is enabled then a source alpha of zero forces the	*/

+/* source to be transparent for that pixel regardless of the blend equation being used.		*/

+typedef struct _PVR2D_ALPHABLT

+{

+	PVR2D_BLEND_OP	eAlpha1;

+	PVR2D_BOOL		bAlpha1Invert;

+	PVR2D_BLEND_OP	eAlpha2;

+	PVR2D_BOOL		bAlpha2Invert;

+	PVR2D_BLEND_OP	eAlpha3;

+	PVR2D_BOOL		bAlpha3Invert;

+	PVR2D_BLEND_OP	eAlpha4;

+	PVR2D_BOOL		bAlpha4Invert;

+	PVR2D_BOOL		bPremulAlpha;			/* enable pre-multiplication stage */

+	PVR2D_BOOL		bTransAlpha;			/* enable transparent source alpha stage */

+	PVR2D_BOOL		bUpdateAlphaLookup;		/* enable and update the 1555-Lookup alpha table */

+	PVR2D_UCHAR		uAlphaLookup0;			/* 8 bit alpha when A=0 in a 1555-Lookup surface */

+	PVR2D_UCHAR		uAlphaLookup1;			/* 8 bit alpha when A=1 in a 1555-Lookup surface */

+	PVR2D_UCHAR		uGlobalRGB;				/* Global Alpha Value for RGB, 0=transparent 255=opaque */

+	PVR2D_UCHAR		uGlobalA;				/* Global Alpha Value for Alpha */

+

+} PVR2D_ALPHABLT, *PPVR2D_ALPHABLT;

+

+

+/* surface memory info structure */

+typedef struct _PVR2DMEMINFO

+{

+	PVR2D_VOID			*pBase;

+	PVR2D_ULONG			ui32MemSize;

+	PVR2D_ULONG			ui32DevAddr;

+	PVR2D_ULONG			ulFlags;

+	PVR2D_VOID			*hPrivateData;

+	PVR2D_VOID			*hPrivateMapData;

+

+}PVR2DMEMINFO, *PPVR2DMEMINFO;

+

+

+#define PVR2D_MAX_DEVICE_NAME 20

+

+typedef struct _PVR2DDEVICEINFO

+{

+	PVR2D_ULONG		ulDevID;

+	PVR2D_CHAR		szDeviceName[PVR2D_MAX_DEVICE_NAME];

+}PVR2DDEVICEINFO;

+

+

+typedef struct _PVR2DISPLAYINFO

+{

+	PVR2D_ULONG	ulMaxFlipChains;

+	PVR2D_ULONG	ulMaxBuffersInChain;

+	PVR2DFORMAT	eFormat;

+	PVR2D_ULONG	ulWidth;

+	PVR2D_ULONG	ulHeight;

+	PVR2D_LONG	lStride;

+	PVR2D_ULONG	ulMinFlipInterval;

+	PVR2D_ULONG	ulMaxFlipInterval;

+

+}PVR2DDISPLAYINFO;

+

+

+typedef struct _PVR2MISCDISPLAYINFO

+{

+	PVR2D_ULONG ulPhysicalWidthmm;

+	PVR2D_ULONG ulPhysicalHeightmm;

+	PVR2D_ULONG ulUnused[10];

+

+}PVR2DMISCDISPLAYINFO;

+

+

+typedef struct _PVR2DBLTINFO

+{

+	PVR2D_ULONG		CopyCode;			/* rop code  */

+	PVR2D_ULONG		Colour;				/* fill colour */

+	PVR2D_ULONG		ColourKey;			/* colour key argb8888 (see CKEY_ defs below) */

+	PVR2D_UCHAR		GlobalAlphaValue;	/* global alpha blending */

+	PVR2D_UCHAR		AlphaBlendingFunc;	/* per-pixel alpha-blending function */

+

+	PVR2DBLITFLAGS	BlitFlags;			/* additional blit control information */

+

+	PVR2DMEMINFO	*pDstMemInfo;		/* destination memory */

+	PVR2D_ULONG		DstOffset;			/* byte offset from start of allocation to destination surface pixel 0,0 */

+	PVR2D_LONG		DstStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */

+	PVR2D_LONG		DstX, DstY;			/* pixel offset from start of dest surface to start of blt rectangle */

+	PVR2D_LONG		DSizeX,DSizeY;		/* blt size */

+	PVR2DFORMAT		DstFormat;			/* dest format */

+	PVR2D_ULONG		DstSurfWidth;		/* size of dest surface in pixels */

+	PVR2D_ULONG		DstSurfHeight;		/* size of dest surface in pixels */

+

+	PVR2DMEMINFO	*pSrcMemInfo;		/* source mem, (source fields are also used for patterns) */

+	PVR2D_ULONG		SrcOffset;			/* byte offset from start of allocation to src/pat surface pixel 0,0 */

+	PVR2D_LONG		SrcStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */

+	PVR2D_LONG		SrcX, SrcY;			/* pixel offset from start of surface to start of source rectangle */

+										/* for patterns this is the start offset within the pattern */

+	PVR2D_LONG		SizeX,SizeY;		/* source rectangle size or pattern size in pixels */

+	PVR2DFORMAT		SrcFormat;			/* source/pattern format */

+	PVR2DMEMINFO	*pPalMemInfo;		/* source/pattern palette memory containing argb8888 colour table */

+	PVR2D_ULONG		PalOffset;			/* byte offset from start of allocation to start of palette */

+	PVR2D_ULONG		SrcSurfWidth;		/* size of source surface in pixels */

+	PVR2D_ULONG		SrcSurfHeight;		/* size of source surface in pixels */

+

+	PVR2DMEMINFO	*pMaskMemInfo;		/* mask memory, 1bpp format implied */

+	PVR2D_ULONG		MaskOffset;			/* byte offset from start of allocation to mask surface pixel 0,0 */

+	PVR2D_LONG		MaskStride;			/* signed stride, the number of bytes from pixel 0,0 to 0,1 */

+	PVR2D_LONG		MaskX, MaskY;		/* mask rect top left (mask size = blt size) */

+	PVR2D_ULONG		MaskSurfWidth;		/* size of mask surface in pixels */

+	PVR2D_ULONG		MaskSurfHeight;		/* size of mask surface in pixels */

+	

+	PPVR2D_ALPHABLT pAlpha;				/* fully specified alpha blend (2DCore only) */

+	

+	PVR2D_ULONG		uSrcChromaPlane1;	/* mem offset from start of source alloc to chroma plane 1 */

+	PVR2D_ULONG		uSrcChromaPlane2;	/* mem offset from start of source alloc to chroma plane 2 */

+	PVR2D_ULONG		uDstChromaPlane1;	/* mem offset from start of dest alloc to chroma plane 1 */

+	PVR2D_ULONG		uDstChromaPlane2;	/* mem offset from start of dest alloc to chroma plane 2 */

+	

+	PVR2D_ULONG		ColourKeyMask;		/* 32 bit colour key mask, only valid when PVR2D_BLIT_COLKEY_MASKED is set */

+

+}PVR2DBLTINFO, *PPVR2DBLTINFO;

+

+typedef struct _PVR2DRECT

+{

+	PVR2D_LONG left, top;

+	PVR2D_LONG right, bottom;

+} PVR2DRECT;

+

+typedef struct

+{

+	PVR2DMEMINFO	*pSurfMemInfo;		/* surface memory */

+	PVR2D_ULONG		SurfOffset;			/* byte offset from start of allocation to destination surface pixel 0,0 */

+	PVR2D_LONG		Stride;				/* signed stride */

+	PVR2DFORMAT		Format;				/* format */

+	PVR2D_ULONG		SurfWidth;			/* surface width in pixels */

+	PVR2D_ULONG		SurfHeight;			/* surface height in pixels */

+

+} PVR2D_SURFACE, *PPVR2D_SURFACE;

+

+typedef struct

+{

+	PVR2D_ULONG		uChromaPlane1;		/* YUV multiplane - byte offset from start of alloc to chroma plane 1 */

+	PVR2D_ULONG		uChromaPlane2;		/* YUV multiplane - byte offset from start of alloc to chroma plane 2 */

+	PVR2D_LONG		Reserved[2];		/* Reserved, must be zero */

+

+} PVR2D_SURFACE_EXT, *PPVR2D_SURFACE_EXT;

+

+typedef struct

+{

+	PVR2D_ULONG		*pUseCode;					/* USSE code */

+	PVR2D_ULONG		UseCodeSize;				/* usse code size in bytes */

+

+} PVR2D_USECODE, *PPVR2D_USECODE;

+

+typedef struct

+{

+	PVR2D_SURFACE			sDst;				/* destination surface */

+	PVR2D_SURFACE			sSrc;				/* source surface */

+	PVR2DRECT				rcDest;				/* destination rectangle */

+	PVR2DRECT				rcSource;			/* source rectangle */

+	PVR2D_HANDLE			hUseCode;			/* custom USE code (NULL implies source copy) */

+	PVR2D_ULONG				UseParams[2];		/* per-blt params for use code */

+

+} PVR2D_3DBLT, *PPVR2D_3DBLT;

+

+typedef struct

+{

+	PVR2D_SURFACE			sDst;						/* destination surface */

+	PVR2DRECT				rcDest;						/* destination rectangle; scaling is supported */

+	PVR2D_SURFACE			sSrc;						/* source surface */

+	PVR2DRECT				rcSource;					/* source rectangle; scaling is supported */

+	PPVR2D_SURFACE			pSrc2;						/* optional second source surface (NULL if not required) */

+	PVR2DRECT*				prcSource2;					/* optional pSrc2 rectangle */

+	PVR2D_HANDLE			hUseCode;					/* custom USSE shader code (NULL implies default source copy) */

+	PVR2D_ULONG				UseParams[2];				/* per-blt params for usse code */

+	PVR2D_ULONG				uiNumTemporaryRegisters;	/* no. of temporary registers used in custom shader code */

+	PVR2D_BOOL				bDisableDestInput;			/* set true if the destination is output only */

+	PPVR2D_SURFACE_EXT		pDstExt;					/* Extended format params for dest */

+	PPVR2D_SURFACE_EXT		pSrcExt[2];					/* Extended format params for source 1 and 2 */

+	PVR2D_LONG				Reserved[4];				/* Reserved, must be zero */

+

+} PVR2D_3DBLT_EXT, *PPVR2D_3DBLT_EXT;

+

+

+#define MAKE_COPY_BLIT(src,soff,dest,doff,sx,sy,dx,dy,sz)

+

+typedef void* PVR2DCONTEXTHANDLE;

+typedef void* PVR2DFLIPCHAINHANDLE;

+

+

+// CopyCode field of PVR2DBLTINFO structure:

+// the CopyCode field of the PVR2DBLTINFO structure should contain a rop3 or rop4 code.

+// a rop3 is an 8 bit code that describes a blt with three inputs : source dest and pattern

+// rop4 is a 16 bit code that describes a blt with four inputs : source dest pattern and mask

+// common rop3 codes are defined below

+// a colour fill blt is processed in the pattern channel as a constant colour with a rop code of 0xF0

+// PVR2D_BLIT_PAT_SURFACE_ENABLE defines whether the pattern channel is a surface or a fill colour.

+// a rop4 is defined by two rop3 codes, and the 1 bit-per-pixel mask surface defines which is used.

+// a common rop4 is 0xAAF0 which is the mask copy blt used for text glyphs.

+// CopyCode is taken to be a rop4 when pMaskMemInfo is non zero, otherwise it is assumed to be a rop3

+// use the PVR2DMASKROP4 macro below to construct a rop4 from two rop3's

+// rop3a is the rop used when mask pixel = 1, and rop3b when mask = 0

+#define PVR2DROP4(rop3b, rop3a)			((rop3b<<8)|rop3a)

+

+/* common rop codes */

+#define PVR2DROPclear				0x00       /* 0 (whiteness) */

+#define PVR2DROPset					0xFF       /* 1 (blackness) */

+#define PVR2DROPnoop				0xAA       /* dst (used for masked blts) */

+

+/* source and  dest rop codes */

+#define PVR2DROPand					0x88       /* src AND dst */

+#define PVR2DROPandReverse			0x44       /* src AND NOT dst */

+#define PVR2DROPcopy				0xCC       /* src (used for source copy and alpha blts) */

+#define PVR2DROPandInverted			0x22       /* NOT src AND dst */

+#define PVR2DROPxor					0x66       /* src XOR dst */

+#define PVR2DROPor					0xEE       /* src OR dst */

+#define PVR2DROPnor					0x11       /* NOT src AND NOT dst */

+#define PVR2DROPequiv				0x99       /* NOT src XOR dst */

+#define PVR2DROPinvert				0x55       /* NOT dst */

+#define PVR2DROPorReverse			0xDD       /* src OR NOT dst */

+#define PVR2DROPcopyInverted		0x33       /* NOT src */

+#define PVR2DROPorInverted			0xBB       /* NOT src OR dst */

+#define PVR2DROPnand				0x77       /* NOT src OR NOT dst */

+

+/* pattern rop codes */

+#define PVR2DPATROPand				0xA0       /* pat AND dst */

+#define PVR2DPATROPandReverse		0x50       /* pat AND NOT dst */

+#define PVR2DPATROPcopy				0xF0       /* pat (used for solid color fills and pattern blts) */

+#define PVR2DPATROPandInverted		0x0A       /* NOT pat AND dst */

+#define PVR2DPATROPxor				0x5A       /* pat XOR dst */

+#define PVR2DPATROPor				0xFA       /* pat OR dst */

+#define PVR2DPATROPnor				0x05       /* NOT pat AND NOT dst */

+#define PVR2DPATROPequiv			0xA5       /* NOT pat XOR dst */

+#define PVR2DPATROPinvert			0x55       /* NOT dst */

+#define PVR2DPATROPorReverse		0xF5       /* pat OR NOT dst */

+#define PVR2DPATROPcopyInverted		0x0F       /* NOT pat */

+#define PVR2DPATROPorInverted		0xAF       /* NOT pat OR dst */

+#define PVR2DPATROPnand				0x5F       /* NOT pat OR NOT dst */

+

+/* common rop4 codes */

+#define PVR2DROP4MaskedCopy              PVR2DROP4(PVR2DROPnoop,PVR2DROPcopy)		/* masked source copy blt (used for rounded window corners etc) */

+#define PVR2DROP4MaskedFill              PVR2DROP4(PVR2DROPnoop,PVR2DPATROPcopy)	/* masked colour fill blt (used for text) */

+

+/* Legacy support */

+#define PVR2DROP3_PATMASK			PVR2DPATROPcopy

+#define PVR2DROP3_SRCMASK			PVR2DROPcopy

+

+/* pixmap memory alignment */

+#define PVR2D_ALIGNMENT_4			4			/* DWORD alignment */

+#define PVR2D_ALIGNMENT_ANY			0			/* no alignment    */

+#define PVR2D_ALIGNMENT_PALETTE		16			/* 16 byte alignment is required for palettes */

+

+/* Heap number for PVR2DGetFrameBuffer */

+#define PVR2D_FB_PRIMARY_SURFACE 0

+

+#define PVR2D_PRESENT_PROPERTY_SRCSTRIDE	(1UL << 0)

+#define PVR2D_PRESENT_PROPERTY_DSTSIZE		(1UL << 1)

+#define PVR2D_PRESENT_PROPERTY_DSTPOS		(1UL << 2)

+#define PVR2D_PRESENT_PROPERTY_CLIPRECTS	(1UL << 3)

+#define PVR2D_PRESENT_PROPERTY_INTERVAL		(1UL << 4)

+

+#define PVR2D_CREATE_FLIPCHAIN_SHARED		(1UL << 0)

+#define PVR2D_CREATE_FLIPCHAIN_QUERY		(1UL << 1)

+#define PVR2D_CREATE_FLIPCHAIN_OEMOVERLAY   (1UL << 2)

+#define PVR2D_CREATE_FLIPCHAIN_AS_BLITCHAIN (1UL << 3)

+

+/* Colour-key colour must be translated into argb8888 format */

+#define CKEY_8888(P)		(P)

+#define CKEY_4444(P)		(((P&0xF000UL)<<16) | ((P&0x0F00UL)<<12) | ((P&0x00F0UL)<<8) | ((P&0x000FUL)<<4))

+#define CKEY_1555(P)		(((P&0x8000UL)<<16) | ((P&0x7C00UL)<<9)  | ((P&0x3E0UL)<<6)  | ((P&0x1FUL)<<3))

+#define CKEY_565(P)			(((P&0xF800UL)<<8)  | ((P&0x7E0UL)<<5)   | ((P&0x1FUL)<<3))

+#define CKEY_MASK_8888		0x00FFFFFFUL

+#define CKEY_MASK_4444		0x00F0F0F0UL

+#define CKEY_MASK_1555		0x00F8F8F8UL	/* Alpha is not normally included in the key test */

+#define CKEY_MASK_565		0x00F8FCF8UL

+

+/* Fill colours must be translated into argb8888 format */

+#define CFILL_4444(P)		(((P&0xF000UL)<<16) | ((P&0x0F00UL)<<12) | ((P&0x00F0UL)<<8) | ((P&0x000FUL)<<4))

+#define CFILL_1555(P)		(((P&0x8000UL)<<16) | ((P&0x7C00UL)<<9)  | ((P&0x3E0UL)<<6)  | ((P&0x1FUL)<<3))

+#define CFILL_565(P)		(((P&0xF800UL)<<8)  | ((P&0x7E0UL)<<5)   | ((P&0x1FUL)<<3))

+

+/* PVR2DCreateDeviceContext flags */

+#define PVR2D_XSERVER_PROC			0x00000001UL		/*!< Set for the Xserver connection */

+

+/* PVR2DMemAlloc flags */

+#define PVR2D_MEM_UNCACHED			0x00000000UL	/* Default */

+#define PVR2D_MEM_CACHED			0x00000001UL	/* Caller must flush and sync when necessary */

+#define PVR2D_MEM_WRITECOMBINE		0x00000002UL

+

+/* Functions that the library exports */

+

+PVR2D_IMPORT

+int PVR2DEnumerateDevices(PVR2DDEVICEINFO *pDevInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DCreateDeviceContext(PVR2D_ULONG ulDevID,

+									PVR2DCONTEXTHANDLE* phContext,

+									PVR2D_ULONG ulFlags);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DDestroyDeviceContext(PVR2DCONTEXTHANDLE hContext);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DGetDeviceInfo(PVR2DCONTEXTHANDLE hContext,

+							  PVR2DDISPLAYINFO *pDisplayInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DGetMiscDisplayInfo(PVR2DCONTEXTHANDLE hContext,

+							  PVR2DMISCDISPLAYINFO *pMiscDisplayInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DGetScreenMode(PVR2DCONTEXTHANDLE hContext,

+							  PVR2DFORMAT *pFormat,

+							  PVR2D_LONG *plWidth,

+							  PVR2D_LONG *plHeight,

+							  PVR2D_LONG *plStride,

+							  PVR2D_INT *piRefreshRate);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DGetFrameBuffer(PVR2DCONTEXTHANDLE hContext,

+							   PVR2D_INT nHeap,

+							   PVR2DMEMINFO **ppsMemInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DMemAlloc(PVR2DCONTEXTHANDLE hContext,

+						 PVR2D_ULONG ulBytes,

+						 PVR2D_ULONG ulAlign,

+						 PVR2D_ULONG ulFlags,

+						 PVR2DMEMINFO **ppsMemInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DMemExport(PVR2DCONTEXTHANDLE hContext,

+						 PVR2D_ULONG ulFlags,

+						 PVR2DMEMINFO *psMemInfo,

+						 PVR2D_HANDLE *phMemHandle);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DMemWrap(PVR2DCONTEXTHANDLE hContext,

+						PVR2D_VOID *pMem,

+						PVR2D_ULONG ulFlags,

+						PVR2D_ULONG ulBytes,

+						PVR2D_ULONG alPageAddress[],

+						PVR2DMEMINFO **ppsMemInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DMemMap(PVR2DCONTEXTHANDLE hContext,

+						PVR2D_ULONG ulFlags,

+						PVR2D_HANDLE hMemHandle,

+						PVR2DMEMINFO **ppsDstMem);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DMemFree(PVR2DCONTEXTHANDLE hContext,

+						PVR2DMEMINFO *psMemInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DBlt(PVR2DCONTEXTHANDLE hContext,

+					PVR2DBLTINFO *pBltInfo);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DBltClipped(PVR2DCONTEXTHANDLE hContext,

+						   PVR2DBLTINFO *pBltInfo,

+						   PVR2D_ULONG ulNumClipRects,

+						   PVR2DRECT *pClipRects);

+

+PVR2D_EXPORT

+PVR2DERROR PVR2DSet1555Alpha (PVR2DCONTEXTHANDLE hContext,

+							  PVR2D_UCHAR Alpha0, PVR2D_UCHAR Alpha1);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DQueryBlitsComplete(PVR2DCONTEXTHANDLE hContext,

+								   const PVR2DMEMINFO *pMemInfo,

+								   PVR2D_UINT uiWaitForComplete);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DSetPresentBltProperties(PVR2DCONTEXTHANDLE hContext,

+										PVR2D_ULONG ulPropertyMask,

+										PVR2D_LONG lSrcStride,

+										PVR2D_ULONG ulDstWidth,

+										PVR2D_ULONG ulDstHeight,

+										PVR2D_LONG lDstXPos,

+										PVR2D_LONG lDstYPos,

+										PVR2D_ULONG ulNumClipRects,

+										PVR2DRECT *pClipRects,

+										PVR2D_ULONG ulSwapInterval);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DPresentBlt(PVR2DCONTEXTHANDLE hContext,

+						   PVR2DMEMINFO *pMemInfo,

+						   PVR2D_LONG lRenderID);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DCreateFlipChain(PVR2DCONTEXTHANDLE hContext,

+								PVR2D_ULONG ulFlags,

+								PVR2D_ULONG ulNumBuffers,

+								PVR2D_ULONG ulWidth,

+								PVR2D_ULONG ulHeight,

+								PVR2DFORMAT eFormat,

+								PVR2D_LONG *plStride,

+								PVR2D_ULONG *pulFlipChainID,

+								PVR2DFLIPCHAINHANDLE *phFlipChain);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DDestroyFlipChain(PVR2DCONTEXTHANDLE hContext,

+								 PVR2DFLIPCHAINHANDLE hFlipChain);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DGetFlipChainBuffers(PVR2DCONTEXTHANDLE hContext,

+									PVR2DFLIPCHAINHANDLE hFlipChain,

+									PVR2D_ULONG *pulNumBuffers,

+									PVR2DMEMINFO *psMemInfo[]);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DSetPresentFlipProperties(PVR2DCONTEXTHANDLE hContext,

+										 PVR2DFLIPCHAINHANDLE hFlipChain,

+										 PVR2D_ULONG ulPropertyMask,

+										 PVR2D_LONG lDstXPos,

+										 PVR2D_LONG lDstYPos,

+										 PVR2D_ULONG ulNumClipRects, 

+										 PVR2DRECT *pClipRects,

+										 PVR2D_ULONG ulSwapInterval);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DPresentFlip(PVR2DCONTEXTHANDLE hContext,

+							PVR2DFLIPCHAINHANDLE hFlipChain,

+							PVR2DMEMINFO *psMemInfo,

+							PVR2D_LONG lRenderID);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DGetAPIRev(PVR2D_LONG *lRevMajor, PVR2D_LONG *lRevMinor);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DLoadUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_UCHAR	*pUseCode,

+									const PVR2D_ULONG UseCodeSize, PVR2D_HANDLE *pUseCodeHandle);

+PVR2D_IMPORT

+PVR2DERROR PVR2DFreeUseCode (const PVR2DCONTEXTHANDLE hContext, const PVR2D_HANDLE hUseCodeHandle);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DBlt3D (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT pBlt3D);

+

+PVR2D_IMPORT

+PVR2DERROR PVR2DBlt3DExt (const PVR2DCONTEXTHANDLE hContext, const PPVR2D_3DBLT_EXT pBlt3D);

+

+#ifdef __cplusplus

+}

+#endif 

+

+#endif /* _PVR2D_H_ */

+

+/******************************************************************************

+ End of file (pvr2d.h)

+******************************************************************************/

diff --git a/sys/pvr2d/pvr_includes/services.h b/sys/pvr2d/pvr_includes/services.h
new file mode 100644
index 000000000..93263a874
--- /dev/null
+++ b/sys/pvr2d/pvr_includes/services.h
@@ -0,0 +1,1211 @@
+/**********************************************************************
+ *
+ * Copyright (C) Imagination Technologies Ltd. All rights reserved.
+ * 
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ * 
+ * This program is distributed in the hope it will be useful but, except 
+ * as otherwise stated in writing, without any warranty; without even the 
+ * implied warranty of merchantability or fitness for a particular purpose. 
+ * See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * Imagination Technologies Ltd. <gpl-support@imgtec.com>
+ * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK 
+ *
+ ******************************************************************************/
+
+#ifndef __SERVICES_H__
+#define __SERVICES_H__
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include "img_defs.h"
+#include "servicesext.h"
+
+#define PVRSRV_4K_PAGE_SIZE		4096UL
+
+#define PVRSRV_MAX_CMD_SIZE		1024
+
+#define PVRSRV_MAX_DEVICES		16	
+
+#define EVENTOBJNAME_MAXLENGTH (50)
+
+#define PVRSRV_MEM_READ						(1U<<0)
+#define PVRSRV_MEM_WRITE					(1U<<1)
+#define PVRSRV_MEM_CACHE_CONSISTENT			(1U<<2)
+#define PVRSRV_MEM_NO_SYNCOBJ				(1U<<3)
+#define PVRSRV_MEM_INTERLEAVED				(1U<<4)
+#define PVRSRV_MEM_DUMMY					(1U<<5)
+#define PVRSRV_MEM_EDM_PROTECT				(1U<<6)
+#define PVRSRV_MEM_ZERO						(1U<<7)
+#define PVRSRV_MEM_USER_SUPPLIED_DEVVADDR	(1U<<8)
+#define PVRSRV_MEM_RAM_BACKED_ALLOCATION	(1U<<9)
+#define PVRSRV_MEM_NO_RESMAN				(1U<<10)
+#define PVRSRV_MEM_EXPORTED					(1U<<11)
+
+
+#define PVRSRV_HAP_CACHED					(1U<<12)
+#define PVRSRV_HAP_UNCACHED					(1U<<13)
+#define PVRSRV_HAP_SMART					(1U<<20)  /* XXX could we use CACHED|UNCACHED? */
+#define PVRSRV_HAP_WRITECOMBINE				(1U<<14)
+#define PVRSRV_HAP_CACHETYPE_MASK			(PVRSRV_HAP_CACHED|PVRSRV_HAP_UNCACHED|PVRSRV_HAP_SMART|PVRSRV_HAP_WRITECOMBINE)
+#define PVRSRV_HAP_KERNEL_ONLY				(1U<<15)
+#define PVRSRV_HAP_SINGLE_PROCESS			(1U<<16)
+#define PVRSRV_HAP_MULTI_PROCESS			(1U<<17)
+#define PVRSRV_HAP_FROM_EXISTING_PROCESS	(1U<<18)
+#define PVRSRV_HAP_NO_CPU_VIRTUAL			(1U<<19)
+#define PVRSRV_HAP_GPU_PAGEABLE				(1U<<21)
+#define PVRSRV_HAP_MAPTYPE_MASK				(PVRSRV_HAP_KERNEL_ONLY \
+                                            |PVRSRV_HAP_SINGLE_PROCESS \
+                                            |PVRSRV_HAP_MULTI_PROCESS \
+                                            |PVRSRV_HAP_FROM_EXISTING_PROCESS \
+                                            |PVRSRV_HAP_NO_CPU_VIRTUAL\
+                                            |PVRSRV_HAP_GPU_PAGEABLE)
+
+#define PVRSRV_MEM_CACHED					PVRSRV_HAP_CACHED
+#define PVRSRV_MEM_UNCACHED					PVRSRV_HAP_UNCACHED
+#define PVRSRV_MEM_SMART					PVRSRV_HAP_SMART
+#define PVRSRV_MEM_WRITECOMBINE				PVRSRV_HAP_WRITECOMBINE
+
+#define PVRSRV_MEM_BACKINGSTORE_FIELD_SHIFT	(24)
+
+#define PVRSRV_MAP_NOUSERVIRTUAL            (1UL<<27)
+#define PVRSRV_MEM_XPROC  					(1U<<28)
+
+#define PVRSRV_NO_CONTEXT_LOSS					0		
+#define PVRSRV_SEVERE_LOSS_OF_CONTEXT			1		
+#define PVRSRV_PRE_STATE_CHANGE_MASK			0x80	
+
+
+#define PVRSRV_DEFAULT_DEV_COOKIE			(1)	 
+
+
+#define PVRSRV_MISC_INFO_TIMER_PRESENT				(1U<<0)
+#define PVRSRV_MISC_INFO_CLOCKGATE_PRESENT			(1U<<1)
+#define PVRSRV_MISC_INFO_MEMSTATS_PRESENT			(1U<<2)
+#define PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT	(1U<<3)
+#define PVRSRV_MISC_INFO_DDKVERSION_PRESENT			(1U<<4)
+#define PVRSRV_MISC_INFO_CPUCACHEOP_PRESENT			(1U<<5)
+#define PVRSRV_MISC_INFO_FREEMEM_PRESENT			(1U<<6)
+
+#define PVRSRV_MISC_INFO_RESET_PRESENT				(1U<<31)
+
+#define PVRSRV_PDUMP_MAX_FILENAME_SIZE			20
+#define PVRSRV_PDUMP_MAX_COMMENT_SIZE			200
+
+
+#define PVRSRV_CHANGEDEVMEM_ATTRIBS_CACHECOHERENT		0x00000001
+
+#define PVRSRV_MAPEXTMEMORY_FLAGS_ALTERNATEVA			0x00000001
+#define PVRSRV_MAPEXTMEMORY_FLAGS_PHYSCONTIG			0x00000002
+
+#define PVRSRV_MODIFYSYNCOPS_FLAGS_WO_INC			0x00000001
+#define PVRSRV_MODIFYSYNCOPS_FLAGS_RO_INC			0x00000002
+
+#define SRV_FLAGS_PERSIST		0x1
+#define SRV_FLAGS_PDUMP_ACTIVE	0x2
+
+#define PVRSRV_PDUMP_FLAGS_CONTINUOUS		0x1
+
+#define PVR_FULL_CACHE_OP_THRESHOLD	(0x7D000)
+
+typedef enum _PVRSRV_DEVICE_TYPE_
+{
+	PVRSRV_DEVICE_TYPE_UNKNOWN			= 0 ,
+	PVRSRV_DEVICE_TYPE_MBX1				= 1 ,
+	PVRSRV_DEVICE_TYPE_MBX1_LITE		= 2 ,
+
+	PVRSRV_DEVICE_TYPE_M24VA			= 3,
+	PVRSRV_DEVICE_TYPE_MVDA2			= 4,
+	PVRSRV_DEVICE_TYPE_MVED1			= 5,
+	PVRSRV_DEVICE_TYPE_MSVDX			= 6,
+
+	PVRSRV_DEVICE_TYPE_SGX				= 7,
+
+	PVRSRV_DEVICE_TYPE_VGX				= 8,
+
+	
+	PVRSRV_DEVICE_TYPE_EXT				= 9,
+
+    PVRSRV_DEVICE_TYPE_LAST             = 9,
+
+	PVRSRV_DEVICE_TYPE_FORCE_I32		= 0x7fffffff
+
+} PVRSRV_DEVICE_TYPE;
+
+#define HEAP_ID( _dev_ , _dev_heap_idx_ )	(  ((_dev_)<<24) | ((_dev_heap_idx_)&((1<<24)-1))  )
+#define HEAP_IDX( _heap_id_ )				( (_heap_id_)&((1<<24) - 1 ) )
+#define HEAP_DEV( _heap_id_ )				( (_heap_id_)>>24 )
+
+#define PVRSRV_UNDEFINED_HEAP_ID			(~0LU)
+
+typedef enum
+{
+	IMG_EGL				= 0x00000001,
+	IMG_OPENGLES1		= 0x00000002,
+	IMG_OPENGLES2		= 0x00000003,
+	IMG_D3DM			= 0x00000004,
+	IMG_SRV_UM			= 0x00000005,
+	IMG_OPENVG			= 0x00000006,
+	IMG_SRVCLIENT		= 0x00000007,
+	IMG_VISTAKMD		= 0x00000008,
+	IMG_VISTA3DNODE		= 0x00000009,
+	IMG_VISTAMVIDEONODE	= 0x0000000A,
+	IMG_VISTAVPBNODE	= 0x0000000B,
+	IMG_OPENGL			= 0x0000000C,
+	IMG_D3D				= 0x0000000D,
+#if defined(SUPPORT_GRAPHICS_HAL) || defined(SUPPORT_COMPOSER_HAL)
+	IMG_ANDROID_HAL		= 0x0000000E,
+#endif
+#if defined(SUPPORT_OPENCL)
+	IMG_OPENCL			= 0x0000000F,
+#endif
+
+} IMG_MODULE_ID;
+
+
+#define APPHINT_MAX_STRING_SIZE	256
+
+typedef enum
+{
+	IMG_STRING_TYPE		= 1,
+	IMG_FLOAT_TYPE		,
+	IMG_UINT_TYPE		,
+	IMG_INT_TYPE		,
+	IMG_FLAG_TYPE
+}IMG_DATA_TYPE;
+
+
+typedef struct _PVRSRV_DEV_DATA_ *PPVRSRV_DEV_DATA;
+
+typedef struct _PVRSRV_DEVICE_IDENTIFIER_
+{
+	PVRSRV_DEVICE_TYPE		eDeviceType;		
+	PVRSRV_DEVICE_CLASS		eDeviceClass;		
+	IMG_UINT32				ui32DeviceIndex;	
+	IMG_CHAR				*pszPDumpDevName;	
+	IMG_CHAR				*pszPDumpRegName;	
+
+} PVRSRV_DEVICE_IDENTIFIER;
+
+
+typedef struct _PVRSRV_CLIENT_DEV_DATA_
+{
+	IMG_UINT32		ui32NumDevices;				
+	PVRSRV_DEVICE_IDENTIFIER asDevID[PVRSRV_MAX_DEVICES];		
+	PVRSRV_ERROR	(*apfnDevConnect[PVRSRV_MAX_DEVICES])(PPVRSRV_DEV_DATA);	
+	PVRSRV_ERROR	(*apfnDumpTrace[PVRSRV_MAX_DEVICES])(PPVRSRV_DEV_DATA);		
+
+} PVRSRV_CLIENT_DEV_DATA;
+
+
+typedef struct _PVRSRV_CONNECTION_
+{
+	IMG_HANDLE hServices;					
+	IMG_UINT32 ui32ProcessID;				
+	PVRSRV_CLIENT_DEV_DATA	sClientDevData;	
+	IMG_UINT32 ui32SrvFlags;				
+}PVRSRV_CONNECTION;
+
+
+typedef struct _PVRSRV_DEV_DATA_
+{
+	IMG_CONST PVRSRV_CONNECTION	 *psConnection;	
+#if defined (SUPPORT_SID_INTERFACE)
+	IMG_SID			hDevCookie;				
+#else
+	IMG_HANDLE			hDevCookie;				
+#endif
+
+} PVRSRV_DEV_DATA;
+
+typedef struct _PVRSRV_MEMUPDATE_
+{
+	IMG_UINT32			ui32UpdateAddr;		
+	IMG_UINT32			ui32UpdateVal;		
+} PVRSRV_MEMUPDATE;
+
+typedef struct _PVRSRV_HWREG_
+{
+	IMG_UINT32			ui32RegAddr;	
+	IMG_UINT32			ui32RegVal;		
+} PVRSRV_HWREG;
+
+typedef struct _PVRSRV_MEMBLK_
+{
+	IMG_DEV_VIRTADDR	sDevVirtAddr;			
+	IMG_HANDLE			hOSMemHandle;			
+	IMG_HANDLE			hOSWrapMem;				
+	IMG_HANDLE			hBuffer;				
+	IMG_HANDLE			hResItem;				
+	IMG_SYS_PHYADDR	 	*psIntSysPAddr;
+
+} PVRSRV_MEMBLK;
+
+typedef struct _PVRSRV_KERNEL_MEM_INFO_ *PPVRSRV_KERNEL_MEM_INFO;
+
+typedef struct _PVRSRV_CLIENT_MEM_INFO_
+{
+	
+	IMG_PVOID				pvLinAddr;
+
+	
+	IMG_PVOID				pvLinAddrKM;
+
+	
+	IMG_DEV_VIRTADDR		sDevVAddr;
+
+	
+
+
+
+
+	IMG_CPU_PHYADDR			sCpuPAddr;
+
+	
+	IMG_UINT32				ui32Flags;
+
+	
+
+
+	IMG_UINT32				ui32ClientFlags;
+
+	
+	IMG_SIZE_T				uAllocSize;
+
+
+	
+	struct _PVRSRV_CLIENT_SYNC_INFO_	*psClientSyncInfo;
+
+#if defined (SUPPORT_SID_INTERFACE)
+	
+	IMG_SID								hMappingInfo;
+
+	
+	IMG_SID								hKernelMemInfo;
+
+	
+	IMG_SID								hResItem;
+#else
+	
+	IMG_HANDLE							hMappingInfo;
+
+	
+	IMG_HANDLE							hKernelMemInfo;
+
+	
+	IMG_HANDLE							hResItem;
+#endif
+
+#if defined(SUPPORT_MEMINFO_IDS)
+	#if !defined(USE_CODE)
+	
+	IMG_UINT64							ui64Stamp;
+	#else 
+	IMG_UINT32							dummy1;
+	IMG_UINT32							dummy2;
+	#endif 
+#endif 
+
+	
+
+
+	struct _PVRSRV_CLIENT_MEM_INFO_		*psNext;
+
+} PVRSRV_CLIENT_MEM_INFO, *PPVRSRV_CLIENT_MEM_INFO;
+
+
+#define PVRSRV_MAX_CLIENT_HEAPS (32)
+typedef struct _PVRSRV_HEAP_INFO_
+{
+	IMG_UINT32			ui32HeapID;
+#if defined (SUPPORT_SID_INTERFACE)
+	IMG_SID 			hDevMemHeap;
+#else
+	IMG_HANDLE 			hDevMemHeap;
+#endif
+	IMG_DEV_VIRTADDR	sDevVAddrBase;
+	IMG_UINT32			ui32HeapByteSize;
+	IMG_UINT32			ui32Attribs;
+	IMG_UINT32			ui32XTileStride;
+}PVRSRV_HEAP_INFO;
+
+
+
+
+typedef struct _PVRSRV_EVENTOBJECT_
+{
+	
+	IMG_CHAR	szName[EVENTOBJNAME_MAXLENGTH];
+	
+#if defined (SUPPORT_SID_INTERFACE)
+	IMG_SID     hOSEventKM;
+#else
+	IMG_HANDLE	hOSEventKM;
+#endif
+
+} PVRSRV_EVENTOBJECT;
+
+typedef enum
+{
+	PVRSRV_MISC_INFO_CPUCACHEOP_NONE = 0,
+	PVRSRV_MISC_INFO_CPUCACHEOP_CLEAN,
+	PVRSRV_MISC_INFO_CPUCACHEOP_FLUSH,
+	PVRSRV_MISC_INFO_CPUCACHEOP_CUSTOM_FLUSH,
+	PVRSRV_MISC_INFO_CPUCACHEOP_CUSTOM_INV
+} PVRSRV_MISC_INFO_CPUCACHEOP_TYPE;
+
+typedef struct _PVRSRV_MISC_INFO_
+{
+	IMG_UINT32	ui32StateRequest;		
+	IMG_UINT32	ui32StatePresent;		
+
+	
+	IMG_VOID	*pvSOCTimerRegisterKM;
+	IMG_VOID	*pvSOCTimerRegisterUM;
+#if defined (SUPPORT_SID_INTERFACE)
+	IMG_SID		hSOCTimerRegisterOSMemHandle;
+	IMG_SID		hSOCTimerRegisterMappingInfo;
+#else
+	IMG_HANDLE	hSOCTimerRegisterOSMemHandle;
+	IMG_HANDLE	hSOCTimerRegisterMappingInfo;
+#endif
+
+	
+	IMG_VOID	*pvSOCClockGateRegs;
+	IMG_UINT32	ui32SOCClockGateRegsSize;
+
+	
+	IMG_CHAR	*pszMemoryStr;
+	IMG_UINT32	ui32MemoryStrLen;
+
+	
+	PVRSRV_EVENTOBJECT	sGlobalEventObject;
+#if defined (SUPPORT_SID_INTERFACE)
+	IMG_EVENTSID		hOSGlobalEvent;
+#else
+	IMG_HANDLE			hOSGlobalEvent;
+#endif
+
+	
+	IMG_UINT32	aui32DDKVersion[4];
+
+	
+	struct
+	{
+		
+		IMG_BOOL bDeferOp;
+
+		
+		PVRSRV_MISC_INFO_CPUCACHEOP_TYPE eCacheOpType;
+
+		
+#if !defined (SUPPORT_SID_INTERFACE)
+		union
+		{
+			
+			PVRSRV_CLIENT_MEM_INFO *psClientMemInfo;
+
+			
+			struct _PVRSRV_KERNEL_MEM_INFO_ *psKernelMemInfo;
+		} u;
+#endif
+
+		
+		IMG_VOID *pvBaseVAddr;
+
+		
+		IMG_UINT32	ui32Length;
+	} sCacheOpCtl;
+} PVRSRV_MISC_INFO;
+
+typedef struct _PVRSRV_SYNC_TOKEN_
+{
+	
+
+	struct
+	{
+#if defined (SUPPORT_SID_INTERFACE)
+		IMG_SID    hKernelSyncInfo;
+#else
+		IMG_HANDLE hKernelSyncInfo;
+#endif
+		IMG_UINT32 ui32ReadOpsPendingSnapshot;
+		IMG_UINT32 ui32WriteOpsPendingSnapshot;
+	} sPrivate;
+} PVRSRV_SYNC_TOKEN;
+
+
+typedef enum _PVRSRV_CLIENT_EVENT_
+{
+	PVRSRV_CLIENT_EVENT_HWTIMEOUT = 0,
+} PVRSRV_CLIENT_EVENT;
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVClientEvent(IMG_CONST PVRSRV_CLIENT_EVENT eEvent,
+											PVRSRV_DEV_DATA *psDevData,
+											IMG_PVOID pvData);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVConnect(PVRSRV_CONNECTION **ppsConnection, IMG_UINT32 ui32SrvFlags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDisconnect(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDevices(IMG_CONST PVRSRV_CONNECTION 			*psConnection,
+													IMG_UINT32 					*puiNumDevices,
+													PVRSRV_DEVICE_IDENTIFIER 	*puiDevIDs);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAcquireDeviceData(IMG_CONST PVRSRV_CONNECTION 	*psConnection,
+													IMG_UINT32			uiDevIndex,
+													PVRSRV_DEV_DATA		*psDevData,
+													PVRSRV_DEVICE_TYPE	eDeviceType);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetMiscInfo (IMG_CONST PVRSRV_CONNECTION *psConnection, PVRSRV_MISC_INFO *psMiscInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVReleaseMiscInfo (IMG_CONST PVRSRV_CONNECTION *psConnection, PVRSRV_MISC_INFO *psMiscInfo);
+
+#if 1
+IMG_IMPORT
+IMG_UINT32 ReadHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset);
+
+IMG_IMPORT
+IMG_VOID WriteHWReg(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Offset, IMG_UINT32 ui32Value);
+
+IMG_IMPORT IMG_VOID WriteHWRegs(IMG_PVOID pvLinRegBaseAddr, IMG_UINT32 ui32Count, PVRSRV_HWREG *psHWRegs);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR PVRSRVPollForValue ( const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+							IMG_SID    hOSEvent,
+#else
+							IMG_HANDLE hOSEvent,
+#endif
+							volatile IMG_UINT32 *pui32LinMemAddr,
+							IMG_UINT32 ui32Value,
+							IMG_UINT32 ui32Mask,
+							IMG_UINT32 ui32Waitus,
+							IMG_UINT32 ui32Tries);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateDeviceMemContext(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+											IMG_SID    *phDevMemContext,
+#else
+											IMG_HANDLE *phDevMemContext,
+#endif
+											IMG_UINT32 *pui32SharedHeapCount,
+											PVRSRV_HEAP_INFO *psHeapInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyDeviceMemContext(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+											IMG_SID 			hDevMemContext);
+#else
+											IMG_HANDLE 			hDevMemContext);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDeviceMemHeapInfo(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+											IMG_SID     hDevMemContext,
+#else
+											IMG_HANDLE hDevMemContext,
+#endif
+											IMG_UINT32 *pui32SharedHeapCount,
+											PVRSRV_HEAP_INFO *psHeapInfo);
+
+#if defined(PVRSRV_LOG_MEMORY_ALLOCS)
+	#define PVRSRVAllocDeviceMem_log(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo, logStr) \
+		(PVR_TRACE(("PVRSRVAllocDeviceMem(" #psDevData "," #hDevMemHeap "," #ui32Attribs "," #ui32Size "," #ui32Alignment "," #ppsMemInfo ")" \
+			": " logStr " (size = 0x%lx)", ui32Size)), \
+		PVRSRVAllocDeviceMem(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo))
+#else
+	#define PVRSRVAllocDeviceMem_log(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo, logStr) \
+		PVRSRVAllocDeviceMem(psDevData, hDevMemHeap, ui32Attribs, ui32Size, ui32Alignment, ppsMemInfo)
+#endif
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocDeviceMem(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+									IMG_SID			hDevMemHeap,
+#else
+									IMG_HANDLE		hDevMemHeap,
+#endif
+									IMG_UINT32		ui32Attribs,
+									IMG_SIZE_T		ui32Size,
+									IMG_SIZE_T		ui32Alignment,
+									PVRSRV_CLIENT_MEM_INFO	**ppsMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceMem(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+								PVRSRV_CLIENT_MEM_INFO		*psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVRemapToDev(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+								PVRSRV_CLIENT_MEM_INFO		*psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapFromDev(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+								PVRSRV_CLIENT_MEM_INFO		*psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVExportDeviceMem(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+												PVRSRV_CLIENT_MEM_INFO		*psMemInfo,
+#if defined (SUPPORT_SID_INTERFACE)
+												IMG_SID						*phMemInfo);
+#else
+												IMG_HANDLE					*phMemInfo);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVReserveDeviceVirtualMem(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+											IMG_SID				hDevMemHeap,
+#else
+											IMG_HANDLE			hDevMemHeap,
+#endif
+											IMG_DEV_VIRTADDR	*psDevVAddr,
+											IMG_SIZE_T			ui32Size,
+											IMG_SIZE_T			ui32Alignment,
+											PVRSRV_CLIENT_MEM_INFO		**ppsMemInfo);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeDeviceVirtualMem(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+													PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+									IMG_SID hKernelMemInfo,
+									IMG_SID hDstDevMemHeap,
+#else
+									IMG_HANDLE hKernelMemInfo,
+									IMG_HANDLE hDstDevMemHeap,
+#endif
+									PVRSRV_CLIENT_MEM_INFO **ppsDstMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+										PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapExtMemory (IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+									PVRSRV_CLIENT_MEM_INFO		*psMemInfo,
+									IMG_SYS_PHYADDR				*psSysPAddr,
+									IMG_UINT32					ui32Flags);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapExtMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+									PVRSRV_CLIENT_MEM_INFO		*psMemInfo,
+									IMG_UINT32					ui32Flags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVWrapExtMemory(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+												IMG_SID					hDevMemContext,
+#else
+												IMG_HANDLE				hDevMemContext,
+#endif
+												IMG_SIZE_T 				ui32ByteSize,
+												IMG_SIZE_T				ui32PageOffset,
+												IMG_BOOL				bPhysContig,
+												IMG_SYS_PHYADDR	 		*psSysPAddr,
+												IMG_VOID 				*pvLinAddr,
+												IMG_UINT32				ui32Flags,
+												PVRSRV_CLIENT_MEM_INFO **ppsMemInfo);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnwrapExtMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+												PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+PVRSRV_ERROR PVRSRVChangeDeviceMemoryAttributes(IMG_CONST PVRSRV_DEV_DATA			*psDevData,
+												PVRSRV_CLIENT_MEM_INFO	*psClientMemInfo,
+												IMG_UINT32				ui32Attribs);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceClassMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+										IMG_SID hDevMemContext,
+										IMG_SID hDeviceClassBuffer,
+#else
+										IMG_HANDLE hDevMemContext,
+										IMG_HANDLE hDeviceClassBuffer,
+#endif
+										PVRSRV_CLIENT_MEM_INFO **ppsMemInfo);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapDeviceClassMemory (IMG_CONST PVRSRV_DEV_DATA *psDevData,
+										PVRSRV_CLIENT_MEM_INFO *psMemInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapPhysToUserSpace(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+									  IMG_SYS_PHYADDR sSysPhysAddr,
+									  IMG_UINT32 uiSizeInBytes,
+									  IMG_PVOID *ppvUserAddr,
+									  IMG_UINT32 *puiActualSize,
+									  IMG_PVOID *ppvProcess);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVUnmapPhysToUserSpace(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+										IMG_PVOID pvUserAddr,
+										IMG_PVOID pvProcess);
+
+#if defined(LINUX)
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVExportDeviceMem2(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+												 PVRSRV_CLIENT_MEM_INFO		*psMemInfo,
+												 IMG_INT					*iFd);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVMapDeviceMemory2(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+												 IMG_INT					iFd,
+#if defined (SUPPORT_SID_INTERFACE)
+												 IMG_SID					hDstDevMemHeap,
+#else
+												 IMG_HANDLE					hDstDevMemHeap,
+#endif
+												 PVRSRV_CLIENT_MEM_INFO		**ppsDstMemInfo);
+#endif 
+
+typedef enum _PVRSRV_SYNCVAL_MODE_
+{
+	PVRSRV_SYNCVAL_READ				= IMG_TRUE,
+	PVRSRV_SYNCVAL_WRITE			= IMG_FALSE,
+
+} PVRSRV_SYNCVAL_MODE, *PPVRSRV_SYNCVAL_MODE;
+
+typedef IMG_UINT32 PVRSRV_SYNCVAL;
+
+IMG_IMPORT PVRSRV_ERROR PVRSRVWaitForOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+	PVRSRV_SYNCVAL_MODE eMode, PVRSRV_SYNCVAL OpRequired);
+
+IMG_IMPORT PVRSRV_ERROR PVRSRVWaitForAllOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+	PVRSRV_SYNCVAL_MODE eMode);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+	PVRSRV_SYNCVAL_MODE eMode, PVRSRV_SYNCVAL OpRequired);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestAllOpsComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+	PVRSRV_SYNCVAL_MODE eMode);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestOpsNotComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+	PVRSRV_SYNCVAL_MODE eMode, PVRSRV_SYNCVAL OpRequired);
+
+IMG_IMPORT IMG_BOOL PVRSRVTestAllOpsNotComplete(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+	PVRSRV_SYNCVAL_MODE eMode);
+
+IMG_IMPORT PVRSRV_SYNCVAL PVRSRVGetPendingOpSyncVal(PPVRSRV_CLIENT_MEM_INFO psMemInfo,
+	PVRSRV_SYNCVAL_MODE eMode);
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumerateDeviceClass(IMG_CONST PVRSRV_CONNECTION *psConnection,
+													PVRSRV_DEVICE_CLASS DeviceClass,
+													IMG_UINT32 *pui32DevCount,
+													IMG_UINT32 *pui32DevID);
+
+IMG_IMPORT
+IMG_HANDLE IMG_CALLCONV PVRSRVOpenDCDevice(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+											IMG_UINT32 ui32DeviceID);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCloseDCDevice(IMG_CONST PVRSRV_CONNECTION	*psConnection, IMG_HANDLE hDevice);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumDCFormats (IMG_HANDLE hDevice,
+											IMG_UINT32		*pui32Count,
+											DISPLAY_FORMAT	*psFormat);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVEnumDCDims (IMG_HANDLE hDevice,
+										IMG_UINT32 		*pui32Count,
+										DISPLAY_FORMAT	*psFormat,
+										DISPLAY_DIMS	*psDims);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDCSystemBuffer(IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+										IMG_SID *phBuffer);
+#else
+										IMG_HANDLE *phBuffer);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDCInfo(IMG_HANDLE hDevice,
+										DISPLAY_INFO* psDisplayInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateDCSwapChain (IMG_HANDLE				hDevice,
+													IMG_UINT32				ui32Flags,
+													DISPLAY_SURF_ATTRIBUTES	*psDstSurfAttrib,
+													DISPLAY_SURF_ATTRIBUTES	*psSrcSurfAttrib,
+													IMG_UINT32				ui32BufferCount,
+													IMG_UINT32				ui32OEMFlags,
+													IMG_UINT32				*pui32SwapChainID,
+#if defined (SUPPORT_SID_INTERFACE)
+													IMG_SID					*phSwapChain);
+#else
+													IMG_HANDLE				*phSwapChain);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyDCSwapChain (IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+											IMG_SID hSwapChain);
+#else
+											IMG_HANDLE		hSwapChain);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCDstRect (IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+										IMG_SID		hSwapChain,
+#else
+										IMG_HANDLE	hSwapChain,
+#endif
+										IMG_RECT	*psDstRect);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCSrcRect (IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+										IMG_SID		hSwapChain,
+#else
+										IMG_HANDLE	hSwapChain,
+#endif
+										IMG_RECT	*psSrcRect);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCDstColourKey (IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+											IMG_SID		hSwapChain,
+#else
+											IMG_HANDLE	hSwapChain,
+#endif
+											IMG_UINT32	ui32CKColour);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSetDCSrcColourKey (IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+											IMG_SID		hSwapChain,
+#else
+											IMG_HANDLE	hSwapChain,
+#endif
+											IMG_UINT32	ui32CKColour);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetDCBuffers(IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+									IMG_SID     hSwapChain,
+									IMG_SID    *phBuffer);
+#else
+									IMG_HANDLE hSwapChain,
+									IMG_HANDLE *phBuffer);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSwapToDCBuffer (IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+										IMG_SID    hBuffer,
+#else
+										IMG_HANDLE hBuffer,
+#endif
+										IMG_UINT32 ui32ClipRectCount,
+										IMG_RECT  *psClipRect,
+										IMG_UINT32 ui32SwapInterval,
+#if defined (SUPPORT_SID_INTERFACE)
+										IMG_SID hPrivateTag);
+#else
+										IMG_HANDLE hPrivateTag);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSwapToDCSystem (IMG_HANDLE hDevice,
+#if defined (SUPPORT_SID_INTERFACE)
+										IMG_SID hSwapChain);
+#else
+										IMG_HANDLE hSwapChain);
+#endif
+
+
+IMG_IMPORT
+IMG_HANDLE IMG_CALLCONV PVRSRVOpenBCDevice(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+											IMG_UINT32 ui32DeviceID);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCloseBCDevice(IMG_CONST PVRSRV_CONNECTION *psConnection,
+												IMG_HANDLE hDevice);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetBCBufferInfo(IMG_HANDLE hDevice,
+												BUFFER_INFO	*psBuffer);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVGetBCBuffer(IMG_HANDLE hDevice,
+												IMG_UINT32 ui32BufferIndex,
+#if defined (SUPPORT_SID_INTERFACE)
+												IMG_SID   *phBuffer);
+#else
+												IMG_HANDLE *phBuffer);
+#endif
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpInit(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpStartInitPhase(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpStopInitPhase(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpSyncPol(IMG_CONST PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+											 IMG_SID    hKernelSyncInfo,
+#else
+											 PVRSRV_CLIENT_SYNC_INFO *psClientSyncInfo,
+#endif
+											 IMG_BOOL   bIsRead,
+											 IMG_UINT32 ui32Value,
+											 IMG_UINT32 ui32Mask);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpSyncPol2(IMG_CONST PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+											 IMG_SID  hKernelSyncInfo,
+#else
+											 PVRSRV_CLIENT_SYNC_INFO *psClientSyncInfo,
+#endif
+											 IMG_BOOL bIsRead);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpMem(IMG_CONST PVRSRV_CONNECTION *psConnection,
+									IMG_PVOID pvAltLinAddr,
+									PVRSRV_CLIENT_MEM_INFO *psMemInfo,
+									IMG_UINT32 ui32Offset,
+									IMG_UINT32 ui32Bytes,
+									IMG_UINT32 ui32Flags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpSync(IMG_CONST PVRSRV_CONNECTION *psConnection,
+										IMG_PVOID pvAltLinAddr,
+										PVRSRV_CLIENT_SYNC_INFO *psClientSyncInfo,
+										IMG_UINT32 ui32Offset,
+										IMG_UINT32 ui32Bytes);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpReg(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+										 IMG_CHAR *pszRegRegion,
+											IMG_UINT32 ui32RegAddr,
+											IMG_UINT32 ui32RegValue,
+											IMG_UINT32 ui32Flags);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegPolWithFlags(const PVRSRV_DEV_DATA *psDevData,
+													 IMG_CHAR *pszRegRegion,
+													 IMG_UINT32 ui32RegAddr,
+													 IMG_UINT32 ui32RegValue,
+													 IMG_UINT32 ui32Mask,
+													 IMG_UINT32 ui32Flags);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegPol(const PVRSRV_DEV_DATA *psDevData,
+											IMG_CHAR *pszRegRegion,
+											IMG_UINT32 ui32RegAddr,
+											IMG_UINT32 ui32RegValue,
+											IMG_UINT32 ui32Mask);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpPDReg(IMG_CONST PVRSRV_CONNECTION *psConnection,
+											IMG_UINT32 ui32RegAddr,
+											IMG_UINT32 ui32RegValue);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpPDDevPAddr(IMG_CONST PVRSRV_CONNECTION *psConnection,
+												PVRSRV_CLIENT_MEM_INFO *psMemInfo,
+												IMG_UINT32 ui32Offset,
+												IMG_DEV_PHYADDR sPDDevPAddr);
+
+#if !defined(USE_CODE)
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpMemPages(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+#if defined (SUPPORT_SID_INTERFACE)
+														   IMG_SID				hKernelMemInfo,
+#else
+														   IMG_HANDLE			hKernelMemInfo,
+#endif
+														   IMG_DEV_PHYADDR		*pPages,
+														   IMG_UINT32			ui32NumPages,
+												   		   IMG_DEV_VIRTADDR		sDevVAddr,
+														   IMG_UINT32			ui32Start,
+														   IMG_UINT32			ui32Length,
+														   IMG_UINT32			ui32Flags);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpSetFrame(IMG_CONST PVRSRV_CONNECTION *psConnection,
+											  IMG_UINT32 ui32Frame);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpComment(IMG_CONST PVRSRV_CONNECTION *psConnection,
+											 IMG_CONST IMG_CHAR *pszComment,
+											 IMG_BOOL bContinuous);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCommentf(IMG_CONST PVRSRV_CONNECTION *psConnection,
+											  IMG_BOOL bContinuous,
+											  IMG_CONST IMG_CHAR *pszFormat, ...)
+#if !defined(USE_CODE)
+											  IMG_FORMAT_PRINTF(3, 4)
+#endif
+;
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCommentWithFlagsf(IMG_CONST PVRSRV_CONNECTION *psConnection,
+													   IMG_UINT32 ui32Flags,
+													   IMG_CONST IMG_CHAR *pszFormat, ...)
+#if !defined(USE_CODE)
+													   IMG_FORMAT_PRINTF(3, 4)
+#endif
+;
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpDriverInfo(IMG_CONST PVRSRV_CONNECTION *psConnection,
+								 				IMG_CHAR *pszString,
+												IMG_BOOL bContinuous);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpIsCapturing(IMG_CONST PVRSRV_CONNECTION *psConnection,
+								 				IMG_BOOL *pbIsCapturing);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpRegRead(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+											IMG_CONST IMG_CHAR *pszRegRegion,
+								 			IMG_CONST IMG_CHAR *pszFileName,
+											IMG_UINT32 ui32FileOffset,
+											IMG_UINT32 ui32Address,
+											IMG_UINT32 ui32Size,
+											IMG_UINT32 ui32PDumpFlags);
+
+
+IMG_IMPORT
+IMG_BOOL IMG_CALLCONV PVRSRVPDumpIsCapturingTest(IMG_CONST PVRSRV_CONNECTION *psConnection);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVPDumpCycleCountRegRead(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+														IMG_UINT32 ui32RegOffset,
+														IMG_BOOL bLastFrame);
+
+IMG_IMPORT IMG_HANDLE	PVRSRVLoadLibrary(const IMG_CHAR *pszLibraryName);
+IMG_IMPORT PVRSRV_ERROR	PVRSRVUnloadLibrary(IMG_HANDLE hExtDrv);
+IMG_IMPORT PVRSRV_ERROR	PVRSRVGetLibFuncAddr(IMG_HANDLE hExtDrv, const IMG_CHAR *pszFunctionName, IMG_VOID **ppvFuncAddr);
+
+IMG_IMPORT IMG_UINT32 PVRSRVClockus (void);
+IMG_IMPORT IMG_VOID PVRSRVWaitus (IMG_UINT32 ui32Timeus);
+IMG_IMPORT IMG_VOID PVRSRVReleaseThreadQuanta (void);
+IMG_IMPORT IMG_UINT32 IMG_CALLCONV PVRSRVGetCurrentProcessID(void);
+IMG_IMPORT IMG_CHAR * IMG_CALLCONV PVRSRVSetLocale(const IMG_CHAR *pszLocale);
+
+
+
+
+
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVCreateAppHintState(IMG_MODULE_ID eModuleID,
+														const IMG_CHAR *pszAppName,
+														IMG_VOID **ppvState);
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVFreeAppHintState(IMG_MODULE_ID eModuleID,
+										 IMG_VOID *pvHintState);
+
+IMG_IMPORT IMG_BOOL IMG_CALLCONV PVRSRVGetAppHint(IMG_VOID			*pvHintState,
+												  const IMG_CHAR	*pszHintName,
+												  IMG_DATA_TYPE		eDataType,
+												  const IMG_VOID	*pvDefault,
+												  IMG_VOID			*pvReturn);
+
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVAllocUserModeMem (IMG_SIZE_T ui32Size);
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVCallocUserModeMem (IMG_SIZE_T ui32Size);
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVReallocUserModeMem (IMG_PVOID pvBase, IMG_SIZE_T uNewSize);
+IMG_IMPORT IMG_VOID  IMG_CALLCONV PVRSRVFreeUserModeMem (IMG_PVOID pvMem);
+IMG_IMPORT IMG_VOID PVRSRVMemCopy(IMG_VOID *pvDst, const IMG_VOID *pvSrc, IMG_SIZE_T ui32Size);
+IMG_IMPORT IMG_VOID PVRSRVMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_SIZE_T ui32Size);
+
+struct _PVRSRV_MUTEX_OPAQUE_STRUCT_;
+typedef	struct  _PVRSRV_MUTEX_OPAQUE_STRUCT_ *PVRSRV_MUTEX_HANDLE;
+
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateMutex(PVRSRV_MUTEX_HANDLE *phMutex);
+IMG_IMPORT PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroyMutex(PVRSRV_MUTEX_HANDLE hMutex);
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVLockMutex(PVRSRV_MUTEX_HANDLE hMutex);
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVUnlockMutex(PVRSRV_MUTEX_HANDLE hMutex);
+
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVLockProcessGlobalMutex(void);
+IMG_IMPORT IMG_VOID IMG_CALLCONV PVRSRVUnlockProcessGlobalMutex(void);
+
+
+struct _PVRSRV_SEMAPHORE_OPAQUE_STRUCT_;
+typedef	struct  _PVRSRV_SEMAPHORE_OPAQUE_STRUCT_ *PVRSRV_SEMAPHORE_HANDLE;
+
+
+  	#define IMG_SEMAPHORE_WAIT_INFINITE       ((IMG_UINT64)0xFFFFFFFFFFFFFFFFull)
+
+
+#if !defined(USE_CODE)
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVCreateSemaphore)
+#endif
+static INLINE PVRSRV_ERROR PVRSRVCreateSemaphore(PVRSRV_SEMAPHORE_HANDLE *phSemaphore, IMG_INT iInitialCount)
+{
+	PVR_UNREFERENCED_PARAMETER(iInitialCount);
+	*phSemaphore = 0;
+	return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVDestroySemaphore)
+#endif
+static INLINE PVRSRV_ERROR PVRSRVDestroySemaphore(PVRSRV_SEMAPHORE_HANDLE hSemaphore)
+{
+	PVR_UNREFERENCED_PARAMETER(hSemaphore);
+	return PVRSRV_OK;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVWaitSemaphore)
+#endif
+static INLINE PVRSRV_ERROR PVRSRVWaitSemaphore(PVRSRV_SEMAPHORE_HANDLE hSemaphore, IMG_UINT64 ui64TimeoutMicroSeconds)
+{
+	PVR_UNREFERENCED_PARAMETER(hSemaphore);
+	PVR_UNREFERENCED_PARAMETER(ui64TimeoutMicroSeconds);
+	return PVRSRV_ERROR_INVALID_PARAMS;
+}
+
+#ifdef INLINE_IS_PRAGMA
+#pragma inline(PVRSRVPostSemaphore)
+#endif
+static INLINE IMG_VOID PVRSRVPostSemaphore(PVRSRV_SEMAPHORE_HANDLE hSemaphore, IMG_INT iPostCount)
+{
+	PVR_UNREFERENCED_PARAMETER(hSemaphore);
+	PVR_UNREFERENCED_PARAMETER(iPostCount);
+}
+
+#endif 
+
+
+#if (defined(DEBUG) && defined(__linux__))
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVAllocUserModeMemTracking(IMG_SIZE_T ui32Size, IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
+
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVCallocUserModeMemTracking(IMG_SIZE_T ui32Size, IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
+
+IMG_IMPORT IMG_VOID  IMG_CALLCONV PVRSRVFreeUserModeMemTracking(IMG_VOID *pvMem);
+
+IMG_IMPORT IMG_PVOID IMG_CALLCONV PVRSRVReallocUserModeMemTracking(IMG_VOID *pvMem, IMG_SIZE_T ui32NewSize, 
+													  IMG_CHAR *pszFileName, IMG_UINT32 ui32LineNumber);
+#endif 
+
+IMG_IMPORT PVRSRV_ERROR PVRSRVEventObjectWait(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+									IMG_EVENTSID hOSEvent);
+#else
+									IMG_HANDLE hOSEvent);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVCreateSyncInfoModObj(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+													 IMG_SID *phKernelSyncInfoModObj);
+#else
+													 IMG_HANDLE *phKernelSyncInfoModObj);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVDestroySyncInfoModObj(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+													  IMG_SID hKernelSyncInfoModObj);
+#else
+													  IMG_HANDLE hKernelSyncInfoModObj);
+#endif
+
+
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVModifyPendingSyncOps(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+													  IMG_SID    hKernelSyncInfoModObj,
+#else
+													  IMG_HANDLE hKernelSyncInfoModObj,
+#endif
+													  PVRSRV_CLIENT_SYNC_INFO *psSyncInfo,
+													  IMG_UINT32 ui32ModifyFlags,
+													  IMG_UINT32 *pui32ReadOpsPending,
+													  IMG_UINT32 *pui32WriteOpsPending);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVModifyCompleteSyncOps(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+													  IMG_SID hKernelSyncInfoModObj);
+#else
+													  IMG_HANDLE hKernelSyncInfoModObj);
+#endif
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSyncOpsTakeToken(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+												 const IMG_SID      hKernelSyncInfo,
+#else
+												 const PVRSRV_CLIENT_SYNC_INFO *psSyncInfo,
+#endif
+												 PVRSRV_SYNC_TOKEN *psSyncToken);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSyncOpsFlushToToken(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+													const IMG_SID            hKernelSyncInfo,
+#else
+													const PVRSRV_CLIENT_SYNC_INFO *psSyncInfo,
+#endif
+													const PVRSRV_SYNC_TOKEN *psSyncToken,
+													IMG_BOOL bWait);
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSyncOpsFlushToModObj(const PVRSRV_CONNECTION *psConnection,
+#if defined (SUPPORT_SID_INTERFACE)
+													 IMG_SID  hKernelSyncInfoModObj,
+#else
+													 IMG_HANDLE hKernelSyncInfoModObj,
+#endif
+													 IMG_BOOL bWait);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVSyncOpsFlushToDelta(const PVRSRV_CONNECTION *psConnection,
+													PVRSRV_CLIENT_SYNC_INFO *psClientSyncInfo,
+													IMG_UINT32 ui32Delta,
+													IMG_BOOL bWait);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVAllocSyncInfo(IMG_CONST PVRSRV_DEV_DATA	*psDevData,
+											  PVRSRV_CLIENT_SYNC_INFO **ppsSyncInfo);
+
+IMG_IMPORT
+PVRSRV_ERROR IMG_CALLCONV PVRSRVFreeSyncInfo(IMG_CONST PVRSRV_DEV_DATA *psDevData,
+											 PVRSRV_CLIENT_SYNC_INFO *psSyncInfo);
+
+IMG_IMPORT
+const IMG_CHAR *PVRSRVGetErrorString(PVRSRV_ERROR eError);
+
+
+#define TIME_NOT_PASSED_UINT32(a,b,c)		(((a) - (b)) < (c))
+
+#if defined (__cplusplus)
+}
+#endif
+#endif 
+
diff --git a/sys/pvr2d/pvr_includes/servicesext.h b/sys/pvr2d/pvr_includes/servicesext.h
new file mode 100755
index 000000000..d32624511
--- /dev/null
+++ b/sys/pvr2d/pvr_includes/servicesext.h
@@ -0,0 +1,855 @@
+/**********************************************************************

+*

+* Copyright(c) Imagination Technologies Ltd.

+*

+* The contents of this file are subject to the MIT license as set out below.

+*

+* 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 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.

+* 

+* This License is also included in this distribution in the file called 

+* "COPYING".

+* 

+******************************************************************************/

+

+

+

+#if !defined (__SERVICESEXT_H__)

+#define __SERVICESEXT_H__

+

+#define PVRSRV_LOCKFLG_READONLY     	(1)		

+

+typedef enum _PVRSRV_ERROR_

+{

+	PVRSRV_OK = 0,

+	PVRSRV_ERROR_OUT_OF_MEMORY,

+	PVRSRV_ERROR_TOO_FEW_BUFFERS,

+	PVRSRV_ERROR_INVALID_PARAMS,

+	PVRSRV_ERROR_INIT_FAILURE,

+	PVRSRV_ERROR_CANT_REGISTER_CALLBACK,

+	PVRSRV_ERROR_INVALID_DEVICE,

+	PVRSRV_ERROR_NOT_OWNER,

+	PVRSRV_ERROR_BAD_MAPPING,

+	PVRSRV_ERROR_TIMEOUT,

+	PVRSRV_ERROR_FLIP_CHAIN_EXISTS,

+	PVRSRV_ERROR_INVALID_SWAPINTERVAL,

+	PVRSRV_ERROR_SCENE_INVALID,

+	PVRSRV_ERROR_STREAM_ERROR,

+	PVRSRV_ERROR_FAILED_DEPENDENCIES,

+	PVRSRV_ERROR_CMD_NOT_PROCESSED,

+	PVRSRV_ERROR_CMD_TOO_BIG,

+	PVRSRV_ERROR_DEVICE_REGISTER_FAILED,

+	PVRSRV_ERROR_TOOMANYBUFFERS,

+	PVRSRV_ERROR_NOT_SUPPORTED,

+	PVRSRV_ERROR_PROCESSING_BLOCKED,

+

+	PVRSRV_ERROR_CANNOT_FLUSH_QUEUE,

+	PVRSRV_ERROR_CANNOT_GET_QUEUE_SPACE,

+	PVRSRV_ERROR_CANNOT_GET_RENDERDETAILS,

+	PVRSRV_ERROR_RETRY,

+

+	PVRSRV_ERROR_DDK_VERSION_MISMATCH,

+	PVRSRV_ERROR_BUILD_MISMATCH,

+	PVRSRV_ERROR_CORE_REVISION_MISMATCH,

+

+	PVRSRV_ERROR_UPLOAD_TOO_BIG,

+

+	PVRSRV_ERROR_INVALID_FLAGS,

+	PVRSRV_ERROR_FAILED_TO_REGISTER_PROCESS,

+

+	PVRSRV_ERROR_UNABLE_TO_LOAD_LIBRARY,

+	PVRSRV_ERROR_UNABLE_GET_FUNC_ADDR,

+	PVRSRV_ERROR_UNLOAD_LIBRARY_FAILED,

+

+	PVRSRV_ERROR_BRIDGE_CALL_FAILED,

+	PVRSRV_ERROR_IOCTL_CALL_FAILED,

+

+    PVRSRV_ERROR_MMU_CONTEXT_NOT_FOUND,

+	PVRSRV_ERROR_BUFFER_DEVICE_NOT_FOUND,

+	PVRSRV_ERROR_BUFFER_DEVICE_ALREADY_PRESENT,

+

+	PVRSRV_ERROR_PCI_DEVICE_NOT_FOUND,

+	PVRSRV_ERROR_PCI_CALL_FAILED,

+	PVRSRV_ERROR_PCI_REGION_TOO_SMALL,

+	PVRSRV_ERROR_PCI_REGION_UNAVAILABLE,

+	PVRSRV_ERROR_BAD_REGION_SIZE_MISMATCH,

+

+	PVRSRV_ERROR_REGISTER_BASE_NOT_SET,

+

+	PVRSRV_ERROR_FAILED_TO_ALLOC_USER_MEM,

+	PVRSRV_ERROR_FAILED_TO_ALLOC_VP_MEMORY,

+	PVRSRV_ERROR_FAILED_TO_MAP_SHARED_PBDESC,

+	PVRSRV_ERROR_FAILED_TO_GET_PHYS_ADDR,

+

+	PVRSRV_ERROR_FAILED_TO_ALLOC_VIRT_MEMORY,

+	PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY,

+

+	PVRSRV_ERROR_FAILED_TO_ALLOC_PAGES,

+	PVRSRV_ERROR_FAILED_TO_FREE_PAGES,

+	PVRSRV_ERROR_FAILED_TO_COPY_PAGES,

+	PVRSRV_ERROR_UNABLE_TO_LOCK_PAGES,

+	PVRSRV_ERROR_UNABLE_TO_UNLOCK_PAGES,

+	PVRSRV_ERROR_STILL_MAPPED,

+	PVRSRV_ERROR_MAPPING_NOT_FOUND,

+	PVRSRV_ERROR_PHYS_ADDRESS_EXCEEDS_32BIT,

+	PVRSRV_ERROR_FAILED_TO_MAP_PAGE_TABLE,

+

+	PVRSRV_ERROR_INVALID_SEGMENT_BLOCK,

+	PVRSRV_ERROR_INVALID_SGXDEVDATA,

+	PVRSRV_ERROR_INVALID_DEVINFO,

+	PVRSRV_ERROR_INVALID_MEMINFO,

+	PVRSRV_ERROR_INVALID_MISCINFO,

+	PVRSRV_ERROR_UNKNOWN_IOCTL,

+	PVRSRV_ERROR_INVALID_CONTEXT,

+	PVRSRV_ERROR_UNABLE_TO_DESTROY_CONTEXT,

+	PVRSRV_ERROR_INVALID_HEAP,

+	PVRSRV_ERROR_INVALID_KERNELINFO,

+	PVRSRV_ERROR_UNKNOWN_POWER_STATE,

+	PVRSRV_ERROR_INVALID_HANDLE_TYPE,

+	PVRSRV_ERROR_INVALID_WRAP_TYPE,

+	PVRSRV_ERROR_INVALID_PHYS_ADDR,

+	PVRSRV_ERROR_INVALID_CPU_ADDR,

+	PVRSRV_ERROR_INVALID_HEAPINFO,

+	PVRSRV_ERROR_INVALID_PERPROC,

+	PVRSRV_ERROR_FAILED_TO_RETRIEVE_HEAPINFO,

+	PVRSRV_ERROR_INVALID_MAP_REQUEST,

+	PVRSRV_ERROR_INVALID_UNMAP_REQUEST,

+	PVRSRV_ERROR_UNABLE_TO_FIND_MAPPING_HEAP,

+	PVRSRV_ERROR_MAPPING_STILL_IN_USE,

+

+	PVRSRV_ERROR_EXCEEDED_HW_LIMITS,

+	PVRSRV_ERROR_NO_STAGING_BUFFER_ALLOCATED,

+

+	PVRSRV_ERROR_UNABLE_TO_CREATE_PERPROC_AREA,

+	PVRSRV_ERROR_UNABLE_TO_CREATE_EVENT,

+	PVRSRV_ERROR_UNABLE_TO_ENABLE_EVENT,

+	PVRSRV_ERROR_UNABLE_TO_REGISTER_EVENT,

+	PVRSRV_ERROR_UNABLE_TO_DESTROY_EVENT,

+	PVRSRV_ERROR_UNABLE_TO_CREATE_THREAD,

+	PVRSRV_ERROR_UNABLE_TO_CLOSE_THREAD,

+	PVRSRV_ERROR_THREAD_READ_ERROR,

+	PVRSRV_ERROR_UNABLE_TO_REGISTER_ISR_HANDLER,

+	PVRSRV_ERROR_UNABLE_TO_INSTALL_ISR,

+	PVRSRV_ERROR_UNABLE_TO_UNINSTALL_ISR,

+	PVRSRV_ERROR_ISR_ALREADY_INSTALLED,

+	PVRSRV_ERROR_ISR_NOT_INSTALLED,

+	PVRSRV_ERROR_UNABLE_TO_INITIALISE_INTERRUPT,

+	PVRSRV_ERROR_UNABLE_TO_RETRIEVE_INFO,

+	PVRSRV_ERROR_UNABLE_TO_DO_BACKWARDS_BLIT,

+	PVRSRV_ERROR_UNABLE_TO_CLOSE_SERVICES,

+	PVRSRV_ERROR_UNABLE_TO_REGISTER_CONTEXT,

+	PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE,

+

+	PVRSRV_ERROR_INVALID_CCB_COMMAND,

+

+	PVRSRV_ERROR_UNABLE_TO_LOCK_RESOURCE,

+	PVRSRV_ERROR_INVALID_LOCK_ID,

+	PVRSRV_ERROR_RESOURCE_NOT_LOCKED,

+

+	PVRSRV_ERROR_FLIP_FAILED,

+	PVRSRV_ERROR_UNBLANK_DISPLAY_FAILED,

+

+	PVRSRV_ERROR_TIMEOUT_POLLING_FOR_VALUE,

+

+	PVRSRV_ERROR_CREATE_RENDER_CONTEXT_FAILED,

+	PVRSRV_ERROR_UNKNOWN_PRIMARY_FRAG,

+	PVRSRV_ERROR_UNEXPECTED_SECONDARY_FRAG,

+	PVRSRV_ERROR_UNEXPECTED_PRIMARY_FRAG,

+

+	PVRSRV_ERROR_UNABLE_TO_INSERT_FENCE_ID,

+

+	PVRSRV_ERROR_BLIT_SETUP_FAILED,

+

+	PVRSRV_ERROR_PDUMP_NOT_AVAILABLE,

+	PVRSRV_ERROR_PDUMP_BUFFER_FULL,

+	PVRSRV_ERROR_PDUMP_BUF_OVERFLOW,

+	PVRSRV_ERROR_PDUMP_NOT_ACTIVE,

+	PVRSRV_ERROR_INCOMPLETE_LINE_OVERLAPS_PAGES,

+

+	PVRSRV_ERROR_MUTEX_DESTROY_FAILED,

+	PVRSRV_ERROR_MUTEX_INTERRUPTIBLE_ERROR,

+

+	PVRSRV_ERROR_INSUFFICIENT_SCRIPT_SPACE,

+	PVRSRV_ERROR_INSUFFICIENT_SPACE_FOR_COMMAND,

+

+	PVRSRV_ERROR_PROCESS_NOT_INITIALISED,

+	PVRSRV_ERROR_PROCESS_NOT_FOUND,

+	PVRSRV_ERROR_SRV_CONNECT_FAILED,

+	PVRSRV_ERROR_SRV_DISCONNECT_FAILED,

+	PVRSRV_ERROR_DEINT_PHASE_FAILED,

+	PVRSRV_ERROR_INIT2_PHASE_FAILED,

+

+	PVRSRV_ERROR_UNABLE_TO_FIND_RESOURCE,

+

+	PVRSRV_ERROR_NO_DC_DEVICES_FOUND,

+	PVRSRV_ERROR_UNABLE_TO_OPEN_DC_DEVICE,

+	PVRSRV_ERROR_UNABLE_TO_REMOVE_DEVICE,

+	PVRSRV_ERROR_NO_DEVICEDATA_FOUND,

+	PVRSRV_ERROR_NO_DEVICENODE_FOUND,

+	PVRSRV_ERROR_NO_CLIENTNODE_FOUND,

+	PVRSRV_ERROR_FAILED_TO_PROCESS_QUEUE,

+

+	PVRSRV_ERROR_UNABLE_TO_INIT_TASK,

+	PVRSRV_ERROR_UNABLE_TO_SCHEDULE_TASK,

+	PVRSRV_ERROR_UNABLE_TO_KILL_TASK,

+

+	PVRSRV_ERROR_UNABLE_TO_ENABLE_TIMER,

+	PVRSRV_ERROR_UNABLE_TO_DISABLE_TIMER,

+	PVRSRV_ERROR_UNABLE_TO_REMOVE_TIMER,

+

+	PVRSRV_ERROR_UNKNOWN_PIXEL_FORMAT,

+	PVRSRV_ERROR_UNKNOWN_SCRIPT_OPERATION,

+

+	PVRSRV_ERROR_HANDLE_INDEX_OUT_OF_RANGE,

+	PVRSRV_ERROR_HANDLE_NOT_ALLOCATED,

+	PVRSRV_ERROR_HANDLE_TYPE_MISMATCH,

+	PVRSRV_ERROR_UNABLE_TO_ADD_HANDLE,

+	PVRSRV_ERROR_HANDLE_NOT_SHAREABLE,

+	PVRSRV_ERROR_HANDLE_NOT_FOUND,

+	PVRSRV_ERROR_INVALID_SUBHANDLE,

+	PVRSRV_ERROR_HANDLE_BATCH_IN_USE,

+	PVRSRV_ERROR_HANDLE_BATCH_COMMIT_FAILURE,

+

+	PVRSRV_ERROR_UNABLE_TO_CREATE_HASH_TABLE,

+	PVRSRV_ERROR_INSERT_HASH_TABLE_DATA_FAILED,

+

+	PVRSRV_ERROR_UNSUPPORTED_BACKING_STORE,

+	PVRSRV_ERROR_UNABLE_TO_DESTROY_BM_HEAP,

+

+	PVRSRV_ERROR_UNKNOWN_INIT_SERVER_STATE,

+

+	PVRSRV_ERROR_NO_FREE_DEVICEIDS_AVALIABLE,

+	PVRSRV_ERROR_INVALID_DEVICEID,

+	PVRSRV_ERROR_DEVICEID_NOT_FOUND,

+

+	PVRSRV_ERROR_MEMORY_TEST_FAILED,

+	PVRSRV_ERROR_CPUPADDR_TEST_FAILED,

+	PVRSRV_ERROR_COPY_TEST_FAILED,

+

+	PVRSRV_ERROR_SEMAPHORE_NOT_INITIALISED,

+

+	PVRSRV_ERROR_UNABLE_TO_RELEASE_CLOCK,

+	PVRSRV_ERROR_CLOCK_REQUEST_FAILED,

+	PVRSRV_ERROR_DISABLE_CLOCK_FAILURE,

+	PVRSRV_ERROR_UNABLE_TO_SET_CLOCK_RATE,

+	PVRSRV_ERROR_UNABLE_TO_ROUND_CLOCK_RATE,

+	PVRSRV_ERROR_UNABLE_TO_ENABLE_CLOCK,

+	PVRSRV_ERROR_UNABLE_TO_GET_CLOCK,

+	PVRSRV_ERROR_UNABLE_TO_GET_PARENT_CLOCK,

+	PVRSRV_ERROR_UNABLE_TO_GET_SYSTEM_CLOCK,

+

+	PVRSRV_ERROR_UNKNOWN_SGL_ERROR,

+

+	PVRSRV_ERROR_SYSTEM_POWER_CHANGE_FAILURE,

+	PVRSRV_ERROR_DEVICE_POWER_CHANGE_FAILURE,

+

+	PVRSRV_ERROR_BAD_SYNC_STATE,

+

+	PVRSRV_ERROR_CACHEOP_FAILED,

+

+	PVRSRV_ERROR_FORCE_I32 = 0x7fffffff

+

+} PVRSRV_ERROR;

+

+

+typedef enum _PVRSRV_DEVICE_CLASS_

+{

+	PVRSRV_DEVICE_CLASS_3D				= 0 ,

+	PVRSRV_DEVICE_CLASS_DISPLAY			= 1 ,

+	PVRSRV_DEVICE_CLASS_BUFFER			= 2 ,

+	PVRSRV_DEVICE_CLASS_VIDEO			= 3 ,

+

+	PVRSRV_DEVICE_CLASS_FORCE_I32 		= 0x7fffffff

+

+} PVRSRV_DEVICE_CLASS;

+

+

+typedef enum _PVRSRV_SYS_POWER_STATE_

+{

+	PVRSRV_SYS_POWER_STATE_Unspecified		= -1,	

+	PVRSRV_SYS_POWER_STATE_D0				= 0,	

+	PVRSRV_SYS_POWER_STATE_D1				= 1,	

+	PVRSRV_SYS_POWER_STATE_D2				= 2,	

+	PVRSRV_SYS_POWER_STATE_D3				= 3,	

+	PVRSRV_SYS_POWER_STATE_D4				= 4,	

+

+	PVRSRV_SYS_POWER_STATE_FORCE_I32 = 0x7fffffff

+

+} PVRSRV_SYS_POWER_STATE, *PPVRSRV_SYS_POWER_STATE;

+

+

+typedef enum _PVRSRV_DEV_POWER_STATE_

+{

+	PVRSRV_DEV_POWER_STATE_DEFAULT	= -1,	

+	PVRSRV_DEV_POWER_STATE_ON		= 0,	

+	PVRSRV_DEV_POWER_STATE_IDLE		= 1,	

+	PVRSRV_DEV_POWER_STATE_OFF		= 2,	

+

+	PVRSRV_DEV_POWER_STATE_FORCE_I32 = 0x7fffffff

+

+} PVRSRV_DEV_POWER_STATE, *PPVRSRV_DEV_POWER_STATE;	

+

+

+typedef PVRSRV_ERROR (*PFN_PRE_POWER) (IMG_HANDLE				hDevHandle,

+									   PVRSRV_DEV_POWER_STATE	eNewPowerState,

+									   PVRSRV_DEV_POWER_STATE	eCurrentPowerState);

+typedef PVRSRV_ERROR (*PFN_POST_POWER) (IMG_HANDLE				hDevHandle,

+										PVRSRV_DEV_POWER_STATE	eNewPowerState,

+										PVRSRV_DEV_POWER_STATE	eCurrentPowerState);

+

+typedef PVRSRV_ERROR (*PFN_PRE_CLOCKSPEED_CHANGE) (IMG_HANDLE				hDevHandle,

+												   IMG_BOOL					bIdleDevice,

+												   PVRSRV_DEV_POWER_STATE	eCurrentPowerState);

+typedef PVRSRV_ERROR (*PFN_POST_CLOCKSPEED_CHANGE) (IMG_HANDLE				hDevHandle,

+													IMG_BOOL				bIdleDevice,

+													PVRSRV_DEV_POWER_STATE	eCurrentPowerState);

+

+

+typedef enum _PVRSRV_PIXEL_FORMAT_ {

+	

+	PVRSRV_PIXEL_FORMAT_UNKNOWN				=  0,

+	PVRSRV_PIXEL_FORMAT_RGB565				=  1,

+	PVRSRV_PIXEL_FORMAT_RGB555				=  2,

+	PVRSRV_PIXEL_FORMAT_RGB888				=  3,	

+	PVRSRV_PIXEL_FORMAT_BGR888				=  4,	

+	PVRSRV_PIXEL_FORMAT_GREY_SCALE			=  8,

+	PVRSRV_PIXEL_FORMAT_PAL12				= 13,

+	PVRSRV_PIXEL_FORMAT_PAL8				= 14,

+	PVRSRV_PIXEL_FORMAT_PAL4				= 15,

+	PVRSRV_PIXEL_FORMAT_PAL2				= 16,

+	PVRSRV_PIXEL_FORMAT_PAL1				= 17,

+	PVRSRV_PIXEL_FORMAT_ARGB1555			= 18,

+	PVRSRV_PIXEL_FORMAT_ARGB4444			= 19,

+	PVRSRV_PIXEL_FORMAT_ARGB8888			= 20,

+	PVRSRV_PIXEL_FORMAT_ABGR8888			= 21,

+	PVRSRV_PIXEL_FORMAT_YV12				= 22,

+	PVRSRV_PIXEL_FORMAT_I420				= 23,

+    PVRSRV_PIXEL_FORMAT_IMC2				= 25,

+	PVRSRV_PIXEL_FORMAT_XRGB8888			= 26,

+	PVRSRV_PIXEL_FORMAT_XBGR8888			= 27,

+	PVRSRV_PIXEL_FORMAT_BGRA8888			= 28,

+	PVRSRV_PIXEL_FORMAT_XRGB4444			= 29,

+	PVRSRV_PIXEL_FORMAT_ARGB8332			= 30,

+	PVRSRV_PIXEL_FORMAT_A2RGB10				= 31,	

+	PVRSRV_PIXEL_FORMAT_A2BGR10				= 32,	

+	PVRSRV_PIXEL_FORMAT_P8					= 33,

+	PVRSRV_PIXEL_FORMAT_L8					= 34,

+	PVRSRV_PIXEL_FORMAT_A8L8				= 35,

+	PVRSRV_PIXEL_FORMAT_A4L4				= 36,

+	PVRSRV_PIXEL_FORMAT_L16					= 37,

+	PVRSRV_PIXEL_FORMAT_L6V5U5				= 38,

+	PVRSRV_PIXEL_FORMAT_V8U8				= 39,

+	PVRSRV_PIXEL_FORMAT_V16U16				= 40,

+	PVRSRV_PIXEL_FORMAT_QWVU8888			= 41,

+	PVRSRV_PIXEL_FORMAT_XLVU8888			= 42,

+	PVRSRV_PIXEL_FORMAT_QWVU16				= 43,

+	PVRSRV_PIXEL_FORMAT_D16					= 44,

+	PVRSRV_PIXEL_FORMAT_D24S8				= 45,

+	PVRSRV_PIXEL_FORMAT_D24X8				= 46,

+

+	

+	PVRSRV_PIXEL_FORMAT_ABGR16				= 47,

+	PVRSRV_PIXEL_FORMAT_ABGR16F				= 48,

+	PVRSRV_PIXEL_FORMAT_ABGR32				= 49,

+	PVRSRV_PIXEL_FORMAT_ABGR32F				= 50,

+	PVRSRV_PIXEL_FORMAT_B10GR11				= 51,

+	PVRSRV_PIXEL_FORMAT_GR88				= 52,

+	PVRSRV_PIXEL_FORMAT_BGR32				= 53,

+	PVRSRV_PIXEL_FORMAT_GR32				= 54,

+	PVRSRV_PIXEL_FORMAT_E5BGR9				= 55,

+

+	

+	PVRSRV_PIXEL_FORMAT_RESERVED1			= 56,

+	PVRSRV_PIXEL_FORMAT_RESERVED2			= 57,

+	PVRSRV_PIXEL_FORMAT_RESERVED3			= 58,

+	PVRSRV_PIXEL_FORMAT_RESERVED4			= 59,

+	PVRSRV_PIXEL_FORMAT_RESERVED5			= 60,

+

+	

+	PVRSRV_PIXEL_FORMAT_R8G8_B8G8			= 61,

+	PVRSRV_PIXEL_FORMAT_G8R8_G8B8			= 62,

+

+	

+	PVRSRV_PIXEL_FORMAT_NV11				= 63,

+	PVRSRV_PIXEL_FORMAT_NV12				= 64,

+

+	

+	PVRSRV_PIXEL_FORMAT_YUY2				= 65,

+	PVRSRV_PIXEL_FORMAT_YUV420				= 66,

+	PVRSRV_PIXEL_FORMAT_YUV444				= 67,

+	PVRSRV_PIXEL_FORMAT_VUY444				= 68,

+	PVRSRV_PIXEL_FORMAT_YUYV				= 69,

+	PVRSRV_PIXEL_FORMAT_YVYU				= 70,

+	PVRSRV_PIXEL_FORMAT_UYVY				= 71,

+	PVRSRV_PIXEL_FORMAT_VYUY				= 72,

+

+	PVRSRV_PIXEL_FORMAT_FOURCC_ORG_UYVY		= 73,	

+	PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YUYV		= 74,	

+	PVRSRV_PIXEL_FORMAT_FOURCC_ORG_YVYU		= 75,	

+	PVRSRV_PIXEL_FORMAT_FOURCC_ORG_VYUY		= 76,	

+	PVRSRV_PIXEL_FORMAT_FOURCC_ORG_AYUV		= 77,	

+

+	

+	PVRSRV_PIXEL_FORMAT_A32B32G32R32		= 78,	

+	PVRSRV_PIXEL_FORMAT_A32B32G32R32F		= 79,	

+	PVRSRV_PIXEL_FORMAT_A32B32G32R32_UINT	= 80,	

+	PVRSRV_PIXEL_FORMAT_A32B32G32R32_SINT	= 81,	

+

+	

+	PVRSRV_PIXEL_FORMAT_B32G32R32			= 82,	

+	PVRSRV_PIXEL_FORMAT_B32G32R32F			= 83,	

+	PVRSRV_PIXEL_FORMAT_B32G32R32_UINT		= 84,	

+	PVRSRV_PIXEL_FORMAT_B32G32R32_SINT		= 85,	

+

+	

+	PVRSRV_PIXEL_FORMAT_G32R32				= 86,	

+	PVRSRV_PIXEL_FORMAT_G32R32F				= 87,	

+	PVRSRV_PIXEL_FORMAT_G32R32_UINT			= 88,	

+	PVRSRV_PIXEL_FORMAT_G32R32_SINT			= 89,	

+

+	

+	PVRSRV_PIXEL_FORMAT_D32F				= 90,	

+	PVRSRV_PIXEL_FORMAT_R32					= 91,	

+	PVRSRV_PIXEL_FORMAT_R32F				= 92,	

+	PVRSRV_PIXEL_FORMAT_R32_UINT			= 93,	

+	PVRSRV_PIXEL_FORMAT_R32_SINT			= 94,	

+

+	

+	PVRSRV_PIXEL_FORMAT_A16B16G16R16		= 95,	

+	PVRSRV_PIXEL_FORMAT_A16B16G16R16F		= 96,	

+	PVRSRV_PIXEL_FORMAT_A16B16G16R16_SINT	= 97,	

+	PVRSRV_PIXEL_FORMAT_A16B16G16R16_SNORM	= 98,	

+	PVRSRV_PIXEL_FORMAT_A16B16G16R16_UINT	= 99,	

+	PVRSRV_PIXEL_FORMAT_A16B16G16R16_UNORM	= 100,	

+

+	

+	PVRSRV_PIXEL_FORMAT_G16R16				= 101,	

+	PVRSRV_PIXEL_FORMAT_G16R16F				= 102,	

+	PVRSRV_PIXEL_FORMAT_G16R16_UINT			= 103,	

+	PVRSRV_PIXEL_FORMAT_G16R16_UNORM		= 104,	

+	PVRSRV_PIXEL_FORMAT_G16R16_SINT			= 105,	

+	PVRSRV_PIXEL_FORMAT_G16R16_SNORM		= 106,	

+

+	

+	PVRSRV_PIXEL_FORMAT_R16					= 107,	

+	PVRSRV_PIXEL_FORMAT_R16F				= 108,	

+	PVRSRV_PIXEL_FORMAT_R16_UINT			= 109,	

+	PVRSRV_PIXEL_FORMAT_R16_UNORM			= 110,	

+	PVRSRV_PIXEL_FORMAT_R16_SINT			= 111,	

+	PVRSRV_PIXEL_FORMAT_R16_SNORM			= 112,	

+

+	

+	PVRSRV_PIXEL_FORMAT_X8R8G8B8			= 113,	

+	PVRSRV_PIXEL_FORMAT_X8R8G8B8_UNORM		= 114,	

+	PVRSRV_PIXEL_FORMAT_X8R8G8B8_UNORM_SRGB	= 115,	

+

+	PVRSRV_PIXEL_FORMAT_A8R8G8B8			= 116,	

+	PVRSRV_PIXEL_FORMAT_A8R8G8B8_UNORM		= 117,	

+	PVRSRV_PIXEL_FORMAT_A8R8G8B8_UNORM_SRGB	= 118,	

+

+	PVRSRV_PIXEL_FORMAT_A8B8G8R8			= 119,	

+	PVRSRV_PIXEL_FORMAT_A8B8G8R8_UINT		= 120,	

+	PVRSRV_PIXEL_FORMAT_A8B8G8R8_UNORM		= 121,	

+	PVRSRV_PIXEL_FORMAT_A8B8G8R8_UNORM_SRGB	= 122,	

+	PVRSRV_PIXEL_FORMAT_A8B8G8R8_SINT		= 123,	

+	PVRSRV_PIXEL_FORMAT_A8B8G8R8_SNORM		= 124,	

+

+	

+	PVRSRV_PIXEL_FORMAT_G8R8				= 125,	

+	PVRSRV_PIXEL_FORMAT_G8R8_UINT			= 126,	

+	PVRSRV_PIXEL_FORMAT_G8R8_UNORM			= 127,	

+	PVRSRV_PIXEL_FORMAT_G8R8_SINT			= 128,	

+	PVRSRV_PIXEL_FORMAT_G8R8_SNORM			= 129,	

+

+	

+	PVRSRV_PIXEL_FORMAT_A8					= 130,	

+	PVRSRV_PIXEL_FORMAT_R8					= 131,	

+	PVRSRV_PIXEL_FORMAT_R8_UINT				= 132,	

+	PVRSRV_PIXEL_FORMAT_R8_UNORM			= 133,	

+	PVRSRV_PIXEL_FORMAT_R8_SINT				= 134,	

+	PVRSRV_PIXEL_FORMAT_R8_SNORM			= 135,	

+

+	

+	PVRSRV_PIXEL_FORMAT_A2B10G10R10			= 136,	

+	PVRSRV_PIXEL_FORMAT_A2B10G10R10_UNORM	= 137,	

+	PVRSRV_PIXEL_FORMAT_A2B10G10R10_UINT	= 138,	

+

+	

+	PVRSRV_PIXEL_FORMAT_B10G11R11			= 139,	

+	PVRSRV_PIXEL_FORMAT_B10G11R11F			= 140,	

+

+	

+	PVRSRV_PIXEL_FORMAT_X24G8R32			= 141,	

+	PVRSRV_PIXEL_FORMAT_G8R24				= 142,	

+	PVRSRV_PIXEL_FORMAT_X8R24				= 143,

+	PVRSRV_PIXEL_FORMAT_E5B9G9R9			= 144,	

+	PVRSRV_PIXEL_FORMAT_R1					= 145,	

+

+	PVRSRV_PIXEL_FORMAT_RESERVED6			= 146,

+	PVRSRV_PIXEL_FORMAT_RESERVED7			= 147,

+	PVRSRV_PIXEL_FORMAT_RESERVED8			= 148,

+	PVRSRV_PIXEL_FORMAT_RESERVED9			= 149,

+	PVRSRV_PIXEL_FORMAT_RESERVED10			= 150,

+	PVRSRV_PIXEL_FORMAT_RESERVED11			= 151,

+	PVRSRV_PIXEL_FORMAT_RESERVED12			= 152,

+	PVRSRV_PIXEL_FORMAT_RESERVED13			= 153,

+	PVRSRV_PIXEL_FORMAT_RESERVED14			= 154,

+	PVRSRV_PIXEL_FORMAT_RESERVED15			= 155,

+	PVRSRV_PIXEL_FORMAT_RESERVED16			= 156,

+	PVRSRV_PIXEL_FORMAT_RESERVED17			= 157,

+	PVRSRV_PIXEL_FORMAT_RESERVED18			= 158,

+	PVRSRV_PIXEL_FORMAT_RESERVED19			= 159,

+	PVRSRV_PIXEL_FORMAT_RESERVED20			= 160,

+

+	

+	PVRSRV_PIXEL_FORMAT_UBYTE4				= 161,	

+	PVRSRV_PIXEL_FORMAT_SHORT4				= 162,	

+	PVRSRV_PIXEL_FORMAT_SHORT4N				= 163,	

+	PVRSRV_PIXEL_FORMAT_USHORT4N			= 164,	

+	PVRSRV_PIXEL_FORMAT_SHORT2N				= 165,	

+	PVRSRV_PIXEL_FORMAT_SHORT2				= 166,	

+	PVRSRV_PIXEL_FORMAT_USHORT2N			= 167,	

+	PVRSRV_PIXEL_FORMAT_UDEC3				= 168,	

+	PVRSRV_PIXEL_FORMAT_DEC3N				= 169,	

+	PVRSRV_PIXEL_FORMAT_F16_2				= 170,	

+	PVRSRV_PIXEL_FORMAT_F16_4				= 171,	

+

+	

+	PVRSRV_PIXEL_FORMAT_L_F16				= 172,

+	PVRSRV_PIXEL_FORMAT_L_F16_REP			= 173,

+	PVRSRV_PIXEL_FORMAT_L_F16_A_F16			= 174,

+	PVRSRV_PIXEL_FORMAT_A_F16				= 175,

+	PVRSRV_PIXEL_FORMAT_B16G16R16F			= 176,

+

+	PVRSRV_PIXEL_FORMAT_L_F32				= 177,

+	PVRSRV_PIXEL_FORMAT_A_F32				= 178,

+	PVRSRV_PIXEL_FORMAT_L_F32_A_F32			= 179,

+

+	

+	PVRSRV_PIXEL_FORMAT_PVRTC2				= 180,

+	PVRSRV_PIXEL_FORMAT_PVRTC4				= 181,

+	PVRSRV_PIXEL_FORMAT_PVRTCII2			= 182,

+	PVRSRV_PIXEL_FORMAT_PVRTCII4			= 183,

+	PVRSRV_PIXEL_FORMAT_PVRTCIII			= 184,

+	PVRSRV_PIXEL_FORMAT_PVRO8				= 185,

+	PVRSRV_PIXEL_FORMAT_PVRO88				= 186,

+	PVRSRV_PIXEL_FORMAT_PT1					= 187,

+	PVRSRV_PIXEL_FORMAT_PT2					= 188,

+	PVRSRV_PIXEL_FORMAT_PT4					= 189,

+	PVRSRV_PIXEL_FORMAT_PT8					= 190,

+	PVRSRV_PIXEL_FORMAT_PTW					= 191,

+	PVRSRV_PIXEL_FORMAT_PTB					= 192,

+	PVRSRV_PIXEL_FORMAT_MONO8				= 193,

+	PVRSRV_PIXEL_FORMAT_MONO16				= 194,

+

+	

+	PVRSRV_PIXEL_FORMAT_C0_YUYV				= 195,

+	PVRSRV_PIXEL_FORMAT_C0_UYVY				= 196,

+	PVRSRV_PIXEL_FORMAT_C0_YVYU				= 197,

+	PVRSRV_PIXEL_FORMAT_C0_VYUY				= 198,

+	PVRSRV_PIXEL_FORMAT_C1_YUYV				= 199,

+	PVRSRV_PIXEL_FORMAT_C1_UYVY				= 200,

+	PVRSRV_PIXEL_FORMAT_C1_YVYU				= 201,

+	PVRSRV_PIXEL_FORMAT_C1_VYUY				= 202,

+

+	

+	PVRSRV_PIXEL_FORMAT_C0_YUV420_2P_UV		= 203,

+	PVRSRV_PIXEL_FORMAT_C0_YUV420_2P_VU		= 204,

+	PVRSRV_PIXEL_FORMAT_C0_YUV420_3P		= 205,

+	PVRSRV_PIXEL_FORMAT_C1_YUV420_2P_UV		= 206,

+	PVRSRV_PIXEL_FORMAT_C1_YUV420_2P_VU		= 207,

+	PVRSRV_PIXEL_FORMAT_C1_YUV420_3P		= 208,

+

+	PVRSRV_PIXEL_FORMAT_A2B10G10R10F		= 209,

+	PVRSRV_PIXEL_FORMAT_B8G8R8_SINT			= 210,

+	PVRSRV_PIXEL_FORMAT_PVRF32SIGNMASK		= 211,

+	

+	PVRSRV_PIXEL_FORMAT_ABGR4444			= 212,	

+	PVRSRV_PIXEL_FORMAT_ABGR1555			= 213,

+	PVRSRV_PIXEL_FORMAT_BGR565				= 214,			

+

+	PVRSRV_PIXEL_FORMAT_FORCE_I32			= 0x7fffffff

+

+} PVRSRV_PIXEL_FORMAT;

+

+typedef enum _PVRSRV_ALPHA_FORMAT_ {

+	PVRSRV_ALPHA_FORMAT_UNKNOWN		=  0x00000000,

+	PVRSRV_ALPHA_FORMAT_PRE			=  0x00000001,

+	PVRSRV_ALPHA_FORMAT_NONPRE		=  0x00000002,

+	PVRSRV_ALPHA_FORMAT_MASK		=  0x0000000F,

+} PVRSRV_ALPHA_FORMAT;

+

+typedef enum _PVRSRV_COLOURSPACE_FORMAT_ {

+	PVRSRV_COLOURSPACE_FORMAT_UNKNOWN		=  0x00000000,

+	PVRSRV_COLOURSPACE_FORMAT_LINEAR		=  0x00010000,

+	PVRSRV_COLOURSPACE_FORMAT_NONLINEAR		=  0x00020000,

+	PVRSRV_COLOURSPACE_FORMAT_MASK			=  0x000F0000,

+} PVRSRV_COLOURSPACE_FORMAT;

+

+

+typedef enum _PVRSRV_ROTATION_ {

+	PVRSRV_ROTATE_0		=	0,

+	PVRSRV_ROTATE_90	=	1,

+	PVRSRV_ROTATE_180	=	2,

+	PVRSRV_ROTATE_270	=	3,

+	PVRSRV_FLIP_Y

+

+} PVRSRV_ROTATION;

+

+#define PVRSRV_CREATE_SWAPCHAIN_SHARED		(1<<0)

+#define PVRSRV_CREATE_SWAPCHAIN_QUERY		(1<<1)

+#define PVRSRV_CREATE_SWAPCHAIN_OEMOVERLAY	(1<<2)

+

+typedef struct _PVRSRV_SYNC_DATA_

+{

+	

+	IMG_UINT32					ui32WriteOpsPending;

+	volatile IMG_UINT32			ui32WriteOpsComplete;

+

+	

+	IMG_UINT32					ui32ReadOpsPending;

+	volatile IMG_UINT32			ui32ReadOpsComplete;

+

+	

+	IMG_UINT32					ui32LastOpDumpVal;

+	IMG_UINT32					ui32LastReadOpDumpVal;

+

+} PVRSRV_SYNC_DATA;

+

+typedef struct _PVRSRV_CLIENT_SYNC_INFO_

+{

+	

+	PVRSRV_SYNC_DATA			*psSyncData;

+

+	

+

+

+	

+	IMG_DEV_VIRTADDR		sWriteOpsCompleteDevVAddr;

+

+	

+	IMG_DEV_VIRTADDR		sReadOpsCompleteDevVAddr;

+

+	

+	IMG_HANDLE					hMappingInfo;

+

+	

+	IMG_HANDLE					hKernelSyncInfo;

+

+} PVRSRV_CLIENT_SYNC_INFO, *PPVRSRV_CLIENT_SYNC_INFO;

+

+typedef struct PVRSRV_RESOURCE_TAG

+{

+	volatile IMG_UINT32 ui32Lock;

+	IMG_UINT32 			ui32ID;

+}PVRSRV_RESOURCE;

+typedef PVRSRV_RESOURCE PVRSRV_RES_HANDLE;

+

+

+typedef IMG_VOID (*PFN_CMD_COMPLETE) (IMG_HANDLE);

+typedef IMG_VOID (**PPFN_CMD_COMPLETE) (IMG_HANDLE);

+

+typedef IMG_BOOL (*PFN_CMD_PROC) (IMG_HANDLE, IMG_UINT32, IMG_VOID*);

+typedef IMG_BOOL (**PPFN_CMD_PROC) (IMG_HANDLE, IMG_UINT32, IMG_VOID*);

+

+

+typedef struct _IMG_RECT_

+{

+	IMG_INT32	x0;

+	IMG_INT32	y0;

+	IMG_INT32	x1;

+	IMG_INT32	y1;

+}IMG_RECT;

+

+typedef struct _IMG_RECT_16_

+{

+	IMG_INT16	x0;

+	IMG_INT16	y0;

+	IMG_INT16	x1;

+	IMG_INT16	y1;

+}IMG_RECT_16;

+

+

+typedef PVRSRV_ERROR (*PFN_GET_BUFFER_ADDR)(IMG_HANDLE,

+											IMG_HANDLE,

+											IMG_SYS_PHYADDR**,

+											IMG_SIZE_T*,

+											IMG_VOID**,

+											IMG_HANDLE*,

+											IMG_BOOL*,

+											IMG_UINT32*);

+

+

+typedef struct DISPLAY_DIMS_TAG

+{

+	IMG_UINT32	ui32ByteStride;

+	IMG_UINT32	ui32Width;

+	IMG_UINT32	ui32Height;

+} DISPLAY_DIMS;

+

+

+typedef struct DISPLAY_FORMAT_TAG

+{

+	

+	PVRSRV_PIXEL_FORMAT		pixelformat;

+} DISPLAY_FORMAT;

+

+typedef struct DISPLAY_SURF_ATTRIBUTES_TAG

+{

+	

+	PVRSRV_PIXEL_FORMAT		pixelformat;

+	

+	DISPLAY_DIMS			sDims;

+} DISPLAY_SURF_ATTRIBUTES;

+

+

+typedef struct DISPLAY_MODE_INFO_TAG

+{

+	

+	PVRSRV_PIXEL_FORMAT		pixelformat;

+	

+	DISPLAY_DIMS			sDims;

+	

+	IMG_UINT32				ui32RefreshHZ;

+	

+	IMG_UINT32				ui32OEMFlags;

+} DISPLAY_MODE_INFO;

+

+

+

+#define MAX_DISPLAY_NAME_SIZE	(50) 

+

+typedef struct DISPLAY_INFO_TAG

+{

+	

+	IMG_UINT32 ui32MaxSwapChains;

+	

+	IMG_UINT32 ui32MaxSwapChainBuffers;

+	

+	IMG_UINT32 ui32MinSwapInterval;

+	

+	IMG_UINT32 ui32MaxSwapInterval;

+	

+	IMG_UINT32 ui32PhysicalWidthmm;

+	IMG_UINT32 ui32PhysicalHeightmm;

+	

+	IMG_CHAR	szDisplayName[MAX_DISPLAY_NAME_SIZE];

+#if defined(SUPPORT_HW_CURSOR)

+	

+	IMG_UINT16	ui32CursorWidth;

+	IMG_UINT16	ui32CursorHeight;

+#endif

+} DISPLAY_INFO;

+

+typedef struct ACCESS_INFO_TAG

+{

+	IMG_UINT32		ui32Size;

+	IMG_UINT32  	ui32FBPhysBaseAddress;

+	IMG_UINT32		ui32FBMemAvailable;			

+	IMG_UINT32  	ui32SysPhysBaseAddress;

+	IMG_UINT32		ui32SysSize;

+	IMG_UINT32		ui32DevIRQ;

+}ACCESS_INFO;

+

+

+typedef struct PVRSRV_CURSOR_SHAPE_TAG

+{

+	IMG_UINT16			ui16Width;

+	IMG_UINT16			ui16Height;

+	IMG_INT16			i16XHot;

+	IMG_INT16			i16YHot;

+

+	

+	IMG_VOID*   		pvMask;

+	IMG_INT16  			i16MaskByteStride;

+

+	

+	IMG_VOID*			pvColour;

+	IMG_INT16			i16ColourByteStride;

+	PVRSRV_PIXEL_FORMAT	eColourPixelFormat;

+} PVRSRV_CURSOR_SHAPE;

+

+#define PVRSRV_SET_CURSOR_VISIBILITY	(1<<0)

+#define PVRSRV_SET_CURSOR_POSITION		(1<<1)

+#define PVRSRV_SET_CURSOR_SHAPE			(1<<2)

+#define PVRSRV_SET_CURSOR_ROTATION		(1<<3)

+

+typedef struct PVRSRV_CURSOR_INFO_TAG

+{

+	

+	IMG_UINT32 ui32Flags;

+

+	

+	IMG_BOOL bVisible;

+

+	

+	IMG_INT16 i16XPos;

+	IMG_INT16 i16YPos;

+

+	

+	PVRSRV_CURSOR_SHAPE sCursorShape;

+

+	

+	IMG_UINT32 ui32Rotation;

+

+} PVRSRV_CURSOR_INFO;

+

+

+typedef struct _PVRSRV_REGISTRY_INFO_

+{

+    IMG_UINT32		ui32DevCookie;

+    IMG_PCHAR		pszKey;

+    IMG_PCHAR		pszValue;

+    IMG_PCHAR		pszBuf;

+    IMG_UINT32		ui32BufSize;

+} PVRSRV_REGISTRY_INFO, *PPVRSRV_REGISTRY_INFO;

+

+

+PVRSRV_ERROR IMG_CALLCONV PVRSRVReadRegistryString (PPVRSRV_REGISTRY_INFO psRegInfo);

+PVRSRV_ERROR IMG_CALLCONV PVRSRVWriteRegistryString (PPVRSRV_REGISTRY_INFO psRegInfo);

+

+

+#define PVRSRV_BC_FLAGS_YUVCSC_CONFORMANT_RANGE	(0 << 0)

+#define PVRSRV_BC_FLAGS_YUVCSC_FULL_RANGE		(1 << 0)

+

+#define PVRSRV_BC_FLAGS_YUVCSC_BT601			(0 << 1)

+#define PVRSRV_BC_FLAGS_YUVCSC_BT709			(1 << 1)

+

+#define MAX_BUFFER_DEVICE_NAME_SIZE	(50) 

+

+typedef struct BUFFER_INFO_TAG

+{

+	IMG_UINT32 			ui32BufferCount;

+	IMG_UINT32			ui32BufferDeviceID;

+	PVRSRV_PIXEL_FORMAT	pixelformat;

+	IMG_UINT32			ui32ByteStride;

+	IMG_UINT32			ui32Width;

+	IMG_UINT32			ui32Height;

+	IMG_UINT32			ui32Flags;

+	IMG_CHAR			szDeviceName[MAX_BUFFER_DEVICE_NAME_SIZE];

+} BUFFER_INFO;

+

+typedef enum _OVERLAY_DEINTERLACE_MODE_

+{

+	WEAVE=0x0,

+	BOB_ODD,

+	BOB_EVEN,

+	BOB_EVEN_NONINTERLEAVED

+} OVERLAY_DEINTERLACE_MODE;

+

+#endif 

diff --git a/sys/pvr2d/pvr_includes/wsegl.h b/sys/pvr2d/pvr_includes/wsegl.h
new file mode 100755
index 000000000..e5191ec4d
--- /dev/null
+++ b/sys/pvr2d/pvr_includes/wsegl.h
@@ -0,0 +1,285 @@
+/**********************************************************************

+*

+* Copyright(c) Imagination Technologies Ltd.

+*

+* The contents of this file are subject to the MIT license as set out below.

+*

+* 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 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.

+* 

+* This License is also included in this distribution in the file called 

+* "COPYING".

+* 

+******************************************************************************/

+

+

+

+#if !defined(__WSEGL_H__)

+#define __WSEGL_H__

+

+#ifdef __cplusplus

+extern "C" {

+#endif 

+

+/*

+// WSEGL Platform-specific definitions

+*/

+#if defined(__linux__)

+#define WSEGL_EXPORT __attribute__((visibility("default")))

+#define WSEGL_IMPORT

+#else

+#define WSEGL_EXPORT

+#define WSEGL_IMPORT

+#endif

+

+/*

+// WSEGL API Version Number

+*/

+

+#define WSEGL_VERSION 2

+#define WSEGL_DEFAULT_DISPLAY 0

+#define WSEGL_DEFAULT_NATIVE_ENGINE 0

+

+#define WSEGL_FALSE		0

+#define WSEGL_TRUE		1

+#define WSEGL_NULL		0

+

+#define	WSEGL_UNREFERENCED_PARAMETER(param) (param) = (param)

+

+/*

+// WSEGL handles

+*/

+typedef void *WSEGLDisplayHandle;

+typedef void *WSEGLDrawableHandle;

+

+/*

+// Display capability type

+*/

+typedef enum WSEGLCapsType_TAG

+{

+	WSEGL_NO_CAPS = 0,

+	WSEGL_CAP_MIN_SWAP_INTERVAL = 1, /* System default value = 1 */

+	WSEGL_CAP_MAX_SWAP_INTERVAL = 2, /* System default value = 1 */

+	WSEGL_CAP_WINDOWS_USE_HW_SYNC = 3, /* System default value = 0 (FALSE) */

+	WSEGL_CAP_PIXMAPS_USE_HW_SYNC = 4, /* System default value = 0 (FALSE) */

+

+} WSEGLCapsType;

+

+/*

+// Display capability

+*/

+typedef struct WSEGLCaps_TAG

+{

+	WSEGLCapsType eCapsType;

+	unsigned long ui32CapsValue;

+

+} WSEGLCaps;

+

+/*

+// Drawable type

+*/

+#define WSEGL_NO_DRAWABLE			0x0

+#define WSEGL_DRAWABLE_WINDOW		0x1

+#define WSEGL_DRAWABLE_PIXMAP		0x2

+

+

+/*

+// Pixel format of display/drawable

+*/

+typedef enum WSEGLPixelFormat_TAG

+{

+	/* These must not be re-ordered */

+	WSEGL_PIXELFORMAT_RGB565	= 0,

+	WSEGL_PIXELFORMAT_ARGB4444	= 1,

+	WSEGL_PIXELFORMAT_ARGB8888	= 2,

+	WSEGL_PIXELFORMAT_ARGB1555	= 3,

+	WSEGL_PIXELFORMAT_ABGR8888	= 4,

+	WSEGL_PIXELFORMAT_XBGR8888	= 5,

+

+	/* These are compatibility names only; new WSEGL

+	 * modules should not use them.

+	 */

+	WSEGL_PIXELFORMAT_565		= WSEGL_PIXELFORMAT_RGB565,

+	WSEGL_PIXELFORMAT_4444		= WSEGL_PIXELFORMAT_ARGB4444,

+	WSEGL_PIXELFORMAT_8888		= WSEGL_PIXELFORMAT_ARGB8888,

+	WSEGL_PIXELFORMAT_1555		= WSEGL_PIXELFORMAT_ARGB1555,

+

+} WSEGLPixelFormat;

+

+/*

+// Transparent of display/drawable

+*/

+typedef enum WSEGLTransparentType_TAG

+{

+	WSEGL_OPAQUE = 0,

+	WSEGL_COLOR_KEY = 1,

+

+} WSEGLTransparentType;

+

+/*

+// Display/drawable configuration

+*/

+typedef struct WSEGLConfig_TAG

+{

+	/*

+	// Type of drawables this configuration applies to -

+	// OR'd values of drawable types. 

+	*/

+	unsigned long ui32DrawableType;

+

+	/* Pixel format */

+	WSEGLPixelFormat ePixelFormat;

+

+	/* Native Renderable  - set to WSEGL_TRUE if native renderable */

+	unsigned long ulNativeRenderable;

+

+	/* FrameBuffer Level Parameter */

+	unsigned long ulFrameBufferLevel;

+

+	/* Native Visual ID */

+	unsigned long ulNativeVisualID;

+

+	/* Native Visual */

+	void *hNativeVisual;

+

+	/* Transparent Type */

+	WSEGLTransparentType eTransparentType;

+

+	/* Transparent Color - only used if transparent type is COLOR_KEY */

+	unsigned long ulTransparentColor; /* packed as 0x00RRGGBB */

+

+

+} WSEGLConfig;

+

+/*

+// WSEGL errors

+*/

+typedef enum WSEGLError_TAG

+{

+	WSEGL_SUCCESS = 0,

+	WSEGL_CANNOT_INITIALISE = 1,

+	WSEGL_BAD_NATIVE_DISPLAY = 2,

+	WSEGL_BAD_NATIVE_WINDOW = 3,

+	WSEGL_BAD_NATIVE_PIXMAP = 4,

+	WSEGL_BAD_NATIVE_ENGINE = 5,

+	WSEGL_BAD_DRAWABLE = 6,

+	WSEGL_BAD_MATCH = 7,

+	WSEGL_OUT_OF_MEMORY = 8,

+

+	/* These are compatibility names only; new WSEGL

+	 * modules should not use them.

+	 */

+	WSEGL_BAD_CONFIG = WSEGL_BAD_MATCH,

+

+} WSEGLError; 

+

+/*

+// Drawable orientation (in degrees anti-clockwise)

+*/

+typedef enum WSEGLRotationAngle_TAG

+{

+	WSEGL_ROTATE_0 = 0,

+	WSEGL_ROTATE_90 = 1,

+	WSEGL_ROTATE_180 = 2,

+	WSEGL_ROTATE_270 = 3

+

+} WSEGLRotationAngle; 

+

+/*

+// Drawable information required by OpenGL-ES driver

+*/

+typedef struct WSEGLDrawableParams_TAG

+{

+	/* Width in pixels of the drawable */

+	unsigned long	ui32Width;

+

+	/* Height in pixels of the drawable */

+	unsigned long	ui32Height;

+

+	/* Stride in pixels of the drawable */

+	unsigned long	ui32Stride;

+

+	/* Pixel format of the drawable */

+	WSEGLPixelFormat	ePixelFormat;

+

+	/* User space cpu virtual address of the drawable */

+	void   			*pvLinearAddress;

+

+	/* HW address of the drawable */

+	unsigned long	ui32HWAddress;

+

+	/* Private data for the drawable */

+	void			*hPrivateData;

+

+

+} WSEGLDrawableParams;

+

+

+/*

+// Table of function pointers that is returned by WSEGL_GetFunctionTablePointer()

+//

+// The first entry in the table is the version number of the wsegl.h header file that

+// the module has been written against, and should therefore be set to WSEGL_VERSION

+*/

+typedef struct WSEGL_FunctionTable_TAG

+{

+	unsigned long ui32WSEGLVersion;

+

+	WSEGLError (*pfnWSEGL_IsDisplayValid)(NativeDisplayType);

+

+	WSEGLError (*pfnWSEGL_InitialiseDisplay)(NativeDisplayType, WSEGLDisplayHandle *, const WSEGLCaps **, WSEGLConfig **);

+

+	WSEGLError (*pfnWSEGL_CloseDisplay)(WSEGLDisplayHandle);

+

+	WSEGLError (*pfnWSEGL_CreateWindowDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativeWindowType, WSEGLRotationAngle *);

+

+	WSEGLError (*pfnWSEGL_CreatePixmapDrawable)(WSEGLDisplayHandle, WSEGLConfig *, WSEGLDrawableHandle *, NativePixmapType, WSEGLRotationAngle *);

+

+	WSEGLError (*pfnWSEGL_DeleteDrawable)(WSEGLDrawableHandle);

+

+	WSEGLError (*pfnWSEGL_SwapDrawable)(WSEGLDrawableHandle, unsigned long);

+

+	WSEGLError (*pfnWSEGL_SwapControlInterval)(WSEGLDrawableHandle, unsigned long);

+

+	WSEGLError (*pfnWSEGL_WaitNative)(WSEGLDrawableHandle, unsigned long);

+

+	WSEGLError (*pfnWSEGL_CopyFromDrawable)(WSEGLDrawableHandle, NativePixmapType);

+

+	WSEGLError (*pfnWSEGL_CopyFromPBuffer)(void *, unsigned long, unsigned long, unsigned long, WSEGLPixelFormat, NativePixmapType);

+

+	WSEGLError (*pfnWSEGL_GetDrawableParameters)(WSEGLDrawableHandle, WSEGLDrawableParams *, WSEGLDrawableParams *);

+

+	WSEGLError (*pfnWSEGL_ConnectDrawable)(WSEGLDrawableHandle);

+

+	WSEGLError (*pfnWSEGL_DisconnectDrawable)(WSEGLDrawableHandle);

+

+

+} WSEGL_FunctionTable;

+

+

+WSEGL_IMPORT const WSEGL_FunctionTable *WSEGL_GetFunctionTablePointer(void);

+

+#ifdef __cplusplus

+}

+#endif 

+

+#endif /* __WSEGL_H__ */

+

+/******************************************************************************

+ End of file (wsegl.h)

+******************************************************************************/