meta-emenlow: Layer for eMenlow-based systems.

This layer provides a kernel suitable for booting on eMenlow-based systems,
plus support for Poulsbo graphics.  The Poulsbo support includes a
kernel patch for the graphics driver, a couple of libraries, the 2D
and 3D X drivers, and a properly configured X server.

The closed portions of this support are in the 3D driver, xpsb-glx.
This package contains the binaries for the libraries that communicate
with the kernel driver and a mesa library which uses those libraries.

There is a README in meta-emenlow/ describing how to enable this layer.

Where possible, the recipes use bitbake's new .bbappend facility in
order to avoid copying recipes from meta/.

There are checksums and license information for all of the new packages.

Signed-off-by: Jeff Dike <jdike@linux.intel.com>

56 files changed, 9035 insertions, 0 deletions

diff --git a/meta-emenlow/README b/meta-emenlow/README
new file mode 100644
index 0000000000..e87df35a61
--- /dev/null
+++ b/meta-emenlow/README
@@ -0,0 +1,16 @@
+To use this layer, you will need to add ${OEROOT}/meta-emenlow to the
+BBLAYERS variable in build/conf/bblayers.conf, like this:
+
+	BBLAYERS = " \
+	  ${OEROOT}/meta-emenlow \ 
+	  ${OEROOT}/meta \
+	  "
+
+Also, per the comment, increment LCONF_VERSION in
+build/conf/bblayers.conf and build/conf/bblayers.conf.sample, and
+LAYER_CONF_VERSION in meta/conf/sanity.conf so that they all match.
+
+In conf/local.conf, set MACHINE to "emenlow".
+
+Then build the image of your choice (this was tested with sato), copy
+it to your device, and boot it.
diff --git a/meta-emenlow/conf/checksums.ini b/meta-emenlow/conf/checksums.ini
new file mode 100644
index 0000000000..e6fc77fb78
--- /dev/null
+++ b/meta-emenlow/conf/checksums.ini
@@ -0,0 +1,23 @@
+[https://launchpad.net/~gma500/+archive/ppa/+files/libdrm-poulsbo_2.3.0-1ubuntu0sarvatt4~1004um1ubuntu1.tar.gz]
+md5=82c00bb9f1239f1d00b18411b89c2380
+sha256=335d4ac6694687475efe07b44a2d77a9a9fadcbc16946d01ea8a02339ae7d9ec
+
+[https://launchpad.net/~gma500/+archive/ppa/+files/libva_0.31.0-1+sds9.1ubuntu1.tar.gz]
+md5=860f13e5a9d09511d7c6807b880e758b
+sha256=306468f87b9e13fdb3b6f0c6e2159b20198b33eed9eda4c31d7381a88911554f
+
+[https://launchpad.net/~gma500/+archive/ppa/+files/psb-firmware_0.30-0ubuntu1netbook1ubuntu1.tar.gz]
+md5=760005739edc64387240e56f6916e825
+sha256=714bc9162409b172caaabdaff5a942bc9d104a9b3a47a165754f7090803ba4b3
+
+[https://launchpad.net/~gma500/+archive/ppa/+files/psb-kernel-source_4.42.0-0ubuntu2~1004um2.tar.gz]
+md5=4f079e4f880bd45b281f5f3c017e8afa
+sha256=91ac0646ab02423a91b0a6027ffa1b0dbf1082588c03a3f7e4302c37c155f3fd
+
+[https://launchpad.net/~gma500/+archive/ppa/+files/xpsb-glx_0.18-0ubuntu1netbook2~1004um1ubuntu1.tar.gz]
+md5=50423a9e861ccff5814eb95a32494952
+sha256=03c958defef56ae0ec051c6f67620fa90733649925386824b7bf029f40bd7905
+
+[https://launchpad.net/~gma500/+archive/ppa/+files/xserver-xorg-video-psb_0.36.0-0ubuntu3~1004um9.tar.gz]
+md5=67bd808960db4fe9b3a7ff2582da1608
+sha256=deeaf6e4d059e709d8a4268bd013a172f7fbd70778236d7d1e2712d1951de72c
diff --git a/meta-emenlow/conf/layer.conf b/meta-emenlow/conf/layer.conf
new file mode 100644
index 0000000000..781df4b016
--- /dev/null
+++ b/meta-emenlow/conf/layer.conf
@@ -0,0 +1,10 @@
+# We have a conf and classes directory, add to BBPATH
+BBPATH := "${BBPATH}:${LAYERDIR}"
+
+# We have a packages directory, add to BBFILES
+BBFILES := "${BBFILES} ${LAYERDIR}/packages/*/*.bb \
+	${LAYERDIR}/packages/*/*.bbappend"
+
+BBFILE_COLLECTIONS += "emenlow"
+BBFILE_PATTERN_emenlow := "^${LAYERDIR}/"
+BBFILE_PRIORITY_emenlow = "6"
diff --git a/meta-emenlow/conf/machine/emenlow.conf b/meta-emenlow/conf/machine/emenlow.conf
new file mode 100644
index 0000000000..91fac7cec8
--- /dev/null
+++ b/meta-emenlow/conf/machine/emenlow.conf
@@ -0,0 +1,41 @@
+#@TYPE: Machine
+#@NAME: emenlow
+
+#@DESCRIPTION: Machine configuration for eMenlow based systems, like the
+# Webs-2120 box.
+
+TARGET_ARCH = "i686"
+PACKAGE_EXTRA_ARCHS = "x86 core2"
+
+include conf/machine/include/tune-atom.inc
+
+MACHINE_FEATURES = "kernel26 screen keyboard pci usbhost ext2 ext3 x86 \
+                    acpi serial usbgadget"
+
+KERNEL_IMAGETYPE = "bzImage"
+
+PREFERRED_PROVIDER_libdrm = "libdrm-poulsbo"
+PREFERRED_PROVIDER_drm = "libdrm-poulsbo"
+PREFERRED_PROVIDER_virtual/libx11 = "libx11-trim"
+PREFERRED_PROVIDER_virtual/libgl = "xpsb-glx"
+PREFERRED_PROVIDER_virtual/xserver = "xserver-psb"
+PREFERRED_PROVIDER_virtual/xserver-xf86 = "xserver-psb"
+PREFERRED_PROVIDER_xserver-xf86-dri-lite = "xserver-psb"
+
+XSERVER ?= "xserver-psb \
+           xf86-input-mouse \
+           xf86-input-keyboard \
+           xf86-input-evdev"
+
+SERIAL_CONSOLE = "115200 ttyS0"
+
+MACHINE_EXTRA_RRECOMMENDS = "kernel-modules eee-acpi-scripts"
+
+GUI_MACHINE_CLASS = "bigscreen"
+
+IMAGE_ROOTFS_SIZE_ext3 = "2000000"
+
+IMAGE_FSTYPES ?= "ext3 cpio.gz"
+
+GLIBC_ADDONS = "nptl"
+GLIBC_EXTRA_OECONF = "--with-tls"
diff --git a/meta-emenlow/packages/formfactor/files/emenlow/config b/meta-emenlow/packages/formfactor/files/emenlow/config
new file mode 100644
index 0000000000..682348d8e6
--- /dev/null
+++ b/meta-emenlow/packages/formfactor/files/emenlow/config
@@ -0,0 +1 @@
+HAVE_TOUCHSCREEN=0
diff --git a/meta-emenlow/packages/formfactor/formfactor_0.0.bbappend b/meta-emenlow/packages/formfactor/formfactor_0.0.bbappend
new file mode 100644
index 0000000000..77958e87cc
--- /dev/null
+++ b/meta-emenlow/packages/formfactor/formfactor_0.0.bbappend
@@ -0,0 +1,3 @@
+FILESPATH := "${FILESPATH}:${@os.path.dirname(bb.data.getVar('FILE', d, True))}"
+
+PR = "r26"
diff --git a/meta-emenlow/packages/libdrm-poulsbo/libdrm-poulsbo_2.3.0.bb b/meta-emenlow/packages/libdrm-poulsbo/libdrm-poulsbo_2.3.0.bb
new file mode 100644
index 0000000000..8a06dce8cc
--- /dev/null
+++ b/meta-emenlow/packages/libdrm-poulsbo/libdrm-poulsbo_2.3.0.bb
@@ -0,0 +1,14 @@
+DESCRIPTION = "Userspace interface to kernel DRM services"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://MIT_License.txt;md5=732825ecdcf420261531d935fcd914a7"
+PR="r1"
+
+PROVIDES = "libdrm-poulsbo libdrm drm"
+
+inherit autotools pkgconfig
+
+SRC_URI = "https://launchpad.net/~gma500/+archive/ppa/+files/libdrm-poulsbo_2.3.0-1ubuntu0sarvatt4~1004um1ubuntu1.tar.gz"
+
+do_install_append() {
+	cp ${D}/${libdir}/pkgconfig/libdrm.pc ${D}/${libdir}/pkgconfig/libdrm-poulsbo.pc 
+}
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/033_g45_add_rgba_subpic.patch b/meta-emenlow/packages/libva/libva-0.31.0/033_g45_add_rgba_subpic.patch
new file mode 100644
index 0000000000..1b928b4c09
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/033_g45_add_rgba_subpic.patch
@@ -0,0 +1,111 @@
+From 6622e8eba85cea476f8ef5b8c3620c4a0f024dcd Mon Sep 17 00:00:00 2001
+From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date: Wed, 4 Nov 2009 10:56:54 +0000
+Subject: [PATCH] [G45] Add RGBA subpictures.
+
+---
+ i965_drv_video/i965_drv_video.c |   18 ++++++++++++++++++
+ i965_drv_video/i965_drv_video.h |    3 ++-
+ i965_drv_video/i965_render.c    |    8 ++++----
+ 3 files changed, 24 insertions(+), 5 deletions(-)
+
+diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c
+index 8f4bfc1..92c4785 100644
+--- a/i965_drv_video/i965_drv_video.c
++++ b/i965_drv_video/i965_drv_video.c
+@@ -70,6 +70,14 @@ i965_subpic_formats_map[I965_MAX_SUBPIC_FORMATS + 1] = {
+     { I965_SURFACETYPE_INDEXED, I965_SURFACEFORMAT_A4P4_UNORM,
+       { VA_FOURCC('A','I','4','4'), VA_MSB_FIRST, 8, },
+       0 },
++    { I965_SURFACETYPE_RGBA, I965_SURFACEFORMAT_B8G8R8A8_UNORM,
++      { VA_FOURCC('B','G','R','A'), VA_LSB_FIRST, 32,
++        32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 },
++      0 },
++    { I965_SURFACETYPE_RGBA, I965_SURFACEFORMAT_R8G8B8A8_UNORM,
++      { VA_FOURCC('R','G','B','A'), VA_LSB_FIRST, 32,
++        32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 },
++      0 },
+ };
+ 
+ static const i965_subpic_format_map_t *
+@@ -467,6 +475,7 @@ i965_CreateSubpicture(VADriverContextP ctx,
+     obj_subpic->format = m->format;
+     obj_subpic->width  = obj_image->image.width;
+     obj_subpic->height = obj_image->image.height;
++    obj_subpic->pitch  = obj_image->image.pitches[0];
+     obj_subpic->bo     = obj_image->bo;
+     return VA_STATUS_SUCCESS;
+ }
+@@ -1218,6 +1227,15 @@ i965_CreateImage(VADriverContextP ctx,
+         image->component_order[1]  = 'G';
+         image->component_order[2]  = 'B';
+         break;
++    case VA_FOURCC('A','R','G','B'):
++    case VA_FOURCC('A','B','G','R'):
++    case VA_FOURCC('B','G','R','A'):
++    case VA_FOURCC('R','G','B','A'):
++        image->num_planes = 1;
++        image->pitches[0] = width * 4;
++        image->offsets[0] = 0;
++        image->data_size  = image->offsets[0] + image->pitches[0] * height;
++        break;
+     default:
+         goto error;
+     }
+diff --git a/i965_drv_video/i965_drv_video.h b/i965_drv_video/i965_drv_video.h
+index c95c799..4d775da 100644
+--- a/i965_drv_video/i965_drv_video.h
++++ b/i965_drv_video/i965_drv_video.h
+@@ -42,7 +42,7 @@
+ #define I965_MAX_ENTRYPOINTS                    5
+ #define I965_MAX_CONFIG_ATTRIBUTES              10
+ #define I965_MAX_IMAGE_FORMATS                  10
+-#define I965_MAX_SUBPIC_FORMATS                 2
++#define I965_MAX_SUBPIC_FORMATS                 4
+ #define I965_MAX_DISPLAY_ATTRIBUTES             4
+ #define I965_STR_VENDOR                         "i965 Driver 0.1"
+ 
+@@ -124,6 +124,7 @@ struct object_subpic
+     unsigned int format;
+     int width;
+     int height;
++    int pitch;
+     dri_bo *bo;
+ };
+ 
+diff --git a/i965_drv_video/i965_render.c b/i965_drv_video/i965_render.c
+index f105e90..0476087 100644
+--- a/i965_drv_video/i965_render.c
++++ b/i965_drv_video/i965_render.c
+@@ -586,7 +586,7 @@ i965_subpic_render_src_surface_state(VADriverContextP ctx,
+                               int index,
+                               dri_bo *region,
+                               unsigned long offset,
+-                              int w, int h, int format)
++                              int w, int h, int p, int format)
+ {
+     struct i965_driver_data *i965 = i965_driver_data(ctx);  
+     struct i965_render_state *render_state = &i965->render_state;
+@@ -620,7 +620,7 @@ i965_subpic_render_src_surface_state(VADriverContextP ctx,
+     ss->ss2.mip_count = 0;
+     ss->ss2.render_target_rotation = 0;
+ 
+-    ss->ss3.pitch = w - 1;
++    ss->ss3.pitch = p - 1;
+ 
+     dri_bo_emit_reloc(ss_bo,
+                       I915_GEM_DOMAIN_SAMPLER, 0,
+@@ -678,8 +678,8 @@ i965_subpic_render_src_surfaces_state(VADriverContextP ctx,
+     region = obj_surface->bo;
+     subpic_region = obj_image->bo;
+     /*subpicture surface*/
+-    i965_subpic_render_src_surface_state(ctx, 1, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->format);     
+-    i965_subpic_render_src_surface_state(ctx, 2, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->format);     
++    i965_subpic_render_src_surface_state(ctx, 1, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->pitch, obj_subpic->format);     
++    i965_subpic_render_src_surface_state(ctx, 2, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->pitch, obj_subpic->format);     
+ }
+ 
+ static void
+-- 
+1.5.4.3
+
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/034_g45_fix_return_for_unimpl.patch b/meta-emenlow/packages/libva/libva-0.31.0/034_g45_fix_return_for_unimpl.patch
new file mode 100644
index 0000000000..a4612133bb
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/034_g45_fix_return_for_unimpl.patch
@@ -0,0 +1,83 @@
+From 3935c6a836b8f90947f0af658a76b97a08a03c67 Mon Sep 17 00:00:00 2001
+From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date: Wed, 4 Nov 2009 13:23:40 +0000
+Subject: [PATCH] [G45] Don't return VA_STATUS_SUCCESS for unimplemented functions.
+
+---
+ i965_drv_video/i965_drv_video.c |   18 +++++++++++-------
+ 1 files changed, 11 insertions(+), 7 deletions(-)
+
+diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c
+index 10baffb..d8a7bd1 100644
+--- a/i965_drv_video/i965_drv_video.c
++++ b/i965_drv_video/i965_drv_video.c
+@@ -534,7 +534,8 @@ i965_SetSubpictureImage(VADriverContextP ctx,
+                         VASubpictureID subpicture,
+                         VAImageID image)
+ {
+-    return VA_STATUS_SUCCESS;
++    /* TODO */
++    return VA_STATUS_ERROR_UNIMPLEMENTED;
+ }
+ 
+ VAStatus 
+@@ -544,7 +545,8 @@ i965_SetSubpictureChromakey(VADriverContextP ctx,
+                             unsigned int chromakey_max,
+                             unsigned int chromakey_mask)
+ {
+-    return VA_STATUS_SUCCESS;
++    /* TODO */
++    return VA_STATUS_ERROR_UNIMPLEMENTED;
+ }
+ 
+ VAStatus 
+@@ -552,7 +554,8 @@ i965_SetSubpictureGlobalAlpha(VADriverContextP ctx,
+                               VASubpictureID subpicture,
+                               float global_alpha)
+ {
+-    return VA_STATUS_SUCCESS;
++    /* TODO */
++    return VA_STATUS_ERROR_UNIMPLEMENTED;
+ }
+ 
+ VAStatus 
+@@ -1141,7 +1144,7 @@ i965_GetDisplayAttributes(VADriverContextP ctx,
+                           int num_attributes)
+ {
+     /* TODO */
+-    return VA_STATUS_ERROR_UNKNOWN;
++    return VA_STATUS_ERROR_UNIMPLEMENTED;
+ }
+ 
+ /* 
+@@ -1156,7 +1159,7 @@ i965_SetDisplayAttributes(VADriverContextP ctx,
+                           int num_attributes)
+ {
+     /* TODO */
+-    return VA_STATUS_ERROR_UNKNOWN;
++    return VA_STATUS_ERROR_UNIMPLEMENTED;
+ }
+ 
+ VAStatus 
+@@ -1166,7 +1169,7 @@ i965_DbgCopySurfaceToBuffer(VADriverContextP ctx,
+                             unsigned int *stride)       /* out */
+ {
+     /* TODO */
+-    return VA_STATUS_ERROR_UNKNOWN;
++    return VA_STATUS_ERROR_UNIMPLEMENTED;
+ }
+ 
+ static VAStatus 
+@@ -1318,7 +1321,8 @@ VAStatus i965_DeriveImage(VADriverContextP ctx,
+                           VASurfaceID surface,
+                           VAImage *image)        /* out */
+ {
+-    return VA_STATUS_SUCCESS;
++    /* TODO */
++    return VA_STATUS_ERROR_OPERATION_FAILED;
+ }
+ 
+ static void 
+-- 
+1.5.4.3
+
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/035_g45_add_yv12_image_format.patch b/meta-emenlow/packages/libva/libva-0.31.0/035_g45_add_yv12_image_format.patch
new file mode 100644
index 0000000000..92d814c1a8
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/035_g45_add_yv12_image_format.patch
@@ -0,0 +1,102 @@
+From 23b23e8d65551779f10aedddee7882c2e71ac162 Mon Sep 17 00:00:00 2001
+From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date: Wed, 4 Nov 2009 13:01:44 +0000
+Subject: [PATCH] [G45] Add YV12 image format.
+
+---
+ i965_drv_video/i965_drv_video.c |   50 ++++++++++++++++++++++++++++++++++++++-
+ i965_drv_video/i965_drv_video.h |    2 +-
+ 2 files changed, 50 insertions(+), 2 deletions(-)
+
+diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c
+index 1f026bc..8558d0e 100644
+--- a/i965_drv_video/i965_drv_video.c
++++ b/i965_drv_video/i965_drv_video.c
+@@ -54,6 +54,36 @@ enum {
+     I965_SURFACETYPE_INDEXED
+ };
+ 
++/* List of supported image formats */
++typedef struct {
++    unsigned int        type;
++    VAImageFormat       va_format;
++} i965_image_format_map_t;
++
++static const i965_image_format_map_t
++i965_image_formats_map[I965_MAX_IMAGE_FORMATS + 1] = {
++    { I965_SURFACETYPE_YUV,
++      { VA_FOURCC('Y','V','1','2'), VA_LSB_FIRST, 12, } },
++};
++
++static const i965_image_format_map_t *
++get_image_format(const VAImageFormat *va_format)
++{
++    unsigned int i;
++    for (i = 0; i965_image_formats_map[i].type != 0; i++) {
++        const i965_image_format_map_t * const m = &i965_image_formats_map[i];
++        if (m->va_format.fourcc == va_format->fourcc &&
++            (m->type == I965_SURFACETYPE_RGBA ?
++             (m->va_format.byte_order == va_format->byte_order &&
++              m->va_format.red_mask   == va_format->red_mask   &&
++              m->va_format.green_mask == va_format->green_mask &&
++              m->va_format.blue_mask  == va_format->blue_mask  &&
++              m->va_format.alpha_mask == va_format->alpha_mask) : 1))
++            return m;
++    }
++    return NULL;
++}
++
+ /* List of supported subpicture formats */
+ typedef struct {
+     unsigned int        type;
+@@ -398,8 +428,16 @@ i965_QueryImageFormats(VADriverContextP ctx,
+                        VAImageFormat *format_list,      /* out */
+                        int *num_formats)                /* out */
+ {
++    int n;
++
++    for (n = 0; i965_image_formats_map[n].va_format.fourcc != 0; n++) {
++        const i965_image_format_map_t * const m = &i965_image_formats_map[n];
++        if (format_list)
++            format_list[n] = m->va_format;
++    }
++
+     if (num_formats)
+-        *num_formats = 0;
++        *num_formats = n;
+ 
+     return VA_STATUS_SUCCESS;
+ }
+@@ -1236,6 +1274,16 @@ i965_CreateImage(VADriverContextP ctx,
+         image->offsets[0] = 0;
+         image->data_size  = image->offsets[0] + image->pitches[0] * height;
+         break;
++    case VA_FOURCC('Y','V','1','2'):
++        image->num_planes = 3;
++        image->pitches[0] = width;
++        image->offsets[0] = 0;
++        image->pitches[1] = width2;
++        image->offsets[1] = size;
++        image->pitches[2] = width2;
++        image->offsets[2] = size + size2;
++        image->data_size  = size + 2 * size2;
++        break;
+     default:
+         goto error;
+     }
+diff --git a/i965_drv_video/i965_drv_video.h b/i965_drv_video/i965_drv_video.h
+index 4d775da..f512793 100644
+--- a/i965_drv_video/i965_drv_video.h
++++ b/i965_drv_video/i965_drv_video.h
+@@ -41,7 +41,7 @@
+ #define I965_MAX_PROFILES                       11
+ #define I965_MAX_ENTRYPOINTS                    5
+ #define I965_MAX_CONFIG_ATTRIBUTES              10
+-#define I965_MAX_IMAGE_FORMATS                  10
++#define I965_MAX_IMAGE_FORMATS                  1
+ #define I965_MAX_SUBPIC_FORMATS                 4
+ #define I965_MAX_DISPLAY_ATTRIBUTES             4
+ #define I965_STR_VENDOR                         "i965 Driver 0.1"
+-- 
+1.5.4.3
+
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/036_g45_add_vaGetImage.patch b/meta-emenlow/packages/libva/libva-0.31.0/036_g45_add_vaGetImage.patch
new file mode 100644
index 0000000000..dc25d9f9e9
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/036_g45_add_vaGetImage.patch
@@ -0,0 +1,71 @@
+From 37f40c0cdc9667907dfb784874b42fb16c2c9bde Mon Sep 17 00:00:00 2001
+From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date: Wed, 4 Nov 2009 13:16:34 +0000
+Subject: [PATCH] =?utf-8?q?[G45]=C2=A0Implement=20vaGetImage()=20for=20full-sized=20surface=20readback.?=
+MIME-Version: 1.0
+Content-Type: text/plain; charset=utf-8
+Content-Transfer-Encoding: 8bit
+
+---
+ i965_drv_video/i965_drv_video.c |   45 ++++++++++++++++++++++++++++++++++++++-
+ 1 files changed, 44 insertions(+), 1 deletions(-)
+
+diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c
+index 8558d0e..10baffb 100644
+--- a/i965_drv_video/i965_drv_video.c
++++ b/i965_drv_video/i965_drv_video.c
+@@ -1388,7 +1388,50 @@ i965_GetImage(VADriverContextP ctx,
+               unsigned int height,
+               VAImageID image)
+ {
+-    return VA_STATUS_SUCCESS;
++    struct i965_driver_data *i965 = i965_driver_data(ctx);
++
++    struct object_surface *obj_surface = SURFACE(surface);
++    if (!obj_surface)
++        return VA_STATUS_ERROR_INVALID_SURFACE;
++
++    struct object_image *obj_image = IMAGE(image);
++    if (!obj_image)
++        return VA_STATUS_ERROR_INVALID_IMAGE;
++
++    /* XXX: we only support full-size surface readback */
++    if (x != 0 ||
++        y != 0 ||
++        width != obj_surface->width ||
++        height != obj_surface->height)
++        return VA_STATUS_ERROR_INVALID_PARAMETER;
++
++    /* XXX: we only support 1:1 image copies */
++    if (width != obj_image->image.width ||
++        height != obj_image->image.height)
++        return VA_STATUS_ERROR_INVALID_PARAMETER;
++
++    VAStatus va_status;
++    void *image_data = NULL;
++
++    va_status = i965_MapBuffer(ctx, obj_image->image.buf, &image_data);
++    if (va_status != VA_STATUS_SUCCESS)
++        return va_status;
++
++    dri_bo_map(obj_surface->bo, 0);
++
++    switch (obj_image->image.format.fourcc) {
++    case VA_FOURCC('Y','V','1','2'): /* YV12 is native format here */
++        memcpy(image_data, obj_surface->bo->virtual, obj_surface->bo->size);
++        break;
++    default:
++        va_status = VA_STATUS_ERROR_OPERATION_FAILED;
++        break;
++    }
++
++    dri_bo_unmap(obj_surface->bo);
++
++    i965_UnmapBuffer(ctx, obj_image->image.buf);
++    return va_status;
+ }
+ 
+ VAStatus 
+-- 
+1.5.4.3
+
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/037_g45_add_vaPutImage.patch b/meta-emenlow/packages/libva/libva-0.31.0/037_g45_add_vaPutImage.patch
new file mode 100644
index 0000000000..ce638cce52
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/037_g45_add_vaPutImage.patch
@@ -0,0 +1,111 @@
+From 000807cfbd8bcbc9cd4bf28a066087fee43396b4 Mon Sep 17 00:00:00 2001
+From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date: Wed, 4 Nov 2009 13:36:39 +0000
+Subject: [PATCH] =?utf-8?q?[G45]=C2=A0Implement=20vaPutImage()=20for=20full-sized=20surface=20uploads.?=
+MIME-Version: 1.0
+Content-Type: text/plain; charset=utf-8
+Content-Transfer-Encoding: 8bit
+
+---
+ i965_drv_video/i965_drv_video.c |   78 +++++++++++++++++++++++++++++++--------
+ 1 files changed, 62 insertions(+), 16 deletions(-)
+
+diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c
+index d8a7bd1..e8f638c 100644
+--- a/i965_drv_video/i965_drv_video.c
++++ b/i965_drv_video/i965_drv_video.c
+@@ -443,22 +443,6 @@ i965_QueryImageFormats(VADriverContextP ctx,
+ }
+ 
+ VAStatus 
+-i965_PutImage(VADriverContextP ctx,
+-               VASurfaceID surface,
+-               VAImageID image,
+-               int src_x,
+-               int src_y,
+-               unsigned int src_width,
+-               unsigned int src_height,
+-               int dest_x,
+-               int dest_y,
+-               unsigned int dest_width,
+-               unsigned int dest_height)
+-{
+-    return VA_STATUS_SUCCESS;
+-}
+-
+-VAStatus 
+ i965_QuerySubpictureFormats(VADriverContextP ctx,
+                             VAImageFormat *format_list,         /* out */
+                             unsigned int *flags,                /* out */
+@@ -1439,6 +1423,68 @@ i965_GetImage(VADriverContextP ctx,
+ }
+ 
+ VAStatus 
++i965_PutImage(VADriverContextP ctx,
++               VASurfaceID surface,
++               VAImageID image,
++               int src_x,
++               int src_y,
++               unsigned int src_width,
++               unsigned int src_height,
++               int dest_x,
++               int dest_y,
++               unsigned int dest_width,
++               unsigned int dest_height)
++{
++    struct i965_driver_data *i965 = i965_driver_data(ctx);
++
++    struct object_surface *obj_surface = SURFACE(surface);
++    if (!obj_surface)
++        return VA_STATUS_ERROR_INVALID_SURFACE;
++
++    struct object_image *obj_image = IMAGE(image);
++    if (!obj_image)
++        return VA_STATUS_ERROR_INVALID_IMAGE;
++
++    /* XXX: we don't support partial video surface updates */
++    if (src_x != 0 ||
++        src_y != 0 ||
++        src_width != obj_image->image.width ||
++        src_height != obj_image->image.height)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++    if (dest_x != 0 ||
++        dest_y != 0 ||
++        dest_width != obj_surface->width ||
++        dest_height != obj_surface->height)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++    if (src_width != dest_width ||
++        src_height != dest_height)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++
++    VAStatus va_status;
++    void *image_data = NULL;
++
++    va_status = i965_MapBuffer(ctx, obj_image->image.buf, &image_data);
++    if (va_status != VA_STATUS_SUCCESS)
++        return va_status;
++
++    dri_bo_map(obj_surface->bo, 1);
++
++    switch (obj_image->image.format.fourcc) {
++    case VA_FOURCC('Y','V','1','2'): /* YV12 is native format here */
++        memcpy(obj_surface->bo->virtual, image_data, obj_surface->bo->size);
++        break;
++    default:
++        va_status = VA_STATUS_ERROR_OPERATION_FAILED;
++        break;
++    }
++
++    dri_bo_unmap(obj_surface->bo);
++
++    i965_UnmapBuffer(ctx, obj_image->image.buf);
++    return va_status;
++}
++
++VAStatus 
+ i965_PutSurface(VADriverContextP ctx,
+                 VASurfaceID surface,
+                 Drawable draw, /* X Drawable */
+-- 
+1.5.4.3
+
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/038_g45_vaPutSurface_cliprects.patch b/meta-emenlow/packages/libva/libva-0.31.0/038_g45_vaPutSurface_cliprects.patch
new file mode 100644
index 0000000000..ca2e1bd471
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/038_g45_vaPutSurface_cliprects.patch
@@ -0,0 +1,531 @@
+From 90de12a47e26ccc0b4cc8189c76991609481870d Mon Sep 17 00:00:00 2001
+From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date: Wed, 4 Nov 2009 17:34:53 +0000
+Subject: [PATCH] [G45] Handle cliprects in vaPutSurface().
+
+---
+ i965_drv_video/i965_drv_video.c |   39 ++++--
+ i965_drv_video/i965_render.c    |  284 +++++++++++++++++++--------------------
+ i965_drv_video/i965_render.h    |   30 ++---
+ 3 files changed, 176 insertions(+), 177 deletions(-)
+
+diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c
+index e8f638c..20d6bab 100644
+--- a/i965_drv_video/i965_drv_video.c
++++ b/i965_drv_video/i965_drv_video.c
+@@ -1507,13 +1507,23 @@ i965_PutSurface(VADriverContextP ctx,
+     union dri_buffer *buffer;
+     struct intel_region *dest_region;
+     struct object_surface *obj_surface; 
+-	int ret;
++    int ret;
+     uint32_t name;
++    VARectangle src_rect, dst_rect;
+     Bool new_region = False;
++
+     /* Currently don't support DRI1 */
+     if (dri_state->driConnectedFlag != VA_DRI2)
+         return VA_STATUS_ERROR_UNKNOWN;
+ 
++    /* XXX: we currently only support up to 64 cliprects */
++    if (number_cliprects > MAX_CLIP_RECTS)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++
++    obj_surface = SURFACE(surface);
++    if (!obj_surface)
++        return VA_STATUS_ERROR_INVALID_SURFACE;
++
+     dri_drawable = dri_get_drawable(ctx, draw);
+     assert(dri_drawable);
+ 
+@@ -1552,17 +1562,24 @@ i965_PutSurface(VADriverContextP ctx,
+         assert(ret == 0);
+     }
+ 
+-    i965_render_put_surface(ctx, surface,
+-                            srcx, srcy, srcw, srch,
+-                            destx, desty, destw, desth);
+-    obj_surface = SURFACE(surface);
+-    if(obj_surface->subpic != VA_INVALID_ID) {	
+-	i965_render_put_subpic(ctx, surface,
+-                           srcx, srcy, srcw, srch,
+-                           destx, desty, destw, desth);
+-    } 
+-    dri_swap_buffer(ctx, dri_drawable);
++    src_rect.x      = srcx;
++    src_rect.y      = srcy;
++    src_rect.width  = srcw;
++    src_rect.height = srch;
++
++    dst_rect.x      = destx;
++    dst_rect.y      = desty;
++    dst_rect.width  = destw;
++    dst_rect.height = desth;
+ 
++    i965_render_put_surface(ctx, surface, &src_rect, &dst_rect,
++                            cliprects, number_cliprects);
++
++    if (obj_surface->subpic != VA_INVALID_ID)
++	i965_render_put_subpic(ctx, surface, &src_rect, &dst_rect,
++                               cliprects, number_cliprects);
++
++    dri_swap_buffer(ctx, dri_drawable);
+     return VA_STATUS_SUCCESS;
+ }
+ 
+diff --git a/i965_drv_video/i965_render.c b/i965_drv_video/i965_render.c
+index 0476087..d7cd8fe 100644
+--- a/i965_drv_video/i965_render.c
++++ b/i965_drv_video/i965_render.c
+@@ -787,13 +787,81 @@ i965_render_binding_table(VADriverContextP ctx)
+     dri_bo_unmap(render_state->wm.binding_table);
+ }
+ 
+-static void 
++static unsigned int
++i965_render_do_upload_vertex(VADriverContextP   ctx,
++                             unsigned int       width,
++                             unsigned int       height,
++                             const VARectangle *src_rect,
++                             const VARectangle *dst_rect,
++                             const VARectangle *cliprects,
++                             unsigned int       num_cliprects)
++{
++    struct i965_driver_data *i965 = i965_driver_data(ctx);
++    struct i965_render_state *render_state = &i965->render_state;
++    struct intel_region *dest_region = render_state->draw_region;
++    float *vb, tx1, tx2, ty1, ty2;
++    int x1, x2, y1, y2;
++    unsigned int i, n;
++
++    if (!cliprects || num_cliprects == 0) {
++        cliprects = dst_rect;
++        num_cliprects = 1;
++    }
++
++    dri_bo_map(render_state->vb.vertex_buffer, 1);
++    assert(render_state->vb.vertex_buffer->virtual);
++    vb = render_state->vb.vertex_buffer->virtual;
++
++    for (n = 0, i = 0; i < num_cliprects; i++) {
++        x1 = dest_region->x + cliprects[i].x;
++        y1 = dest_region->y + cliprects[i].y;
++        x2 = x1 + cliprects[i].width;
++        y2 = y1 + cliprects[i].height;
++        x1 = MAX(x1, dst_rect->x);
++        y1 = MAX(y1, dst_rect->y);
++        x2 = MIN(x2, dst_rect->x + dst_rect->width);
++        y2 = MIN(y2, dst_rect->y + dst_rect->height);
++
++        if (x2 <= x1 || y2 <= y1)
++            continue;
++
++        const float sx1 = (float)(x1 - dst_rect->x) / (float)dst_rect->width;
++        const float sy1 = (float)(y1 - dst_rect->y) / (float)dst_rect->height;
++        const float sx2 = (float)(x2 - dst_rect->x) / (float)dst_rect->width;
++        const float sy2 = (float)(y2 - dst_rect->y) / (float)dst_rect->height;
++        tx1 = ((float)src_rect->x + sx1 * (float)src_rect->width) / width;
++        ty1 = ((float)src_rect->y + sy1 * (float)src_rect->height) / height;
++        tx2 = ((float)src_rect->x + sx2 * (float)src_rect->width) / width;
++        ty2 = ((float)src_rect->y + sy2 * (float)src_rect->height) / height;
++
++        vb[n++] = tx2;
++        vb[n++] = ty2;
++        vb[n++] = x2;
++        vb[n++] = y2;
++
++        vb[n++] = tx1;
++        vb[n++] = ty2;
++        vb[n++] = x1;
++        vb[n++] = y2;
++
++        vb[n++] = tx1;
++        vb[n++] = ty1;
++        vb[n++] = x1;
++        vb[n++] = y1;
++    }
++
++    dri_bo_unmap(render_state->vb.vertex_buffer);
++    return n / 12;
++}
++
++static unsigned int
+ i965_subpic_render_upload_vertex(VADriverContextP ctx,
+                                  VASurfaceID surface,
+-                                 const VARectangle *output_rect)
+-{    
++                                 const VARectangle *output_rect,
++                                 const VARectangle *cliprects,
++                                 unsigned int num_cliprects)
++{
+     struct i965_driver_data  *i965         = i965_driver_data(ctx);
+-    struct i965_render_state *render_state = &i965->render_state;
+     struct object_surface    *obj_surface  = SURFACE(surface);
+     struct object_subpic     *obj_subpic   = SUBPIC(obj_surface->subpic);
+ 
+@@ -803,8 +871,6 @@ i965_subpic_render_upload_vertex(VADriverContextP ctx,
+     const float ssy = (float)output_rect->height / (float)obj_surface->height;
+     const float sx  = psx * ssx;
+     const float sy  = psy * ssy;
+-    float *vb, tx1, tx2, ty1, ty2, x1, x2, y1, y2;
+-    int i = 0;
+ 
+     VARectangle dst_rect;
+     dst_rect.x      = output_rect->x + sx * (float)obj_subpic->dst_rect.x;
+@@ -812,106 +878,38 @@ i965_subpic_render_upload_vertex(VADriverContextP ctx,
+     dst_rect.width  = sx * (float)obj_subpic->dst_rect.width;
+     dst_rect.height = sy * (float)obj_subpic->dst_rect.height;
+ 
+-    dri_bo_map(render_state->vb.vertex_buffer, 1);
+-    assert(render_state->vb.vertex_buffer->virtual);
+-    vb = render_state->vb.vertex_buffer->virtual;
+-
+-    tx1 = (float)obj_subpic->src_rect.x / (float)obj_subpic->width;
+-    ty1 = (float)obj_subpic->src_rect.y / (float)obj_subpic->height;
+-    tx2 = (float)(obj_subpic->src_rect.x + obj_subpic->src_rect.width) / (float)obj_subpic->width;
+-    ty2 = (float)(obj_subpic->src_rect.y + obj_subpic->src_rect.height) / (float)obj_subpic->height;
+-
+-    x1 = (float)dst_rect.x;
+-    y1 = (float)dst_rect.y;
+-    x2 = (float)(dst_rect.x + dst_rect.width);
+-    y2 = (float)(dst_rect.y + dst_rect.height);
+-
+-    vb[i++] = tx2;
+-    vb[i++] = ty2;
+-    vb[i++] = x2;
+-    vb[i++] = y2;
+-
+-    vb[i++] = tx1;
+-    vb[i++] = ty2;
+-    vb[i++] = x1;
+-    vb[i++] = y2;
+-
+-    vb[i++] = tx1;
+-    vb[i++] = ty1;
+-    vb[i++] = x1;
+-    vb[i++] = y1;
+-    dri_bo_unmap(render_state->vb.vertex_buffer);
++    return i965_render_do_upload_vertex(ctx,
++                                        obj_subpic->width, obj_subpic->height,
++                                        &obj_subpic->src_rect, &dst_rect,
++                                        cliprects, num_cliprects);
+ }
+ 
+-static void 
++static unsigned int 
+ i965_render_upload_vertex(VADriverContextP ctx,
+                           VASurfaceID surface,
+-                          short srcx,
+-                          short srcy,
+-                          unsigned short srcw,
+-                          unsigned short srch,
+-                          short destx,
+-                          short desty,
+-                          unsigned short destw,
+-                          unsigned short desth)
++                          const VARectangle *src_rect,
++                          const VARectangle *dst_rect,
++                          const VARectangle *cliprects,
++                          unsigned int num_cliprects)
+ {
+     struct i965_driver_data *i965 = i965_driver_data(ctx);
+-    struct i965_render_state *render_state = &i965->render_state;
+-    struct intel_region *dest_region = render_state->draw_region;
+-    struct object_surface *obj_surface;
+-    float *vb;
+-
+-    float u1, v1, u2, v2;
+-    int i, width, height;
+-    int box_x1 = dest_region->x + destx;
+-    int box_y1 = dest_region->y + desty;
+-    int box_x2 = box_x1 + destw;
+-    int box_y2 = box_y1 + desth;
+-
+-    obj_surface = SURFACE(surface);
+-    assert(surface);
+-    width = obj_surface->width;
+-    height = obj_surface->height;
+-
+-    u1 = (float)srcx / width;
+-    v1 = (float)srcy / height;
+-    u2 = (float)(srcx + srcw) / width;
+-    v2 = (float)(srcy + srch) / height;
+-
+-    dri_bo_map(render_state->vb.vertex_buffer, 1);
+-    assert(render_state->vb.vertex_buffer->virtual);
+-    vb = render_state->vb.vertex_buffer->virtual;
+-
+-    i = 0;
+-    vb[i++] = u2;
+-    vb[i++] = v2;
+-    vb[i++] = (float)box_x2;
+-    vb[i++] = (float)box_y2;
+-    
+-    vb[i++] = u1;
+-    vb[i++] = v2;
+-    vb[i++] = (float)box_x1;
+-    vb[i++] = (float)box_y2;
+-
+-    vb[i++] = u1;
+-    vb[i++] = v1;
+-    vb[i++] = (float)box_x1;
+-    vb[i++] = (float)box_y1;
++    struct object_surface *obj_surface = SURFACE(surface);
++    assert(obj_surface);
+ 
+-    dri_bo_unmap(render_state->vb.vertex_buffer);
++    return i965_render_do_upload_vertex(ctx,
++                                        obj_surface->width, obj_surface->height,
++                                        src_rect,
++                                        dst_rect,
++                                        cliprects, num_cliprects);
+ }
+ 
+-static void
++static unsigned int
+ i965_surface_render_state_setup(VADriverContextP ctx,
+-                        VASurfaceID surface,
+-                        short srcx,
+-                        short srcy,
+-                        unsigned short srcw,
+-                        unsigned short srch,
+-                        short destx,
+-                        short desty,
+-                        unsigned short destw,
+-                        unsigned short desth)
++                                VASurfaceID surface,
++                                const VARectangle *src_rect,
++                                const VARectangle *dst_rect,
++                                const VARectangle *cliprects,
++                                unsigned int num_cliprects)
+ {
+     i965_render_vs_unit(ctx);
+     i965_render_sf_unit(ctx);
+@@ -922,21 +920,17 @@ i965_surface_render_state_setup(VADriverContextP ctx,
+     i965_render_cc_viewport(ctx);
+     i965_render_cc_unit(ctx);
+     i965_render_binding_table(ctx);
+-    i965_render_upload_vertex(ctx, surface,
+-                              srcx, srcy, srcw, srch,
+-                              destx, desty, destw, desth);
++    return i965_render_upload_vertex(ctx, surface, src_rect, dst_rect,
++                                     cliprects, num_cliprects);
+ }
+-static void
++
++static unsigned int
+ i965_subpic_render_state_setup(VADriverContextP ctx,
+-                        VASurfaceID surface,
+-                        short srcx,
+-                        short srcy,
+-                        unsigned short srcw,
+-                        unsigned short srch,
+-                        short destx,
+-                        short desty,
+-                        unsigned short destw,
+-                        unsigned short desth)
++                               VASurfaceID surface,
++                               const VARectangle *src_rect,
++                               const VARectangle *dst_rect,
++                               const VARectangle *cliprects,
++                               unsigned int num_cliprects)
+ {
+     i965_render_vs_unit(ctx);
+     i965_render_sf_unit(ctx);
+@@ -947,16 +941,10 @@ i965_subpic_render_state_setup(VADriverContextP ctx,
+     i965_render_cc_viewport(ctx);
+     i965_subpic_render_cc_unit(ctx);
+     i965_render_binding_table(ctx);
+-
+-    VARectangle output_rect;
+-    output_rect.x      = destx;
+-    output_rect.y      = desty;
+-    output_rect.width  = destw;
+-    output_rect.height = desth;
+-    i965_subpic_render_upload_vertex(ctx, surface, &output_rect);
++    return i965_subpic_render_upload_vertex(ctx, surface, dst_rect,
++                                            cliprects, num_cliprects);
+ }
+ 
+-
+ static void
+ i965_render_pipeline_select(VADriverContextP ctx)
+ {
+@@ -1192,7 +1180,7 @@ i965_render_upload_image_palette(
+ }
+ 
+ static void
+-i965_render_startup(VADriverContextP ctx)
++i965_render_startup(VADriverContextP ctx, unsigned int vb_offset)
+ {
+     struct i965_driver_data *i965 = i965_driver_data(ctx);
+     struct i965_render_state *render_state = &i965->render_state;
+@@ -1203,7 +1191,7 @@ i965_render_startup(VADriverContextP ctx)
+               (0 << VB0_BUFFER_INDEX_SHIFT) |
+               VB0_VERTEXDATA |
+               ((4 * 4) << VB0_BUFFER_PITCH_SHIFT));
+-    OUT_RELOC(ctx, render_state->vb.vertex_buffer, I915_GEM_DOMAIN_VERTEX, 0, 0);
++    OUT_RELOC(ctx, render_state->vb.vertex_buffer, I915_GEM_DOMAIN_VERTEX, 0, vb_offset);
+ 
+     if (IS_IGDNG(i965->intel.device_id))
+         OUT_RELOC(ctx, render_state->vb.vertex_buffer, I915_GEM_DOMAIN_VERTEX, 0, 12 * 4);
+@@ -1268,8 +1256,10 @@ i965_clear_dest_region(VADriverContextP ctx)
+ }
+ 
+ static void
+-i965_surface_render_pipeline_setup(VADriverContextP ctx)
++i965_surface_render_pipeline_setup(VADriverContextP ctx, unsigned int n_rects)
+ {
++    unsigned int i;
++
+     intel_batchbuffer_start_atomic(ctx, 0x1000);
+     intel_batchbuffer_emit_mi_flush(ctx);
+     i965_clear_dest_region(ctx);
+@@ -1283,13 +1273,16 @@ i965_surface_render_pipeline_setup(VADriverContextP ctx)
+     i965_render_cs_urb_layout(ctx);
+     i965_render_drawing_rectangle(ctx);
+     i965_render_vertex_elements(ctx);
+-    i965_render_startup(ctx);
++    for (i = 0; i < n_rects; i++)
++        i965_render_startup(ctx, 48 * i);
+     intel_batchbuffer_end_atomic(ctx);
+ }
+ 
+ static void
+-i965_subpic_render_pipeline_setup(VADriverContextP ctx)
++i965_subpic_render_pipeline_setup(VADriverContextP ctx, unsigned int n_rects)
+ {
++    unsigned int i;
++
+     intel_batchbuffer_start_atomic(ctx, 0x1000);
+     intel_batchbuffer_emit_mi_flush(ctx);
+     i965_render_pipeline_select(ctx);
+@@ -1302,7 +1295,8 @@ i965_subpic_render_pipeline_setup(VADriverContextP ctx)
+     i965_render_cs_urb_layout(ctx);
+     i965_render_drawing_rectangle(ctx);
+     i965_render_vertex_elements(ctx);
+-    i965_render_startup(ctx);
++    for (i = 0; i < n_rects; i++)
++        i965_render_startup(ctx, 48 * i);
+     intel_batchbuffer_end_atomic(ctx);
+ }
+ 
+@@ -1396,45 +1390,39 @@ i965_render_initialize(VADriverContextP ctx)
+ void
+ i965_render_put_surface(VADriverContextP ctx,
+                         VASurfaceID surface,
+-                        short srcx,
+-                        short srcy,
+-                        unsigned short srcw,
+-                        unsigned short srch,
+-                        short destx,
+-                        short desty,
+-                        unsigned short destw,
+-                        unsigned short desth)
++                        const VARectangle *src_rect,
++                        const VARectangle *dst_rect,
++                        const VARectangle *cliprects,
++                        unsigned int num_cliprects)
+ {
++    unsigned int n_rects;
++
+     i965_render_initialize(ctx);
+-    i965_surface_render_state_setup(ctx, surface,
+-                            srcx, srcy, srcw, srch,
+-                            destx, desty, destw, desth);
+-    i965_surface_render_pipeline_setup(ctx);
++    n_rects = i965_surface_render_state_setup(ctx, surface,
++                                              src_rect, dst_rect,
++                                              cliprects, num_cliprects);
++    i965_surface_render_pipeline_setup(ctx, n_rects);
+     intel_batchbuffer_flush(ctx);
+ }
+ 
+ void
+ i965_render_put_subpic(VADriverContextP ctx,
+-                        VASurfaceID surface,
+-                        short srcx,
+-                        short srcy,
+-                        unsigned short srcw,
+-                        unsigned short srch,
+-                        short destx,
+-                        short desty,
+-                        unsigned short destw,
+-                        unsigned short desth)
++                       VASurfaceID surface,
++                       const VARectangle *src_rect,
++                       const VARectangle *dst_rect,
++                       const VARectangle *cliprects,
++                       unsigned int num_cliprects)
+ {
+     struct i965_driver_data *i965 = i965_driver_data(ctx);
+     struct object_surface *obj_surface = SURFACE(surface);
+     struct object_subpic *obj_subpic = SUBPIC(obj_surface->subpic);
++    unsigned int n_rects;
+     assert(obj_subpic);
+ 
+     i965_render_initialize(ctx);
+-    i965_subpic_render_state_setup(ctx, surface,
+-	    srcx, srcy, srcw, srch,
+-	    destx, desty, destw, desth);
+-    i965_subpic_render_pipeline_setup(ctx);
++    n_rects = i965_subpic_render_state_setup(ctx, surface, src_rect, dst_rect,
++                                             cliprects, num_cliprects);
++    i965_subpic_render_pipeline_setup(ctx, n_rects);
+     i965_render_upload_image_palette(ctx, obj_subpic->image, 0xff);
+     intel_batchbuffer_flush(ctx);
+ }
+diff --git a/i965_drv_video/i965_render.h b/i965_drv_video/i965_render.h
+index e3dce02..d2e23f1 100644
+--- a/i965_drv_video/i965_render.h
++++ b/i965_drv_video/i965_render.h
+@@ -28,6 +28,7 @@
+ #ifndef _I965_RENDER_H_
+ #define _I965_RENDER_H_
+ 
++#define MAX_CLIP_RECTS          80 /* vb_bo:4096 / vb:(3*4*4) */
+ #define MAX_RENDER_SURFACES     16
+ #define MAX_SAMPLERS            16
+ 
+@@ -65,27 +66,20 @@ struct i965_render_state
+ 
+ Bool i965_render_init(VADriverContextP ctx);
+ Bool i965_render_terminate(VADriverContextP ctx);
++
+ void i965_render_put_surface(VADriverContextP ctx,
+                              VASurfaceID surface,
+-                             short srcx,
+-                             short srcy,
+-                             unsigned short srcw,
+-                             unsigned short srch,
+-                             short destx,
+-                             short desty,
+-                             unsigned short destw,
+-                             unsigned short desth);
+-
++                             const VARectangle *src_rect,
++                             const VARectangle *dst_rect,
++                             const VARectangle *cliprects,
++                             unsigned int num_cliprects);
+ 
+ void
+ i965_render_put_subpic(VADriverContextP ctx,
+-                        VASurfaceID surface,
+-                        short srcx,
+-                        short srcy,
+-                        unsigned short srcw,
+-                        unsigned short srch,
+-                        short destx,
+-                        short desty,
+-                        unsigned short destw,
+-                        unsigned short desth);
++                       VASurfaceID surface,
++                       const VARectangle *src_rect,
++                       const VARectangle *dst_rect,
++                       const VARectangle *cliprects,
++                       unsigned int num_cliprects);
++
+ #endif /* _I965_RENDER_H_ */
+-- 
+1.5.4.3
+
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/102_attribute_visibility.patch b/meta-emenlow/packages/libva/libva-0.31.0/102_attribute_visibility.patch
new file mode 100644
index 0000000000..2885ab7b5b
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/102_attribute_visibility.patch
@@ -0,0 +1,47 @@
+commit 8d0004cbd40305114bbe8019122319b43d25a772
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 8 12:34:39 2009 +0000
+
+    Fix ATTRIBUTE_HIDDEN definition if __attribute__((visibility("hidden"))) is not supported.
+
+commit 7a8bf489ffd436d853364dd0d3c9a6734b8cc7eb
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Sep 3 15:46:37 2009 +0000
+
+    Check for __attribute__((visibility("hidden"))).
+
+diff --git a/configure.ac b/configure.ac
+index da96872..abef435 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -132,6 +132,30 @@ if test x$enable_i965_driver = xyes && ! $PKG_CONFIG --atleast-version=2.4 libdr
+ fi
+ AM_CONDITIONAL(BUILD_I965_DRIVER, test x$enable_i965_driver = xyes)
+ 
++dnl Check for __attribute__((visibility()))
++AC_CACHE_CHECK([whether __attribute__((visibility())) is supported],
++    libva_cv_visibility_attribute,
++    [cat > conftest.c <<EOF
++int foo __attribute__ ((visibility ("hidden"))) = 1;
++int bar __attribute__ ((visibility ("protected"))) = 1;
++EOF
++    libva_cv_visibility_attribute=no
++    if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
++        if grep '\.hidden.*foo' conftest.s >/dev/null; then
++            if grep '\.protected.*bar' conftest.s >/dev/null; then
++	       libva_cv_visibility_attribute=yes
++            fi
++        fi
++    fi
++    rm -f conftest.[cs]
++])
++ATTRIBUTE_HIDDEN=""
++if test $libva_cv_visibility_attribute = yes; then
++    ATTRIBUTE_HIDDEN="__attribute__((visibility(\"hidden\")))"
++fi
++AC_DEFINE_UNQUOTED([ATTRIBUTE_HIDDEN], [$ATTRIBUTE_HIDDEN],
++    [Defined to __attribute__((visibility("hidden"))) when available])
++
+ # We only need the headers, we don't link against the DRM libraries
+ LIBVA_CFLAGS="$DRM_CFLAGS"
+ AC_SUBST(LIBVA_CFLAGS)
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/103_fix_vainfo_deps.patch b/meta-emenlow/packages/libva/libva-0.31.0/103_fix_vainfo_deps.patch
new file mode 100644
index 0000000000..942c26d1bd
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/103_fix_vainfo_deps.patch
@@ -0,0 +1,24 @@
+commit 11e626a3610daf0fce253ef48ab8736bce6178f9
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 22 12:29:56 2009 +0000
+
+    Fix vainfo dependencies (Konstantin Pavlov).
+
+diff --git a/test/Makefile.am b/test/Makefile.am
+index 58e1677..ee78d34 100644
+--- a/test/Makefile.am
++++ b/test/Makefile.am
+@@ -31,10 +31,10 @@ AM_CFLAGS = -I$(top_srcdir)/../../include/external/ -I$(top_srcdir)/src -I$(top_
+ 
+ TESTS = $(check_PROGRAMS)
+ 
+-TEST_LIBS = $(top_srcdir)/src/$(libvabackendlib)
++TEST_LIBS = $(top_srcdir)/src/libva.la $(top_srcdir)/src/$(libvabackendlib)
+ 
+-vainfo_LDADD = $(top_srcdir)/src/$(libvabackendlib)
+-vainfo_DEPENDENCIES = $(top_srcdir)/src/$(libvabackendlib)
++vainfo_LDADD = $(top_srcdir)/src/libva.la $(top_srcdir)/src/$(libvabackendlib)
++vainfo_DEPENDENCIES = $(top_srcdir)/src/libva.la $(top_srcdir)/src/$(libvabackendlib)
+ vainfo_SOURCES = vainfo.c
+ 
+ test_01_LDADD = $(TEST_LIBS)
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/104_fix_libva_pkgconfig_deps.patch b/meta-emenlow/packages/libva/libva-0.31.0/104_fix_libva_pkgconfig_deps.patch
new file mode 100644
index 0000000000..bd212bf39c
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/104_fix_libva_pkgconfig_deps.patch
@@ -0,0 +1,18 @@
+commit f0b352251894becfcec50de1430bda12c314a464
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 22 13:00:34 2009 +0000
+
+    Fix libva-x11 pkgconfig dependencies.
+
+diff --git a/libva-x11.pc.in b/libva-x11.pc.in
+index 75e4f0b..6dde07f 100644
+--- a/libva-x11.pc.in
++++ b/libva-x11.pc.in
+@@ -6,6 +6,7 @@ display=x11
+ 
+ Name: libva-${display}
+ Description: Userspace Video Acceleration (VA) ${display} interface
++Requires: libva
+ Version: @PACKAGE_VERSION@
+ Libs: -L${libdir} -lva-${display}
+ Cflags: -I${includedir}
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/105_dont_search_LIBGL_DRIVERS_PATH.patch b/meta-emenlow/packages/libva/libva-0.31.0/105_dont_search_LIBGL_DRIVERS_PATH.patch
new file mode 100644
index 0000000000..de873d6014
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/105_dont_search_LIBGL_DRIVERS_PATH.patch
@@ -0,0 +1,21 @@
+commit 035374378644216fb3a7d3974a8c46b1bd425918
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 22 13:03:23 2009 +0000
+
+    Don't search LIBGL_DRIVERS_PATH, stick to LIBVA_DRIVERS_PATH only or the default path.
+
+diff --git a/src/va.c b/src/va.c
+index 12662cd..723235e 100644
+--- a/src/va.c
++++ b/src/va.c
+@@ -134,10 +134,6 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
+     {
+         /* don't allow setuid apps to use LIBVA_DRIVERS_PATH */
+         search_path = getenv("LIBVA_DRIVERS_PATH");
+-        if (!search_path)
+-        {
+-            search_path = getenv("LIBGL_DRIVERS_PATH");
+-        }
+     }
+     if (!search_path)
+     {
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/108_drivers_path.patch b/meta-emenlow/packages/libva/libva-0.31.0/108_drivers_path.patch
new file mode 100644
index 0000000000..073c987054
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/108_drivers_path.patch
@@ -0,0 +1,25 @@
+From 332bfec6020b5cfcef5d655f4bf525dab67c0b92 Mon Sep 17 00:00:00 2001
+From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date: Wed, 24 Jun 2009 08:12:13 +0000
+Subject: [PATCH] Install drivers into pkglibdir/va/.
+
+---
+ configure.ac |    2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+diff --git a/configure.ac b/configure.ac
+index 4be2b56..d595ac9 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -73,7 +73,7 @@ AC_ARG_ENABLE(i965-driver,
+ 
+ AC_ARG_WITH(drivers-path,
+ 	    [AC_HELP_STRING([--with-drivers-path=[[path]]], [drivers path])],,
+-	    [with_drivers_path="$libdir/dri"])
++	    [with_drivers_path="$libdir/va/drivers"])
+ 
+ LIBVA_DRIVERS_PATH="$with_drivers_path"
+ AC_SUBST(LIBVA_DRIVERS_PATH)
+-- 
+1.5.4.3
+
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/203_fix_fglrx_detection.patch b/meta-emenlow/packages/libva/libva-0.31.0/203_fix_fglrx_detection.patch
new file mode 100644
index 0000000000..ce7f10653c
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/203_fix_fglrx_detection.patch
@@ -0,0 +1,542 @@
+commit fb6ccda5984eda96bcb394b23255143dcbc21f18
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Sep 10 12:22:17 2009 +0000
+
+    Don't link against libdrm to workaround XvBA / fglrx >= 8.66-RC1 bugs.
+
+commit ab3c0f65182462b54729d2d82d4d645c8be5b2d1
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Wed Sep 9 13:24:46 2009 +0000
+
+    Fix DRM device opening with fglrx >= 8.66-RC1.
+
+diff --git a/src/x11/Makefile.am b/src/x11/Makefile.am
+index c70380d..b6916f2 100644
+--- a/src/x11/Makefile.am
++++ b/src/x11/Makefile.am
+@@ -25,6 +25,6 @@ noinst_LTLIBRARIES = libva_x11.la
+ libva_x11includedir = ${includedir}/va
+ libva_x11include_HEADERS = va_x11.h va_dri.h va_dri2.h va_dricommon.h
+ 
+-libva_x11_la_SOURCES = va_x11.c va_dri.c va_dri2.c va_dricommon.c dri2_util.c dri1_util.c va_nvctrl.c
++libva_x11_la_SOURCES = va_x11.c va_dri.c va_dri2.c va_dricommon.c dri2_util.c dri1_util.c va_nvctrl.c libdrm_glue.c
+ 
+-EXTRA_DIST = va_dristr.h va_dri2str.h va_dri2tokens.h va_nvctrl.h
++EXTRA_DIST = va_dristr.h va_dri2str.h va_dri2tokens.h va_nvctrl.h libdrm_glue.h
+diff --git a/src/x11/dri1_util.c b/src/x11/dri1_util.c
+index b3db5b4..3bd490f 100644
+--- a/src/x11/dri1_util.c
++++ b/src/x11/dri1_util.c
+@@ -1,10 +1,12 @@
++#include "config.h"
++#include <stdio.h>
+ #include <stdlib.h>
+ #include <fcntl.h>
+ #include <unistd.h>
+ #include <sys/mman.h>
+ #include <assert.h>
+ 
+-#include <xf86drm.h>
++#include "libdrm_glue.h"
+ 
+ #include "X11/Xlib.h"
+ #include "va.h"
+@@ -21,6 +23,75 @@ struct dri1_drawable
+     int height;
+ };
+ 
++static int
++firegl_drmOpenMinor(int minor)
++{
++    char buf[64];
++    int fd;
++
++    sprintf(buf, "/dev/ati/card%d", minor);
++    if ((fd = open(buf, O_RDWR, 0)) >= 0)
++        return fd;
++    return -1;
++}
++
++static int
++firegl_drmOpenByBusID(const char *busid)
++{
++    int i, fd;
++    drmSetVersion sv;
++    const char *buf;
++
++    for (i = 0; i < DRM_MAX_MINOR; i++) {
++        if ((fd = firegl_drmOpenMinor(i)) < 0)
++            continue;
++        sv.drm_di_major = 1;
++        sv.drm_di_minor = 1;
++        sv.drm_dd_major = -1;
++        sv.drm_dd_minor = -1;
++        libdrm_drmSetInterfaceVersion(fd, &sv);
++        buf = libdrm_drmGetBusid(fd);
++        if (buf && strcasecmp(buf, busid) == 0) { /* XXX: drmMatchBusID() */
++            libdrm_drmFreeBusid(buf);
++            return fd;
++        }
++        if (buf)
++            libdrm_drmFreeBusid(buf);
++        close(fd);
++    }
++    return -1;
++}
++
++static int
++drm_open_once(struct dri_state *dri_state, const char *BusID, int *newlyopened)
++{
++    dri_state->driConnectedFlag = VA_NONE;
++    dri_state->fd = libdrm_drmOpenOnce(NULL, BusID, newlyopened);
++    if (dri_state->fd < 0) {
++        dri_state->fd = firegl_drmOpenByBusID(BusID);
++        if (dri_state->fd >= 0) {
++            *newlyopened = 1;
++            dri_state->driConnectedFlag |= VA_DRI_AMD;
++        }
++    }
++    return dri_state->fd;
++}
++
++static void
++drm_close_once(struct dri_state *dri_state)
++{
++    /* XXX: dri_state->close() doesn't seem to be called, thus this
++       function is never called either */
++    if (dri_state->fd < 0)
++        return;
++    if (dri_state->driConnectedFlag & VA_DRI_AMD)
++        close(dri_state->fd);
++    else
++        libdrm_drmCloseOnce(dri_state->fd);
++    dri_state->fd = -1;
++    dri_state->driConnectedFlag = VA_NONE;
++}
++
+ static struct dri_drawable * 
+ dri1CreateDrawable(VADriverContextP ctx, XID x_drawable)
+ {
+@@ -64,9 +135,9 @@ dri1Close(VADriverContextP ctx)
+     free_drawable_hashtable(ctx);
+     VA_DRIDestroyContext(ctx->x11_dpy, ctx->x11_screen, dri_state->hwContextID);
+     assert(dri_state->pSAREA != MAP_FAILED);
+-    drmUnmap(dri_state->pSAREA, SAREA_MAX);
++    libdrm_drmUnmap(dri_state->pSAREA, SAREA_MAX);
+     assert(dri_state->fd >= 0);
+-    drmCloseOnce(dri_state->fd);
++    drm_close_once(dri_state);
+     VA_DRICloseConnection(ctx->x11_dpy, ctx->x11_screen);
+ }
+ 
+@@ -104,21 +175,20 @@ isDRI1Connected(VADriverContextP ctx, char **driver_name)
+                               &dri_state->hSAREA, &BusID))
+         goto err_out0;
+ 
+-    
+-    dri_state->fd = drmOpenOnce(NULL, BusID, &newlyopened);
++    drm_open_once(dri_state, BusID, &newlyopened);
+     XFree(BusID);
+ 
+     if (dri_state->fd < 0)
+         goto err_out1;
+ 
+ 
+-    if (drmGetMagic(dri_state->fd, &magic))
++    if (libdrm_drmGetMagic(dri_state->fd, &magic))
+         goto err_out1;
+ 
+     if (newlyopened && !VA_DRIAuthConnection(ctx->x11_dpy, ctx->x11_screen, magic))
+         goto err_out1;
+ 
+-    if (drmMap(dri_state->fd, dri_state->hSAREA, SAREA_MAX, &dri_state->pSAREA))
++    if (libdrm_drmMap(dri_state->fd, dri_state->hSAREA, SAREA_MAX, &dri_state->pSAREA))
+         goto err_out1;
+ 
+     if (!VA_DRICreateContext(ctx->x11_dpy, ctx->x11_screen,
+@@ -127,7 +196,8 @@ isDRI1Connected(VADriverContextP ctx, char **driver_name)
+                              &dri_state->hwContextID, &dri_state->hwContext))
+         goto err_out1;
+ 
+-    dri_state->driConnectedFlag = VA_DRI1;
++    dri_state->driConnectedFlag &= VA_DRI_AMD; /* clear flags but AMD bit */
++    dri_state->driConnectedFlag |= VA_DRI1;
+     dri_state->createDrawable = dri1CreateDrawable;
+     dri_state->destroyDrawable = dri1DestroyDrawable;
+     dri_state->swapBuffer = dri1SwapBuffer;
+@@ -138,10 +208,10 @@ isDRI1Connected(VADriverContextP ctx, char **driver_name)
+ 
+ err_out1:
+     if (dri_state->pSAREA != MAP_FAILED)
+-        drmUnmap(dri_state->pSAREA, SAREA_MAX);
++        libdrm_drmUnmap(dri_state->pSAREA, SAREA_MAX);
+ 
+     if (dri_state->fd >= 0)
+-        drmCloseOnce(dri_state->fd);
++        drm_close_once(dri_state);
+ 
+     VA_DRICloseConnection(ctx->x11_dpy, ctx->x11_screen);
+ 
+diff --git a/src/x11/dri2_util.c b/src/x11/dri2_util.c
+index ebe7a2c..b727e97 100644
+--- a/src/x11/dri2_util.c
++++ b/src/x11/dri2_util.c
+@@ -3,7 +3,7 @@
+ #include <unistd.h>
+ #include <assert.h>
+ 
+-#include <xf86drm.h>
++#include "libdrm_glue.h"
+ 
+ #include <X11/Xlibint.h>
+ #include <X11/Xlib.h>
+@@ -166,7 +166,7 @@ isDRI2Connected(VADriverContextP ctx, char **driver_name)
+     if (dri_state->fd < 0)
+         goto err_out;
+ 
+-    if (drmGetMagic(dri_state->fd, &magic))
++    if (libdrm_drmGetMagic(dri_state->fd, &magic))
+         goto err_out;
+ 
+     if (!VA_DRI2Authenticate(ctx->x11_dpy, RootWindow(ctx->x11_dpy, ctx->x11_screen),
+diff --git a/src/x11/libdrm_glue.c b/src/x11/libdrm_glue.c
+new file mode 100644
+index 0000000..b72a2d1
+--- /dev/null
++++ b/src/x11/libdrm_glue.c
+@@ -0,0 +1,208 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
++ */
++
++#define _GNU_SOURCE 1
++#include "libdrm_glue.h"
++#include <stdio.h>
++#include <string.h>
++#include <dlfcn.h>
++#include <assert.h>
++
++#define LOAD_FUNC_(NAME, RET, ARGS, FALLBACK)   \
++    static RET (*lib_##NAME) ARGS;              \
++    if (lib_##NAME == NULL) {                   \
++        lib_##NAME = libdrm_symbol(#NAME);      \
++        if (!lib_##NAME)                        \
++            lib_##NAME = FALLBACK;              \
++    }                                           \
++    assert(lib_##NAME != NULL)
++
++#define LOAD_FUNC(NAME, RET, ARGS)              \
++    LOAD_FUNC_(NAME, RET, ARGS, NULL)
++
++static void *libdrm_handle;
++static int libdrm_handle_ok = -1;
++
++static inline void *libdrm_symbol(const char *name)
++{
++    if (!libdrm_open())
++        return NULL;
++    return dlsym(libdrm_handle, name);
++}
++
++int libdrm_open(void)
++{
++    if (libdrm_handle_ok < 0) {
++        libdrm_handle = dlopen("libdrm.so.2", RTLD_LOCAL|RTLD_LAZY);
++        libdrm_handle_ok = libdrm_handle != NULL;
++    }
++    assert(libdrm_handle);
++    return libdrm_handle_ok;
++}
++
++void libdrm_close(void)
++{
++    if (libdrm_handle)
++        dlclose(libdrm_handle);
++}
++
++// Default drmOpenOnce() and drmCloseOnce() implementations based on current GIT
++#define DRM_MAX_FDS 16
++static struct {
++    char *BusID;
++    int fd;
++    int refcount;
++} connection[DRM_MAX_FDS];
++
++static int nr_fds = 0;
++
++// Default implementation for drmOpenOnce() if none exists in the library
++static int
++libdrm_default_drmOpenOnce(void *unused, const char *BusID, int *newlyopened)
++{
++    int i;
++    int fd;
++
++    for (i = 0; i < nr_fds; i++)
++        if (strcmp(BusID, connection[i].BusID) == 0) {
++            connection[i].refcount++;
++            *newlyopened = 0;
++            return connection[i].fd;
++        }
++
++    fd = libdrm_drmOpen(unused, BusID);
++    if (fd <= 0 || nr_fds == DRM_MAX_FDS)
++        return fd;
++
++    connection[nr_fds].BusID = strdup(BusID);
++    connection[nr_fds].fd = fd;
++    connection[nr_fds].refcount = 1;
++    *newlyopened = 1;
++
++    if (0)
++        fprintf(stderr, "saved connection %d for %s %d\n", 
++                nr_fds, connection[nr_fds].BusID, 
++                strcmp(BusID, connection[nr_fds].BusID));
++    nr_fds++;
++    return fd;
++}
++
++// Default implementation for drmCloseOnce() if none exists in the library
++static void libdrm_default_drmCloseOnce(int fd)
++{
++    int i;
++
++    for (i = 0; i < nr_fds; i++) {
++        if (fd == connection[i].fd) {
++            if (--connection[i].refcount == 0) {
++                libdrm_drmClose(connection[i].fd);
++                free(connection[i].BusID);
++                if (i < --nr_fds) 
++                    connection[i] = connection[nr_fds];
++                return;
++            }
++        }
++    }
++}
++
++// Determine whether the DRM kernel driver has been loaded
++int libdrm_drmAvailable(void)
++{
++    LOAD_FUNC(drmAvailable, int, (void));
++    return lib_drmAvailable();
++}
++
++// Open the DRM device
++int libdrm_drmOpen(const char *name, const char *busid)
++{
++    LOAD_FUNC(drmOpen, int, (const char *, const char *));
++    return lib_drmOpen(name, busid);
++}
++
++// Close the device
++int libdrm_drmClose(int fd)
++{
++    LOAD_FUNC(drmClose, int, (int));
++    return lib_drmClose(fd);
++}
++
++// Open the DRM device (re-use an existing connection)
++int libdrm_drmOpenOnce(void *unused, const char *BusID, int *newlyopened)
++{
++    LOAD_FUNC_(drmOpenOnce, int, (void *, const char *, int *),
++               libdrm_default_drmOpenOnce);
++    return lib_drmOpenOnce(unused, BusID, newlyopened);
++}
++
++// Close the device (unref an existing connection prior to actually closing it)
++void libdrm_drmCloseOnce(int fd)
++{
++    LOAD_FUNC_(drmCloseOnce, void, (int), libdrm_default_drmCloseOnce);
++    lib_drmCloseOnce(fd);
++}
++
++// DRM connection cookie
++int libdrm_drmGetMagic(int fd, drm_magic_t * magic)
++{
++    LOAD_FUNC(drmGetMagic, int, (int, drm_magic_t *));
++    return lib_drmGetMagic(fd, magic);
++}
++
++// Issue a set-version ioctl
++int libdrm_drmSetInterfaceVersion(int fd, drmSetVersion *version)
++{
++    LOAD_FUNC(drmSetInterfaceVersion, int, (int, drmSetVersion *));
++    return lib_drmSetInterfaceVersion(fd, version);
++}
++
++// Get the bus ID of the device
++char *libdrm_drmGetBusid(int fd)
++{
++    LOAD_FUNC(drmGetBusid, char *, (int));
++    return lib_drmGetBusid(fd);
++}
++
++// Free the bus ID information
++void libdrm_drmFreeBusid(const char *busid)
++{
++    LOAD_FUNC(drmFreeBusid, void, (const char *));
++    lib_drmFreeBusid(busid);
++}
++
++// Map a region of memory
++int libdrm_drmMap(int fd,
++                  drm_handle_t handle,
++                  drmSize size,
++                  drmAddressPtr address)
++{
++    LOAD_FUNC(drmMap, int, (int, drm_handle_t, drmSize, drmAddressPtr));
++    return lib_drmMap(fd, handle, size, address);
++}
++
++// Unmap mappings obtained with drmMap()
++int libdrm_drmUnmap(drmAddress address, drmSize size)
++{
++    LOAD_FUNC(drmUnmap, int, (drmAddress, drmSize));
++    return lib_drmUnmap(address, size);
++}
+diff --git a/src/x11/libdrm_glue.h b/src/x11/libdrm_glue.h
+new file mode 100644
+index 0000000..878470b
+--- /dev/null
++++ b/src/x11/libdrm_glue.h
+@@ -0,0 +1,73 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef LIBDRM_GLUE_H
++#define LIBDRM_GLUE_H
++
++#include "config.h"
++#include <xf86drm.h>
++
++int libdrm_open(void)
++    ATTRIBUTE_HIDDEN;
++
++void libdrm_close(void)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmAvailable(void)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmOpen(const char *name, const char *busid)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmClose(int fd)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmOpenOnce(void *unused, const char *BusID, int *newlyopened)
++    ATTRIBUTE_HIDDEN;
++
++void libdrm_drmCloseOnce(int fd)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmGetMagic(int fd, drm_magic_t * magic)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmSetInterfaceVersion(int fd, drmSetVersion *version)
++    ATTRIBUTE_HIDDEN;
++
++char *libdrm_drmGetBusid(int fd)
++    ATTRIBUTE_HIDDEN;
++
++void libdrm_drmFreeBusid(const char *busid)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmMap(int fd,
++                  drm_handle_t handle,
++                  drmSize size,
++                  drmAddressPtr address)
++    ATTRIBUTE_HIDDEN;
++
++int libdrm_drmUnmap(drmAddress address, drmSize size)
++    ATTRIBUTE_HIDDEN;
++
++#endif /* LIBDRM_GLUE_H */
+diff --git a/src/x11/va_dricommon.h b/src/x11/va_dricommon.h
+index a2a51a6..0da35fe 100644
+--- a/src/x11/va_dricommon.h
++++ b/src/x11/va_dricommon.h
+@@ -13,7 +13,8 @@ enum
+ {
+     VA_NONE = 0,
+     VA_DRI1 = 1,
+-    VA_DRI2 = 2
++    VA_DRI2 = 2,
++    VA_DRI_AMD = 4 /* AMD DRI implementation */
+ };
+ 
+ union dri_buffer 
+diff --git a/src/x11/va_x11.c b/src/x11/va_x11.c
+index b8c60fa..414c261 100644
+--- a/src/x11/va_x11.c
++++ b/src/x11/va_x11.c
+@@ -31,6 +31,7 @@
+ #include "va_dri2.h"
+ #include "va_dricommon.h"
+ #include "va_nvctrl.h"
++#include "libdrm_glue.h"
+ #include <stdio.h>
+ #include <stdarg.h>
+ #include <string.h>
+@@ -94,6 +75,8 @@ static void va_DisplayContextDestroy (
+ 	}
+ 	ctx = &((*ctx)->pNext);
+     }
++
++    libdrm_close();
+     free(pDisplayContext->pDriverContext->dri_state);
+     free(pDisplayContext->pDriverContext);
+     free(pDisplayContext);
+diff --git a/src/Makefile.am b/src/Makefile.am
+index e50a15f..d1f8f70 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -45,7 +45,7 @@ libva_la_LDFLAGS = $(LDADD) -no-undefined
+ libva_la_LIBADD = $(LIBVA_LIBS) -ldl
+ 
+ libva_x11_la_SOURCES = 
+-libva_x11_la_LIBADD  = $(libvacorelib) x11/libva_x11.la $(LIBVA_LIBS) $(X11_LIBS) $(XEXT_LIBS) $(DRM_LIBS) $(XFIXES_LIBS)
++libva_x11_la_LIBADD  = $(libvacorelib) x11/libva_x11.la $(LIBVA_LIBS) $(X11_LIBS) $(XEXT_LIBS) $(XFIXES_LIBS) -ldl
+ libva_x11_la_LDFLAGS = $(LDADD)
+ libva_x11_la_DEPENDENCIES = $(libvacorelib) x11/libva_x11.la
+ 
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/204_check_ATIFGLEXTENSION.patch b/meta-emenlow/packages/libva/libva-0.31.0/204_check_ATIFGLEXTENSION.patch
new file mode 100644
index 0000000000..02920a8944
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/204_check_ATIFGLEXTENSION.patch
@@ -0,0 +1,312 @@
+commit d91645f8b37aa43bafa76da3146dcdc9c17963ff
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Fri Nov 20 15:51:22 2009 +0000
+
+    Fix detection of fglrx.
+
+diff --git a/src/x11/Makefile.am b/src/x11/Makefile.am
+index b6916f2..0b61c33 100644
+--- a/src/x11/Makefile.am
++++ b/src/x11/Makefile.am
+@@ -25,6 +25,23 @@ noinst_LTLIBRARIES = libva_x11.la
+ libva_x11includedir = ${includedir}/va
+ libva_x11include_HEADERS = va_x11.h va_dri.h va_dri2.h va_dricommon.h
+ 
+-libva_x11_la_SOURCES = va_x11.c va_dri.c va_dri2.c va_dricommon.c dri2_util.c dri1_util.c va_nvctrl.c libdrm_glue.c
++libva_x11_la_SOURCES =	\
++	dri1_util.c	\
++	dri2_util.c	\
++	libdrm_glue.c	\
++	va_dri.c	\
++	va_dri2.c	\
++	va_dricommon.c	\
++	va_fglext.c	\
++	va_nvctrl.c	\
++	va_x11.c	\
++	$(NULL)
+ 
+-EXTRA_DIST = va_dristr.h va_dri2str.h va_dri2tokens.h va_nvctrl.h libdrm_glue.h
++EXTRA_DIST =		\
++	libdrm_glue.h	\
++	va_dri2str.h	\
++	va_dri2tokens.h	\
++	va_dristr.h	\
++	va_fglext.h	\
++	va_nvctrl.h	\
++	$(NULL)
+diff --git a/src/x11/va_fglext.c b/src/x11/va_fglext.c
+new file mode 100644
+index 0000000..bc58e8b
+--- /dev/null
++++ b/src/x11/va_fglext.c
+@@ -0,0 +1,175 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
++ */
++
++#define _GNU_SOURCE 1
++#include <string.h>
++
++#define NEED_REPLIES
++#include <stdlib.h>
++#include <X11/Xlibint.h>
++#include <X11/Xutil.h>
++#include <X11/extensions/Xext.h>
++#include <X11/extensions/extutil.h>
++#include "va_fglext.h"
++
++#define ATIFGL_EXTENSION_NAME "ATIFGLEXTENSION"
++#define ATIFGL_EXTENSION_EVENTS 0
++
++typedef struct _FGLGetDriverData {
++    CARD8   reqType;
++    CARD8   fireglReqType;
++    CARD16  length B16;
++    CARD32  screen B32;
++    CARD16  size B16;
++    CARD16  pad1;
++} xFGLGetDriverDataReq;
++#define sz_xFGLGetDriverDataReq sizeof(xFGLGetDriverDataReq)
++
++typedef struct {
++    BYTE    type;
++    BYTE    pad1;
++    CARD16  sequenceNumber B16;
++    CARD32  length B32;
++    CARD8   majorVersion;
++    CARD8   minorVersion;
++    CARD8   patchlevel B16;
++    CARD8   BIOSVersionMajor;
++    CARD8   BIOSVersionMinor;
++    CARD8   HasSecondary;
++    CARD16  pad3 B16;
++    CARD32  pad4 B32;
++    CARD32  pad5 B32;
++    CARD32  pad6 B32;
++    CARD32  pad7 B32;
++    // ... there are more fields
++} xFGLGetDriverDataReply;
++#define sz_xFGLGetDriverDataReply sizeof(xFGLGetDriverDataReply)
++
++#define X_FGLGetDriverData 0
++
++static XExtensionInfo _fglext_ext_info_data;
++static XExtensionInfo *fglext_ext_info = &_fglext_ext_info_data;
++static /* const */ char *fglext_extension_name = ATIFGL_EXTENSION_NAME;
++
++#define xFGLCheckExtension(dpy,i,val) \
++  XextCheckExtension (dpy, i, fglext_extension_name, val)
++
++static int close_display();
++static /* const */ XExtensionHooks fglext_extension_hooks = {
++    NULL,                               /* create_gc */
++    NULL,                               /* copy_gc */
++    NULL,                               /* flush_gc */
++    NULL,                               /* free_gc */
++    NULL,                               /* create_font */
++    NULL,                               /* free_font */
++    close_display,                      /* close_display */
++    NULL,                               /* wire_to_event */
++    NULL,                               /* event_to_wire */
++    NULL,                               /* error */
++    NULL,                               /* error_string */
++};
++
++static XEXT_GENERATE_FIND_DISPLAY (find_display, fglext_ext_info,
++                                   fglext_extension_name, 
++                                   &fglext_extension_hooks,
++                                   ATIFGL_EXTENSION_EVENTS, NULL)
++
++static XEXT_GENERATE_CLOSE_DISPLAY (close_display, fglext_ext_info)
++
++Bool VA_FGLEXTQueryDirectRenderingCapable( Display *dpy, int screen,
++    Bool *isCapable )
++{
++    char **extensions;
++    int i, n_extensions, has_fglext = 0, has_fglrxdri = 0;
++
++    if (isCapable)
++        *isCapable = False;
++
++    extensions = XListExtensions(dpy, &n_extensions);
++    if (!extensions)
++        return False;
++
++    for (i = 0; i < n_extensions; i++) {
++        if (strcmp(extensions[i], ATIFGL_EXTENSION_NAME) == 0)
++            has_fglext = 1;
++        if (strcmp(extensions[i], "ATIFGLRXDRI") == 0)
++            has_fglrxdri = 1;
++    }
++    XFreeExtensionList(extensions);
++
++    if (!has_fglext)
++        return False;
++
++    if (isCapable)
++        *isCapable = has_fglrxdri;
++
++    return True;
++}
++
++Bool VA_FGLEXTGetClientDriverName( Display *dpy, int screen,
++    int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
++    int *ddxDriverPatchVersion, char **clientDriverName )
++{
++    XExtDisplayInfo *info = find_display (dpy);
++    xFGLGetDriverDataReply rep;
++    xFGLGetDriverDataReq  *req;
++
++    if (ddxDriverMajorVersion)
++        *ddxDriverMajorVersion = 0;
++    if (ddxDriverMinorVersion)
++        *ddxDriverMinorVersion = 0;
++    if (ddxDriverPatchVersion)
++        *ddxDriverPatchVersion = 0;
++    if (clientDriverName)
++        *clientDriverName = NULL;
++
++    if(!XextHasExtension(info))
++        return False;
++
++    xFGLCheckExtension (dpy, info, False);
++
++    LockDisplay (dpy);
++    GetReq (FGLGetDriverData, req);
++    req->reqType = info->codes->major_opcode;
++    req->fireglReqType = X_FGLGetDriverData;
++    req->screen = screen;
++    if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
++        UnlockDisplay (dpy);
++        SyncHandle ();
++        return False;
++    }
++    UnlockDisplay (dpy);
++    SyncHandle ();
++
++    if (ddxDriverMajorVersion)
++        *ddxDriverMajorVersion = rep.majorVersion;
++    if (ddxDriverMinorVersion)
++        *ddxDriverMinorVersion = rep.minorVersion;
++    if (ddxDriverPatchVersion)
++        *ddxDriverPatchVersion = rep.patchlevel;
++    if (clientDriverName)
++        *clientDriverName = strdup("fglrx");
++
++    return True;
++}
+diff --git a/src/x11/va_fglext.h b/src/x11/va_fglext.h
+new file mode 100644
+index 0000000..f2d87c3
+--- /dev/null
++++ b/src/x11/va_fglext.h
+@@ -0,0 +1,37 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef VA_FGLEXTLIB_H
++#define VA_FGLEXTLIB_H
++
++#include <X11/Xlib.h>
++
++Bool VA_FGLEXTQueryDirectRenderingCapable( Display *dpy, int screen,
++    Bool *isCapable );
++
++Bool VA_FGLEXTGetClientDriverName( Display *dpy, int screen,
++    int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
++    int *ddxDriverPatchVersion, char **clientDriverName );
++
++#endif /* VA_FGLEXTLIB_H */
+diff --git a/src/x11/va_x11.c b/src/x11/va_x11.c
+index 414c261..0510e00 100644
+--- a/src/x11/va_x11.c
++++ b/src/x11/va_x11.c
+@@ -31,6 +31,7 @@
+ #include "va_dri2.h"
+ #include "va_dricommon.h"
+ #include "va_nvctrl.h"
++#include "va_fglext.h"
+ #include "libdrm_glue.h"
+ #include <stdio.h>
+ #include <stdarg.h>
+@@ -132,6 +133,29 @@ static VAStatus va_NVCTRL_GetDriverName (
+     return VA_STATUS_SUCCESS;
+ }
+ 
++static VAStatus va_FGLEXT_GetDriverName(
++    VADisplayContextP pDisplayContext,
++    char **driver_name
++)
++{
++    VADriverContextP ctx = pDisplayContext->pDriverContext;
++    int direct_capable, driver_major, driver_minor, driver_patch;
++    Bool result;
++
++    result = VA_FGLEXTQueryDirectRenderingCapable(ctx->x11_dpy, ctx->x11_screen,
++                                                  &direct_capable);
++    if (!result || !direct_capable)
++        return VA_STATUS_ERROR_UNKNOWN;
++
++    result = VA_FGLEXTGetClientDriverName(ctx->x11_dpy, ctx->x11_screen,
++                                          &driver_major, &driver_minor,
++                                          &driver_patch, driver_name);
++    if (!result)
++        return VA_STATUS_ERROR_UNKNOWN;
++
++    return VA_STATUS_SUCCESS;
++}
++
+ static VAStatus va_DisplayContextGetDriverName (
+     VADisplayContextP pDisplayContext,
+     char **driver_name
+@@ -156,7 +180,8 @@ static VAStatus va_DisplayContextGetDriverName (
+         vaStatus = va_DRIGetDriverName(pDisplayContext, driver_name);
+     if (vaStatus != VA_STATUS_SUCCESS)
+         vaStatus = va_NVCTRL_GetDriverName(pDisplayContext, driver_name);
+-   
++    if (vaStatus != VA_STATUS_SUCCESS)
++        vaStatus = va_FGLEXT_GetDriverName(pDisplayContext, driver_name);
+     return vaStatus;
+ }
+ 
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/300_sds_version.patch b/meta-emenlow/packages/libva/libva-0.31.0/300_sds_version.patch
new file mode 100644
index 0000000000..07531c90cb
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/300_sds_version.patch
@@ -0,0 +1,87 @@
+commit 890acc1975ed9f6b7173ff6fbf9d689943590913
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Wed Jun 24 11:32:40 2009 +0000
+
+    Explicit API extensions from SDS.
+
+diff --git a/configure.ac b/configure.ac
+index 3999dc4..17b0403 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -28,6 +28,9 @@ m4_define([libva_micro_version], [0])
+ m4_define([libva_version],
+           [libva_major_version.libva_minor_version.libva_micro_version])
+ 
++# increase this number for each API change
++m4_define([libva_sds_version], [4])
++
+ # if the library source code has changed, increment revision
+ m4_define([libva_lt_revision], [0])
+ # if any interface was added/removed/changed, then inc current, reset revision
+@@ -52,11 +55,14 @@ AC_SUBST(LIBVA_MINOR_VERSION)
+ AC_SUBST(LIBVA_MICRO_VERSION)
+ AC_SUBST(LIBVA_VERSION)
+ 
++LIBVA_SDS_VERSION=libva_sds_version
++AC_SUBST(LIBVA_SDS_VERSION)
++
+ LIBVA_LT_CURRENT=libva_lt_current
+ LIBVA_LT_REV=libva_lt_revision
+ LIBVA_LT_AGE=libva_lt_age
+ LIBVA_LT_VERSION="$LIBVA_LT_CURRENT:$LIBVA_LT_REV:$LIBVA_LT_AGE"
+-LIBVA_LT_LDFLAGS="-version-info $LIBVA_LT_VERSION"
++LIBVA_LT_LDFLAGS="-version-info $LIBVA_LT_VERSION -release $LIBVA_VERSION.$LIBVA_SDS_VERSION"
+ AC_SUBST(LIBVA_LT_VERSION)
+ AC_SUBST(LIBVA_LT_LDFLAGS)
+ 
+diff --git a/src/va.c b/src/va.c
+index f9791f8..b60ac12 100644
+--- a/src/va.c
++++ b/src/va.c
+@@ -35,6 +35,7 @@
+ #include <linux/videodev2.h>
+ 
+ #define DRIVER_INIT_FUNC	"__vaDriverInit_0_31"
++#define DRIVER_INIT_FUNC_SDS	"__vaDriverInit_0_31_sds"
+ 
+ #define DRIVER_EXTENSION	"_drv_video.so"
+ 
+@@ -160,6 +161,11 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
+             init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC);
+             if (!init_func)
+             {
++                /* Then try SDS extensions (VDPAU and XvBA backends) */
++                init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_SDS);
++            }
++            if (!init_func)
++            {
+                 va_errorMessage("%s has no function %s\n", driver_path, DRIVER_INIT_FUNC);
+                 dlclose(handle);
+             }
+diff --git a/src/va_version.h.in b/src/va_version.h.in
+index c9ea97a..197c482 100644
+--- a/src/va_version.h.in
++++ b/src/va_version.h.in
+@@ -47,6 +47,13 @@
+ #define VA_MICRO_VERSION   (@LIBVA_MICRO_VERSION@)
+ 
+ /**
++ * VA_SDS_VERSION:
++ *
++ * The version of the SDS API extensions to the VA library
++ */
++#define VA_SDS_VERSION     (@LIBVA_SDS_VERSION@)
++
++/**
+  * VA_VERSION:
+  *
+  * The full version of the VA library, like 1.2.3
+@@ -59,7 +66,7 @@
+  * The full version of the VA library, in string form (suited for
+  * string concatenation)
+  */
+-#define VA_VERSION_S       "@LIBVA_VERSION@"
++#define VA_VERSION_S       "@LIBVA_VERSION@-sds@LIBVA_SDS_VERSION@"
+ 
+ /**
+  * VA_VERSION_HEX:
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/301_vdpau_mpeg4.patch b/meta-emenlow/packages/libva/libva-0.31.0/301_vdpau_mpeg4.patch
new file mode 100644
index 0000000000..86188902ab
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/301_vdpau_mpeg4.patch
@@ -0,0 +1,26 @@
+commit 3c2d45290e1369083a27d53a5f94276c82512974
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Mon Nov 23 12:21:24 2009 +0000
+
+    Add extra picture info fields for VDPAU/MPEG-4.
+
+diff --git a/src/va.h b/src/va.h
+index fa34850..f89a5cb 100755
+--- a/src/va.h
++++ b/src/va.h
+@@ -672,6 +672,7 @@ typedef struct _VAPictureParameterBufferMPEG4
+             unsigned int quarter_sample			: 1; 
+             unsigned int data_partitioned		: 1; 
+             unsigned int reversible_vlc			: 1; 
++            unsigned int resync_marker_disable		: 1; 
+         } bits;
+         unsigned int value;
+     } vol_fields;
+@@ -692,6 +693,7 @@ typedef struct _VAPictureParameterBufferMPEG4
+     } vop_fields;
+     unsigned char vop_fcode_forward;
+     unsigned char vop_fcode_backward;
++    unsigned short vop_time_increment_resolution;
+     /* short header related */
+     unsigned char num_gobs_in_vop;
+     unsigned char num_macroblocks_in_gob;
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/320_move_vaPutSurface_flags_def.patch b/meta-emenlow/packages/libva/libva-0.31.0/320_move_vaPutSurface_flags_def.patch
new file mode 100644
index 0000000000..f00c52ca47
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/320_move_vaPutSurface_flags_def.patch
@@ -0,0 +1,60 @@
+commit c682fb5ebd1964638f90590f66edf49629e7481d
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Fri Aug 21 11:34:50 2009 +0000
+
+    Move vaPutSurface() flags to <va/va.h> header.
+
+diff --git a/src/va.h b/src/va.h
+index 0519f6f..6b4bbd4 100755
+--- a/src/va.h
++++ b/src/va.h
+@@ -127,6 +127,22 @@ typedef int VAStatus;	/* Return status type from functions */
+ #define VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED 0x00000013
+ #define VA_STATUS_ERROR_UNKNOWN			0xFFFFFFFF
+ 
++/* De-interlacing flags for vaPutSurface() */
++#define VA_FRAME_PICTURE        0x00000000 
++#define VA_TOP_FIELD            0x00000001
++#define VA_BOTTOM_FIELD         0x00000002
++
++/*
++ * Clears the drawable with background color.
++ * for hardware overlay based implementation this flag
++ * can be used to turn off the overlay
++ */
++#define VA_CLEAR_DRAWABLE       0x00000008 
++
++/* Color space conversion flags for vaPutSurface() */
++#define VA_SRC_BT601            0x00000010
++#define VA_SRC_BT709            0x00000020
++
+ /*
+  * Returns a short english description of error_status
+  */
+diff --git a/src/x11/va_x11.h b/src/x11/va_x11.h
+index 2171ac6..5ab5200 100644
+--- a/src/x11/va_x11.h
++++ b/src/x11/va_x11.h
+@@ -27,22 +27,6 @@ VADisplay vaGetDisplay (
+  * color space conversion and scaling to the destination
+  * rectangle
+  */
+-/* de-interlacing flags for vaPutSurface */
+-#define VA_FRAME_PICTURE	0x00000000 
+-#define VA_TOP_FIELD		0x00000001
+-#define VA_BOTTOM_FIELD		0x00000002
+-
+-/* 
+- * clears the drawable with background color.
+- * for hardware overlay based implementation this flag
+- * can be used to turn off the overlay
+- */
+-#define VA_CLEAR_DRAWABLE	0x00000008 
+-
+-/* color space conversion flags for vaPutSurface */
+-#define VA_SRC_BT601		0x00000010
+-#define VA_SRC_BT709		0x00000020
+-
+ VAStatus vaPutSurface (
+     VADisplay dpy,
+     VASurfaceID surface,	
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/321_libva_glx.base.patch b/meta-emenlow/packages/libva/libva-0.31.0/321_libva_glx.base.patch
new file mode 100644
index 0000000000..43af6f40cc
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/321_libva_glx.base.patch
@@ -0,0 +1,212 @@
+commit f0b352251894becfcec50de1430bda12c314a464
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 22 13:00:34 2009 +0000
+
+    Fix libva-glx pkgconfig dependencies.
+
+commit df0953a951d8a2e5e4b0a28a95ae0f1ac735726e
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 8 12:25:14 2009 +0000
+
+    Add generic VA/GLX implementation with TFP and FBO.
+
+commit f640b1cf9eab4e5d478239b608ed0d8b68f6c5f6
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 8 12:15:35 2009 +0000
+
+    Move GLX VTable to a new file.
+
+commit 70d9cb6d1aa2fc2dde6646f3b692433e0d93d431
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Fri Aug 28 11:15:51 2009 +0000
+
+    Add OpenGL extensions (v3).
+
+diff --git a/Makefile.am b/Makefile.am
+index 07385e6..6fb4cae 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -32,10 +32,13 @@ endif
+ 
+ pcfiles = libva.pc
+ pcfiles += libva-x11.pc
++if USE_GLX
++pcfiles += libva-glx.pc
++endif
+ 
+ pkgconfigdir = @pkgconfigdir@
+ pkgconfig_DATA = $(pcfiles)
+ 
+-EXTRA_DIST = libva.pc.in libva-x11.pc.in
++EXTRA_DIST = libva.pc.in libva-x11.pc.in libva-glx.pc.in
+ 
+ CLEANFILES = $(pcfiles)
+diff --git a/configure.ac b/configure.ac
+index c3aba90..abef435 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -52,6 +55,11 @@ AC_SUBST(LIBVA_MINOR_VERSION)
+ AC_SUBST(LIBVA_LT_VERSION)
+ AC_SUBST(LIBVA_LT_LDFLAGS)
+ 
++AC_ARG_ENABLE(glx,
++              [AC_HELP_STRING([--enable-glx],
++                              [build with OpenGL for X11 support])],
++              [], [enable_glx=yes])
++
+ AC_ARG_ENABLE(dummy-driver,
+               [AC_HELP_STRING([--enable-dummy-driver],
+                               [build dummy video driver])],
+@@ -100,6 +132,23 @@ if test x$enable_i965_driver = xyes && ! $PKG_CONFIG --atleast-version=2.4 libdr
+ AC_DEFINE_UNQUOTED([ATTRIBUTE_HIDDEN], [$ATTRIBUTE_HIDDEN],
+     [Defined to __attribute__((visibility("hidden"))) when available])
+ 
++# Check for OpenGL (X11)
++USE_GLX="no"
++GL_DEPS_CFLAGS=""
++GL_DEPS_LIBS=""
++
++if test x$enable_glx = xyes; then
++    AC_CHECK_HEADERS([GL/gl.h])
++    AC_CHECK_HEADERS([GL/glx.h])
++    AC_CHECK_LIB(GL, glXCreateContext, [
++        USE_GLX="yes"
++        GL_DEPS_LIBS="-lX11 -lGL"
++    ])
++fi
++AC_SUBST(GL_DEPS_CFLAGS)
++AC_SUBST(GL_DEPS_LIBS)
++AM_CONDITIONAL(USE_GLX, test "$USE_GLX" = "yes")
++
+ # We only need the headers, we don't link against the DRM libraries
+ LIBVA_CFLAGS="$DRM_CFLAGS"
+ AC_SUBST(LIBVA_CFLAGS)
+@@ -119,6 +192,7 @@ AC_OUTPUT([
+ 	src/Makefile
+ 	src/va_version.h
+ 	src/x11/Makefile
++	src/glx/Makefile
+ 	dummy_drv_video/Makefile
+ 	i965_drv_video/Makefile
+ 	i965_drv_video/shaders/Makefile
+@@ -128,5 +202,6 @@ AC_OUTPUT([
+ 	test/Makefile
+ 	libva.pc
+ 	libva-x11.pc
++	libva-glx.pc
+ ])
+ 
+diff --git a/libva-glx.pc.in b/libva-glx.pc.in
+new file mode 100644
+index 0000000..20ba20a
+--- /dev/null
++++ b/libva-glx.pc.in
+@@ -0,0 +1,12 @@
++prefix=@prefix@
++exec_prefix=@exec_prefix@
++libdir=@libdir@
++includedir=@includedir@
++display=glx
++
++Name: libva-${display}
++Description: Userspace Video Acceleration (VA) ${display} interface
++Requires: libva
++Version: @PACKAGE_VERSION@
++Libs: -L${libdir} -lva-${display}
++Cflags: -I${includedir}
+diff --git a/src/Makefile.am b/src/Makefile.am
+index 2f4210a..e50a15f 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -28,9 +28,17 @@ INCLUDES = \
+ LDADD = \
+ 	$(LIBVA_LT_LDFLAGS)
+ 
+-lib_LTLIBRARIES = \
+-	libva.la \
+-	libva-x11.la
++libva_x11_backend	= libva-x11.la
++libva_x11_backenddir	= x11
++if USE_GLX
++libva_glx_backend	= libva-glx.la
++libva_glx_backenddir	= glx
++else
++libva_glx_backend	=
++libva_glx_backenddir	=
++endif
++
++lib_LTLIBRARIES = libva.la $(libva_x11_backend) $(libva_glx_backend)
+ 
+ libva_ladir = $(libdir)
+ libva_la_LDFLAGS = $(LDADD) -no-undefined
+@@ -41,7 +49,14 @@ libva_x11_la_LIBADD  = $(libvacorelib) x11/libva_x11.la $(LIBVA_LIBS) $(X11_LIBS
+ libva_x11_la_LDFLAGS = $(LDADD)
+ libva_x11_la_DEPENDENCIES = $(libvacorelib) x11/libva_x11.la
+ 
+-SUBDIRS = x11
++libva_glx_la_SOURCES = 
++libva_glx_la_LIBADD  = $(libvacorelib) glx/libva_glx.la libva-x11.la $(GL_DEPS_LIBS) -ldl
++libva_glx_la_LDFLAGS = $(LDADD)
++libva_glx_la_DEPENDENCIES = $(libvacorelib) glx/libva_glx.la libva-x11.la
++
++SUBDIRS = $(libva_x11_backenddir) $(libva_glx_backenddir)
++
++DIST_SUBDIRS = x11 glx
+ 
+ libva_la_SOURCES = va.c
+ 
+diff --git a/src/va_backend.h b/src/va_backend.h
+index 6f858f5..8f722a3 100644
+--- a/src/va_backend.h
++++ b/src/va_backend.h
+@@ -32,9 +32,11 @@
+ #ifdef IN_LIBVA
+ #include "va.h"
+ #include "x11/va_x11.h"
++#include "glx/va_backend_glx.h"
+ #else
+ #include <va/va.h>
+ #include <va/va_x11.h>
++#include <va/va_backend_glx.h>
+ #endif
+ 
+ #include <stdlib.h>
+@@ -372,6 +374,9 @@ struct VADriverVTable
+                 unsigned int *chroma_v_offset,
+                 void **buffer
+         );
++
++        /* Optional: GLX support hooks */
++        struct VADriverVTableGLX glx;
+ };
+ 
+ struct VADriverContext
+@@ -394,6 +399,7 @@ struct VADriverContext
+     void *handle;			/* dlopen handle */
+     
+     void *dri_state;
++    void *glx;                          /* opaque for GLX code */
+ };
+ 
+ struct VADisplayContext
+@@ -413,6 +420,8 @@ struct VADisplayContext
+ 	VADisplayContextP ctx,
+ 	char **driver_name
+     );
++
++    void *opaque;                       /* opaque for display extensions (e.g. GLX) */
+ };
+ 
+ typedef VAStatus (*VADriverInit) (
+diff --git a/src/x11/va_x11.c b/src/x11/va_x11.c
+index 9de904e..b8c60fa 100644
+--- a/src/x11/va_x11.c
++++ b/src/x11/va_x11.c
+@@ -243,6 +243,7 @@ VADisplay vaGetDisplay (
+ 	  pDisplayContext->vaIsValid       = va_DisplayContextIsValid;
+ 	  pDisplayContext->vaDestroy       = va_DisplayContextDestroy;
+ 	  pDisplayContext->vaGetDriverName = va_DisplayContextGetDriverName;
++          pDisplayContext->opaque          = NULL;
+ 	  pDisplayContexts                 = pDisplayContext;
+ 	  pDriverContext->dri_state 	   = dri_state;
+ 	  dpy                              = (VADisplay)pDisplayContext;
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/322_libva_glx.patch b/meta-emenlow/packages/libva/libva-0.31.0/322_libva_glx.patch
new file mode 100644
index 0000000000..ccd9ae090e
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/322_libva_glx.patch
@@ -0,0 +1,2024 @@
+commit 8e76000abce070da5f1c902a6290f4ccaa3eccc8
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Fri Sep 18 15:51:08 2009 +0000
+
+    Add C++ guards.
+
+commit bf1ae22ef324fbb347f5369e1ba307e847553fe8
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Fri Sep 18 15:49:55 2009 +0000
+
+    Fix check for GL extensions.
+
+commit df0953a951d8a2e5e4b0a28a95ae0f1ac735726e
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 8 12:25:14 2009 +0000
+
+    Add generic VA/GLX implementation with TFP and FBO.
+
+commit f640b1cf9eab4e5d478239b608ed0d8b68f6c5f6
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Tue Sep 8 12:15:35 2009 +0000
+
+    Move GLX VTable to a new file.
+
+commit 70d9cb6d1aa2fc2dde6646f3b692433e0d93d431
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Fri Aug 28 11:15:51 2009 +0000
+
+    Add OpenGL extensions (v3).
+
+diff --git a/src/glx/Makefile.am b/src/glx/Makefile.am
+new file mode 100644
+index 0000000..7783d8c
+--- /dev/null
++++ b/src/glx/Makefile.am
+@@ -0,0 +1,41 @@
++# Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++#
++# Permission is hereby granted, free of charge, to any person obtaining a
++# copy of this software and associated documentation files (the
++# "Software"), to deal in the Software without restriction, including
++# without limitation the rights to use, copy, modify, merge, publish,
++# distribute, sub license, and/or sell copies of the Software, and to
++# permit persons to whom the Software is furnished to do so, subject to
++# the following conditions:
++# 
++# The above copyright notice and this permission notice (including the
++# next paragraph) shall be included in all copies or substantial portions
++# of the Software.
++# 
++# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++# IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
++
++AM_CFLAGS = -DLINUX -DIN_LIBVA -I$(top_srcdir)/src -I$(top_srcdir)/src/x11
++
++source_c = \
++	va_glx.c		\
++	va_glx_impl.c
++
++source_h = \
++	va_glx.h		\
++	va_backend_glx.h
++
++source_h_priv = \
++	va_glx_impl.h		\
++	va_glx_private.h
++
++noinst_LTLIBRARIES	 = libva_glx.la
++libva_glxincludedir	 = ${includedir}/va
++libva_glxinclude_HEADERS = $(source_h)
++libva_glx_la_SOURCES	 = $(source_c)
++noinst_HEADERS		 = $(source_h_priv)
+diff --git a/src/glx/va_backend_glx.h b/src/glx/va_backend_glx.h
+new file mode 100644
+index 0000000..3885d30
+--- /dev/null
++++ b/src/glx/va_backend_glx.h
+@@ -0,0 +1,87 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef VA_BACKEND_GLX_H
++#define VA_BACKEND_GLX_H
++
++struct VADriverContext;
++
++struct VADriverVTableGLX {
++    /* Optional: create a surface used for display to OpenGL */
++    VAStatus (*vaCreateSurfaceGLX)(
++        struct VADriverContext *ctx,
++        unsigned int            gl_target,
++        unsigned int            gl_texture,
++        void                  **gl_surface
++    );
++
++    /* Optional: destroy a VA/GLX surface */
++    VAStatus (*vaDestroySurfaceGLX)(
++        struct VADriverContext *ctx,
++        void                   *gl_surface
++    );
++
++    /* Optional: associate a VA surface to a VA/GLX surface */
++    VAStatus (*vaAssociateSurfaceGLX)(
++        struct VADriverContext *ctx,
++        void                   *gl_surface,
++        VASurfaceID             surface,
++        unsigned int            flags
++    );
++
++    /* Optional: deassociate a VA surface from a VA/GLX surface */
++    VAStatus (*vaDeassociateSurfaceGLX)(
++        struct VADriverContext *ctx,
++        void                   *gl_surface
++    );
++
++    /* Optional: synchronize a VA/GLX surface */
++    VAStatus (*vaSyncSurfaceGLX)(
++        struct VADriverContext *ctx,
++        void                   *gl_surface
++    );
++
++    /* Optional: prepare VA/GLX surface for rendering */
++    VAStatus (*vaBeginRenderSurfaceGLX)(
++        struct VADriverContext *ctx,
++        void                   *gl_surface
++    );
++
++    /* Optional: notify the server that the VA/GLX surface is no
++       longer used for rendering */
++    VAStatus (*vaEndRenderSurfaceGLX)(
++        struct VADriverContext *ctx,
++        void                   *gl_surface
++    );
++
++    /* Optional: copy a VA surface to a VA/GLX surface */
++    VAStatus (*vaCopySurfaceGLX)(
++        struct VADriverContext *ctx,
++        void                   *gl_surface,
++        VASurfaceID             surface,
++        unsigned int            flags
++    );
++};
++
++#endif /* VA_BACKEND_GLX_H */
+diff --git a/src/glx/va_glx.c b/src/glx/va_glx.c
+new file mode 100644
+index 0000000..f6ec2c3
+--- /dev/null
++++ b/src/glx/va_glx.c
+@@ -0,0 +1,295 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#include "va_glx_private.h"
++#include "va_glx_impl.h"
++
++#define INIT_CONTEXT(ctx, dpy) do {                             \
++        if (!vaDisplayIsValid(dpy))                             \
++            return VA_STATUS_ERROR_INVALID_DISPLAY;             \
++                                                                \
++        ctx = ((VADisplayContextP)(dpy))->pDriverContext;       \
++        if (!(ctx))                                             \
++            return VA_STATUS_ERROR_INVALID_DISPLAY;             \
++                                                                \
++        VAStatus status = va_glx_init_context(ctx);             \
++        if (status != VA_STATUS_SUCCESS)                        \
++            return status;                                      \
++    } while (0)
++
++#define INIT_SURFACE(surface, surface_arg) do {                 \
++        surface = (VASurfaceGLXP)(surface_arg);                 \
++        if (!vaSurfaceIsValid(surface))                         \
++            return VA_STATUS_ERROR_INVALID_SURFACE;             \
++    } while (0)
++
++#define INVOKE(ctx, func, args) do {                            \
++        VADriverVTableGLXP vtable;                              \
++        vtable = &VA_DRIVER_CONTEXT_GLX(ctx)->vtable;           \
++        if (!vtable->va##func##GLX)                             \
++            return VA_STATUS_ERROR_UNIMPLEMENTED;               \
++        status = vtable->va##func##GLX args;                    \
++    } while (0)
++
++// Check VADisplay is valid
++static inline int vaDisplayIsValid(VADisplay dpy)
++{
++    VADisplayContextP pDisplayContext = (VADisplayContextP)dpy;
++
++    return (pDisplayContext &&
++            pDisplayContext->vaIsValid &&
++            pDisplayContext->vaIsValid(pDisplayContext));
++}
++
++// Check VASurfaceGLX is valid
++static inline int vaSurfaceIsValid(VASurfaceGLXP pSurfaceGLX)
++{
++    return pSurfaceGLX && pSurfaceGLX->magic == VA_SURFACE_GLX_MAGIC;
++}
++
++// Destroy VA/GLX display context
++static void va_DisplayContextDestroy(VADisplayContextP pDisplayContext)
++{
++    VADisplayContextGLXP pDisplayContextGLX;
++    VADriverContextP     pDriverContext;
++    VADriverContextGLXP  pDriverContextGLX;
++
++    if (!pDisplayContext)
++        return;
++
++    pDriverContext     = pDisplayContext->pDriverContext;
++    pDriverContextGLX  = pDriverContext->glx;
++    if (pDriverContextGLX) {
++        free(pDriverContextGLX);
++        pDriverContext->glx = NULL;
++    }
++
++    pDisplayContextGLX = pDisplayContext->opaque;
++    if (pDisplayContextGLX) {
++        if (pDisplayContextGLX->vaDestroy)
++            pDisplayContextGLX->vaDestroy(pDisplayContext);
++        free(pDisplayContextGLX);
++        pDisplayContext->opaque = NULL;
++    }
++}
++
++// Return a suitable VADisplay for VA API
++VADisplay vaGetDisplayGLX(Display *native_dpy)
++{
++    VADisplay            dpy                = NULL;
++    VADisplayContextP    pDisplayContext    = NULL;
++    VADisplayContextGLXP pDisplayContextGLX = NULL;
++    VADriverContextP     pDriverContext;
++    VADriverContextGLXP  pDriverContextGLX  = NULL;
++
++    dpy = vaGetDisplay(native_dpy);
++    if (!dpy)
++        return NULL;
++    pDisplayContext = (VADisplayContextP)dpy;
++    pDriverContext  = pDisplayContext->pDriverContext;
++
++    pDisplayContextGLX = calloc(1, sizeof(*pDisplayContextGLX));
++    if (!pDisplayContextGLX)
++        goto error;
++
++    pDriverContextGLX = calloc(1, sizeof(*pDriverContextGLX));
++    if (!pDriverContextGLX)
++        goto error;
++
++    pDisplayContextGLX->vaDestroy = pDisplayContext->vaDestroy;
++    pDisplayContext->vaDestroy    = va_DisplayContextDestroy;
++    pDisplayContext->opaque       = pDisplayContextGLX;
++    pDriverContext->glx           = pDriverContextGLX;
++    return dpy;
++
++error:
++    free(pDriverContextGLX);
++    free(pDisplayContextGLX);
++    pDisplayContext->vaDestroy(pDisplayContext);
++    return NULL;
++}
++
++// Create a surface used for display to OpenGL
++VAStatus vaCreateSurfaceGLX(
++    VADisplay dpy,
++    GLenum    target,
++    GLuint    texture,
++    void    **gl_surface
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    /* Make sure it is a valid GL texture object */
++    if (!glIsTexture(texture))
++        return VA_STATUS_ERROR_INVALID_PARAMETER;
++
++    INIT_CONTEXT(ctx, dpy);
++
++    pSurfaceGLX = va_glx_create_surface(ctx, target, texture);
++    if (!pSurfaceGLX)
++        return VA_STATUS_ERROR_ALLOCATION_FAILED;
++
++    INVOKE(ctx, CreateSurface, (ctx, target, texture, &pSurfaceGLX->priv));
++
++    if (status != VA_STATUS_SUCCESS)
++        va_glx_destroy_surface(ctx, &pSurfaceGLX);
++
++    *gl_surface = pSurfaceGLX;
++    return status;
++}
++
++// Destroy a VA/GLX surface
++VAStatus vaDestroySurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    INIT_CONTEXT(ctx, dpy);
++    INIT_SURFACE(pSurfaceGLX, gl_surface);
++
++    INVOKE(ctx, DestroySurface, (ctx, pSurfaceGLX));
++
++    free(pSurfaceGLX);
++    return status;
++}
++
++// Associate a VA surface to a VA/GLX surface
++VAStatus vaAssociateSurfaceGLX(
++    VADisplay    dpy,
++    void        *gl_surface,
++    VASurfaceID  surface,
++    unsigned int flags
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    INIT_CONTEXT(ctx, dpy);
++    INIT_SURFACE(pSurfaceGLX, gl_surface);
++
++    INVOKE(ctx, AssociateSurface, (ctx, pSurfaceGLX, surface, flags));
++
++    if (status == VA_STATUS_SUCCESS)
++        pSurfaceGLX->surface = surface;
++
++    return status;
++}
++
++// Deassociate a VA surface from a VA/GLX surface
++VAStatus vaDeassociateSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    INIT_CONTEXT(ctx, dpy);
++    INIT_SURFACE(pSurfaceGLX, gl_surface);
++
++    INVOKE(ctx, DeassociateSurface, (ctx, pSurfaceGLX));
++
++    if (status == VA_STATUS_SUCCESS)
++        pSurfaceGLX->surface = VA_INVALID_SURFACE;
++
++    return status;
++}
++
++// Synchronize a VA/GLX surface
++VAStatus vaSyncSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    INIT_CONTEXT(ctx, dpy);
++    INIT_SURFACE(pSurfaceGLX, gl_surface);
++
++    INVOKE(ctx, SyncSurface, (ctx, pSurfaceGLX));
++    return status;
++}
++
++// Prepare VA/GLX surface for rendering
++VAStatus vaBeginRenderSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    INIT_CONTEXT(ctx, dpy);
++    INIT_SURFACE(pSurfaceGLX, gl_surface);
++
++    INVOKE(ctx, BeginRenderSurface, (ctx, pSurfaceGLX));
++    return status;
++}
++
++// Notify the server that the VA/GLX surface is no longer used for rendering
++VAStatus vaEndRenderSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    INIT_CONTEXT(ctx, dpy);
++    INIT_SURFACE(pSurfaceGLX, gl_surface);
++
++    INVOKE(ctx, EndRenderSurface, (ctx, pSurfaceGLX));
++    return status;
++}
++
++// Copy a VA surface to a VA/GLX surface
++VAStatus vaCopySurfaceGLX(
++    VADisplay    dpy,
++    void        *gl_surface,
++    VASurfaceID  surface,
++    unsigned int flags
++)
++{
++    VADriverContextP ctx;
++    VASurfaceGLXP pSurfaceGLX;
++    VAStatus status;
++
++    INIT_CONTEXT(ctx, dpy);
++    INIT_SURFACE(pSurfaceGLX, gl_surface);
++
++    INVOKE(ctx, CopySurface, (ctx, pSurfaceGLX, surface, flags));
++    return status;
++}
+diff --git a/src/glx/va_glx.h b/src/glx/va_glx.h
+new file mode 100644
+index 0000000..183ef3a
+--- /dev/null
++++ b/src/glx/va_glx.h
+@@ -0,0 +1,217 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef VA_GLX_H
++#define VA_GLX_H
++
++#ifdef IN_LIBVA
++#include "va.h"
++#else
++#include <va/va.h>
++#endif
++#include <GL/glx.h>
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/**
++ * Return a suitable VADisplay for VA API
++ *
++ * @param[in] dpy the X11 display
++ * @return a VADisplay
++ */
++VADisplay vaGetDisplayGLX(
++    Display *dpy
++);
++
++/**
++ * Create a surface used for display to OpenGL
++ *
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  target     the GL target to which the texture needs to be bound
++ * @param[in]  texture    the GL texture
++ * @param[out] gl_surface the VA/GLX surface
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaCreateSurfaceGLX(
++    VADisplay dpy,
++    GLenum    target,
++    GLuint    texture,
++    void    **gl_surface
++);
++
++/**
++ * Destroy a VA/GLX surface
++ *
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  gl_surface the VA surface
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaDestroySurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++);
++
++/**
++ * Associate a VA surface to a VA/GLX surface
++ *
++ * The association is live until vaDeassociateSurfaceGLX(),
++ * vaCopySurfaceGLX() or the next call to vaBeginPicture() with the
++ * specificed VA surface.
++ * 
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  gl_surface the VA/GLX surface
++ * @param[in]  surface    the VA surface
++ * @param[in]  flags      the PutSurface flags
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaAssociateSurfaceGLX(
++    VADisplay    dpy,
++    void        *gl_surface,
++    VASurfaceID  surface,
++    unsigned int flags
++);
++
++/**
++ * Deassociate a VA surface from a VA/GLX surface
++ *
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  gl_surface the VA surface
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaDeassociateSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++);
++
++/**
++ * Synchronize a VA/GLX surface
++ *
++ * This function blocks until all pending operations on the VA/GLX
++ * surface have been completed.
++ *
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  gl_surface the VA surface
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaSyncSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++);
++
++/**
++ * Prepare VA/GLX surface for rendering
++ *
++ * This function performs an implicit vaSyncSurfaceGLX().
++ *
++ * Implementations using the GLX texture-from-pixmap extension will
++ * generally call glXBindTexImage() here.
++ *
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  gl_surface the VA surface
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaBeginRenderSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++);
++
++/**
++ * Notify the server that the VA/GLX surface is no longer used for
++ * rendering
++ *
++ * Implementations using the GLX texture-from-pixmap extension will
++ * generally call glXReleaseTexImage() here.
++ *
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  gl_surface the VA surface
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaEndRenderSurfaceGLX(
++    VADisplay dpy,
++    void     *gl_surface
++);
++
++/**
++ * Copy a VA surface to a VA/GLX surface
++ *
++ * This function kills any association that was previously made with
++ * vaAssociateSurfaceGLX() and will not return until the copy is
++ * completed.
++ *
++ * Upon successful return, the underlying GL texture will contain the
++ * complete pixels and no call to vaBeginRenderSurfaceGLX() or
++ * vaEndRenderSurfaceGLX() is required.
++ *
++ * The application shall maintain the live GLX context itself.
++ * Implementations are free to use glXGetCurrentContext() and
++ * glXGetCurrentDrawable() functions for internal purposes.
++ *
++ * @param[in]  dpy        the VA display
++ * @param[in]  gl_surface the VA/GLX destination surface
++ * @param[in]  surface    the VA source surface
++ * @param[in]  flags      the PutSurface flags
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus vaCopySurfaceGLX(
++    VADisplay    dpy,
++    void        *gl_surface,
++    VASurfaceID  surface,
++    unsigned int flags
++);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* VA_GLX_H */
+diff --git a/src/glx/va_glx_impl.c b/src/glx/va_glx_impl.c
+new file mode 100644
+index 0000000..d4f9c1d
+--- /dev/null
++++ b/src/glx/va_glx_impl.c
+@@ -0,0 +1,1168 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
++ */
++
++#define _GNU_SOURCE 1
++#include "va_glx_private.h"
++#include "va_glx_impl.h"
++#include <stdio.h>
++#include <stdarg.h>
++#include <string.h>
++#include <assert.h>
++#include <dlfcn.h>
++
++static void va_glx_error_message(const char *format, ...)
++{
++    va_list args;
++    va_start(args, format);
++    fprintf(stderr, "[%s] ", PACKAGE_NAME);
++    vfprintf(stderr, format, args);
++    va_end(args);
++}
++
++// X error trap
++static int x11_error_code = 0;
++static int (*old_error_handler)(Display *, XErrorEvent *);
++
++static int error_handler(Display *dpy, XErrorEvent *error)
++{
++    x11_error_code = error->error_code;
++    return 0;
++}
++
++static void x11_trap_errors(void)
++{
++    x11_error_code    = 0;
++    old_error_handler = XSetErrorHandler(error_handler);
++}
++
++static int x11_untrap_errors(void)
++{
++    XSetErrorHandler(old_error_handler);
++    return x11_error_code;
++}
++
++// Returns a string representation of an OpenGL error
++static const char *gl_get_error_string(GLenum error)
++{
++    static const struct {
++        GLenum val;
++        const char *str;
++    }
++    gl_errors[] = {
++        { GL_NO_ERROR,          "no error" },
++        { GL_INVALID_ENUM,      "invalid enumerant" },
++        { GL_INVALID_VALUE,     "invalid value" },
++        { GL_INVALID_OPERATION, "invalid operation" },
++        { GL_STACK_OVERFLOW,    "stack overflow" },
++        { GL_STACK_UNDERFLOW,   "stack underflow" },
++        { GL_OUT_OF_MEMORY,     "out of memory" },
++#ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT
++        { GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "invalid framebuffer operation" },
++#endif
++        { ~0, NULL }
++    };
++
++    int i;
++    for (i = 0; gl_errors[i].str; i++) {
++        if (gl_errors[i].val == error)
++            return gl_errors[i].str;
++    }
++    return "unknown";
++}
++
++static inline int gl_do_check_error(int report)
++{
++    GLenum error;
++    int is_error = 0;
++    while ((error = glGetError()) != GL_NO_ERROR) {
++        if (report)
++            va_glx_error_message("glError: %s caught\n",
++                                 gl_get_error_string(error));
++        is_error = 1;
++    }
++    return is_error;
++}
++
++static inline void gl_purge_errors(void)
++{
++    gl_do_check_error(0);
++}
++
++static inline int gl_check_error(void)
++{
++    return gl_do_check_error(1);
++}
++
++// glGetFloatv() wrapper
++static int gl_get_current_color(float color[4])
++{
++    gl_purge_errors();
++    glGetFloatv(GL_CURRENT_COLOR, color);
++    if (gl_check_error())
++        return -1;
++    return 0;
++}
++
++// glGetIntegerv() wrapper
++static int gl_get_param(GLenum param, unsigned int *pval)
++{
++    GLint val;
++
++    gl_purge_errors();
++    glGetIntegerv(param, &val);
++    if (gl_check_error())
++        return -1;
++    if (pval)
++        *pval = val;
++    return 0;
++}
++
++// glGetTexLevelParameteriv() wrapper
++static int gl_get_texture_param(GLenum param, unsigned int *pval)
++{
++    GLint val;
++
++    gl_purge_errors();
++    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, param, &val);
++    if (gl_check_error())
++        return -1;
++    if (pval)
++        *pval = val;
++    return 0;
++}
++
++// Returns the OpenGL VTable
++static inline VAOpenGLVTableP gl_get_vtable(VADriverContextP ctx)
++{
++    return &VA_DRIVER_CONTEXT_GLX(ctx)->gl_vtable;
++}
++
++// Lookup for a GLX function
++typedef void (*GLFuncPtr)(void);
++typedef GLFuncPtr (*GLXGetProcAddressProc)(const char *);
++
++static GLFuncPtr get_proc_address_default(const char *name)
++{
++    return NULL;
++}
++
++static GLXGetProcAddressProc get_proc_address_func(void)
++{
++    GLXGetProcAddressProc get_proc_func;
++
++    dlerror();
++    get_proc_func = (GLXGetProcAddressProc)
++        dlsym(RTLD_DEFAULT, "glXGetProcAddress");
++    if (dlerror() == NULL)
++        return get_proc_func;
++
++    get_proc_func = (GLXGetProcAddressProc)
++        dlsym(RTLD_DEFAULT, "glXGetProcAddressARB");
++    if (dlerror() == NULL)
++        return get_proc_func;
++
++    return get_proc_address_default;
++}
++
++static inline GLFuncPtr get_proc_address(const char *name)
++{
++    static GLXGetProcAddressProc get_proc_func = NULL;
++    if (get_proc_func == NULL)
++        get_proc_func = get_proc_address_func();
++    return get_proc_func(name);
++}
++
++// Check for GLX extensions (TFP, FBO)
++static int check_extension(const char *name, const char *ext)
++{
++    const char *end;
++    int name_len, n;
++
++    if (name == NULL || ext == NULL)
++        return 0;
++
++    end = ext + strlen(ext);
++    name_len = strlen(name);
++    while (ext < end) {
++        n = strcspn(ext, " ");
++        if (n == name_len && strncmp(name, ext, n) == 0)
++            return 1;
++        ext += (n + 1);
++    }
++    return 0;
++}
++
++static int check_tfp_extensions(VADriverContextP ctx)
++{
++    const char *gl_extensions;
++    const char *glx_extensions;
++
++    gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
++    if (!check_extension("GL_ARB_texture_non_power_of_two", gl_extensions))
++        return 0;
++
++    glx_extensions = glXQueryExtensionsString(ctx->x11_dpy, ctx->x11_screen);
++    if (!check_extension("GLX_EXT_texture_from_pixmap", glx_extensions))
++        return 0;
++    return 1;
++}
++
++static int check_fbo_extensions(VADriverContextP ctx)
++{
++    const char *gl_extensions;
++
++    gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
++    if (!check_extension("GL_ARB_framebuffer_object", gl_extensions))
++        return 0;
++    if (!check_extension("GL_EXT_framebuffer_object", gl_extensions))
++        return 0;
++    return 1;
++}
++
++// Load GLX extensions
++static int load_tfp_extensions(VADriverContextP ctx)
++{
++    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
++
++    pOpenGLVTable->glx_bind_tex_image = (PFNGLXBINDTEXIMAGEEXTPROC)
++        get_proc_address("glXBindTexImageEXT");
++    if (pOpenGLVTable->glx_bind_tex_image == NULL)
++        return 0;
++    pOpenGLVTable->glx_release_tex_image = (PFNGLXRELEASETEXIMAGEEXTPROC)
++        get_proc_address("glXReleaseTexImageEXT");
++    if (pOpenGLVTable->glx_release_tex_image == NULL)
++        return 0;
++    return 1;
++}
++
++static int load_fbo_extensions(VADriverContextP ctx)
++{
++    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
++
++    pOpenGLVTable->gl_gen_framebuffers = (PFNGLGENFRAMEBUFFERSEXTPROC)
++        get_proc_address("glGenFramebuffersEXT");
++    if (pOpenGLVTable->gl_gen_framebuffers == NULL)
++        return 0;
++    pOpenGLVTable->gl_delete_framebuffers = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
++        get_proc_address("glDeleteFramebuffersEXT");
++    if (pOpenGLVTable->gl_delete_framebuffers == NULL)
++        return 0;
++    pOpenGLVTable->gl_bind_framebuffer = (PFNGLBINDFRAMEBUFFEREXTPROC)
++        get_proc_address("glBindFramebufferEXT");
++    if (pOpenGLVTable->gl_bind_framebuffer == NULL)
++        return 0;
++    pOpenGLVTable->gl_gen_renderbuffers = (PFNGLGENRENDERBUFFERSEXTPROC)
++        get_proc_address("glGenRenderbuffersEXT");
++    if (pOpenGLVTable->gl_gen_renderbuffers == NULL)
++        return 0;
++    pOpenGLVTable->gl_delete_renderbuffers = (PFNGLDELETERENDERBUFFERSEXTPROC)
++        get_proc_address("glDeleteRenderbuffersEXT");
++    if (pOpenGLVTable->gl_delete_renderbuffers == NULL)
++        return 0;
++    pOpenGLVTable->gl_bind_renderbuffer = (PFNGLBINDRENDERBUFFEREXTPROC)
++        get_proc_address("glBindRenderbufferEXT");
++    if (pOpenGLVTable->gl_bind_renderbuffer == NULL)
++        return 0;
++    pOpenGLVTable->gl_renderbuffer_storage = (PFNGLRENDERBUFFERSTORAGEEXTPROC)
++        get_proc_address("glRenderbufferStorageEXT");
++    if (pOpenGLVTable->gl_renderbuffer_storage == NULL)
++        return 0;
++    pOpenGLVTable->gl_framebuffer_renderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)
++        get_proc_address("glFramebufferRenderbufferEXT");
++    if (pOpenGLVTable->gl_framebuffer_renderbuffer == NULL)
++        return 0;
++    pOpenGLVTable->gl_framebuffer_texture_2d = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
++        get_proc_address("glFramebufferTexture2DEXT");
++    if (pOpenGLVTable->gl_framebuffer_texture_2d == NULL)
++        return 0;
++    pOpenGLVTable->gl_check_framebuffer_status = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
++        get_proc_address("glCheckFramebufferStatusEXT");
++    if (pOpenGLVTable->gl_check_framebuffer_status == NULL)
++        return 0;
++    return 1;
++}
++
++
++/* ========================================================================= */
++/* === VA/GLX helpers                                                    === */
++/* ========================================================================= */
++
++// OpenGL texture state
++typedef struct OpenGLTextureState *OpenGLTextureStateP;
++
++struct OpenGLTextureState {
++    int    was_enabled;
++    int    was_bound;
++    GLenum target;
++    GLuint old_texture;
++};
++
++// Bind texture, preserve previous texture state
++static int bind_texture(OpenGLTextureStateP ts, GLenum target, GLuint texture)
++{
++    ts->target      = target;
++    ts->old_texture = 0;
++    ts->was_bound   = 0;
++    ts->was_enabled = glIsEnabled(target);
++    if (!ts->was_enabled)
++        glEnable(target);
++
++    GLenum texture_binding;
++    switch (target) {
++    case GL_TEXTURE_1D:
++        texture_binding = GL_TEXTURE_BINDING_1D;
++        break;
++    case GL_TEXTURE_2D:
++        texture_binding = GL_TEXTURE_BINDING_2D;
++        break;
++    case GL_TEXTURE_3D:
++        texture_binding = GL_TEXTURE_BINDING_3D;
++        break;
++    case GL_TEXTURE_RECTANGLE_ARB:
++        texture_binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
++        break;
++    default:
++        assert(!target);
++        return -1;
++    }
++
++    if (ts->was_enabled && gl_get_param(texture_binding, &ts->old_texture) < 0)
++        return -1;
++
++    ts->was_bound = texture == ts->old_texture;
++    if (!ts->was_bound) {
++        gl_purge_errors();
++        glBindTexture(target, texture);
++        if (gl_check_error())
++            return -1;
++    }
++    return 0;
++}
++
++// Unbind texture, restore previous texture state
++static void unbind_texture(OpenGLTextureStateP ts)
++{
++    if (!ts->was_bound && ts->old_texture)
++        glBindTexture(ts->target, ts->old_texture);
++    if (!ts->was_enabled)
++        glDisable(ts->target);
++}
++
++// Create Pixmaps for GLX texture-from-pixmap extension
++static int create_tfp_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    const unsigned int     width      = pSurfaceGLX->width;
++    const unsigned int     height     = pSurfaceGLX->height;
++    Pixmap                 pixmap     = None;
++    GLXFBConfig           *fbconfig   = NULL;
++    GLXPixmap              glx_pixmap = None;
++    Window                 root_window;
++    XWindowAttributes      wattr;
++    int                   *attrib;
++    int                    n_fbconfig_attribs, x, y, status;
++    unsigned int           border_width, depth, dummy;
++
++    root_window = RootWindow(ctx->x11_dpy, ctx->x11_screen);
++    XGetWindowAttributes(ctx->x11_dpy, root_window, &wattr);
++    pixmap = XCreatePixmap(ctx->x11_dpy, root_window,
++                           width, height, wattr.depth);
++    if (!pixmap)
++        return -1;
++    pSurfaceGLX->pixmap = pixmap;
++
++    x11_trap_errors();
++    status = XGetGeometry(ctx->x11_dpy,
++                          (Drawable)pixmap,
++                          &root_window,
++                          &x,
++                          &y,
++                          &dummy,
++                          &dummy,
++                          &border_width,
++                          &depth);
++    if (x11_untrap_errors() != 0 || status == 0)
++        return -1;
++    if (depth != 24 && depth != 32)
++        return -1;
++
++    int fbconfig_attribs[32] = {
++        GLX_DRAWABLE_TYPE,      GLX_PIXMAP_BIT,
++        GLX_DOUBLEBUFFER,       GL_TRUE,
++        GLX_RENDER_TYPE,        GLX_RGBA_BIT,
++        GLX_X_RENDERABLE,       GL_TRUE,
++        GLX_Y_INVERTED_EXT,     GL_TRUE,
++        GLX_RED_SIZE,           8,
++        GLX_GREEN_SIZE,         8,
++        GLX_BLUE_SIZE,          8,
++        GL_NONE,
++    };
++    for (attrib = fbconfig_attribs; *attrib != GL_NONE; attrib += 2)
++        ;
++    *attrib++ = GLX_DEPTH_SIZE;                         *attrib++ = depth;
++    if (depth == 32) {
++        *attrib++ = GLX_ALPHA_SIZE;                     *attrib++ = 8;
++        *attrib++ = GLX_BIND_TO_TEXTURE_RGBA_EXT;       *attrib++ = GL_TRUE;
++    }
++    else {
++        *attrib++ = GLX_BIND_TO_TEXTURE_RGB_EXT;        *attrib++ = GL_TRUE;
++    }
++    *attrib++ = GL_NONE;
++
++    fbconfig = glXChooseFBConfig(ctx->x11_dpy, ctx->x11_screen, fbconfig_attribs, &n_fbconfig_attribs);
++    if (fbconfig == NULL)
++        return -1;
++
++    int pixmap_attribs[10] = {
++        GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
++        GLX_MIPMAP_TEXTURE_EXT, GL_FALSE,
++        GL_NONE,
++    };
++    for (attrib = pixmap_attribs; *attrib != GL_NONE; attrib += 2)
++        ;
++    *attrib++ = GLX_TEXTURE_FORMAT_EXT;
++    if (depth == 32)
++        *attrib++ = GLX_TEXTURE_FORMAT_RGBA_EXT;
++    else
++        *attrib++ = GLX_TEXTURE_FORMAT_RGB_EXT;
++    *attrib++ = GL_NONE;
++
++    x11_trap_errors();
++    glx_pixmap = glXCreatePixmap(ctx->x11_dpy,
++                                 fbconfig[0],
++                                 pixmap,
++                                 pixmap_attribs);
++    free(fbconfig);
++    if (x11_untrap_errors() != 0)
++        return -1;
++    pSurfaceGLX->glx_pixmap = glx_pixmap;
++    return 0;
++}
++
++// Destroy Pixmaps used for TFP
++static void destroy_tfp_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    if (pSurfaceGLX->glx_pixmap) {
++        glXDestroyPixmap(ctx->x11_dpy, pSurfaceGLX->glx_pixmap);
++        pSurfaceGLX->glx_pixmap = None;
++    }
++
++    if (pSurfaceGLX->pixmap) {
++        XFreePixmap(ctx->x11_dpy, pSurfaceGLX->pixmap);
++        pSurfaceGLX->pixmap = None;
++    }
++}
++
++// Bind GLX Pixmap to texture
++static int bind_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
++
++    if (pSurfaceGLX->is_bound)
++        return 0;
++
++    x11_trap_errors();
++    pOpenGLVTable->glx_bind_tex_image(ctx->x11_dpy, pSurfaceGLX->glx_pixmap,
++                                      GLX_FRONT_LEFT_EXT, NULL);
++    XSync(ctx->x11_dpy, False);
++    if (x11_untrap_errors() != 0) {
++        va_glx_error_message("failed to bind pixmap\n");
++        return -1;
++    }
++
++    pSurfaceGLX->is_bound = 1;
++    return 0;
++}
++
++// Release GLX Pixmap from texture
++static int unbind_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
++
++    if (!pSurfaceGLX->is_bound)
++        return 0;
++
++    x11_trap_errors();
++    pOpenGLVTable->glx_release_tex_image(ctx->x11_dpy, pSurfaceGLX->glx_pixmap,
++                                         GLX_FRONT_LEFT_EXT);
++    XSync(ctx->x11_dpy, False);
++    if (x11_untrap_errors() != 0) {
++        va_glx_error_message("failed to release pixmap\n");
++        return -1;
++    }
++
++    pSurfaceGLX->is_bound = 0;
++    return 0;
++}
++
++// Render GLX Pixmap to texture
++static void render_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    const unsigned int w = pSurfaceGLX->width;
++    const unsigned int h = pSurfaceGLX->height;
++    float old_color[4];
++
++    gl_get_current_color(old_color);
++    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
++    glBegin(GL_QUADS);
++    {
++        glTexCoord2f(0.0f, 0.0f); glVertex2i(0, 0);
++        glTexCoord2f(0.0f, 1.0f); glVertex2i(0, h);
++        glTexCoord2f(1.0f, 1.0f); glVertex2i(w, h);
++        glTexCoord2f(1.0f, 0.0f); glVertex2i(w, 0);
++    }
++    glEnd();
++    glColor4fv(old_color);
++}
++
++// Create offscreen surface
++static int create_fbo_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    VAOpenGLVTableP       pOpenGLVTable  = gl_get_vtable(ctx);
++    const GLenum          texture        = pSurfaceGLX->texture;
++    const unsigned int    texture_width  = pSurfaceGLX->width;
++    const unsigned int    texture_height = pSurfaceGLX->height;
++    GLuint fbo, fbo_buffer, fbo_texture;
++    GLenum status;
++
++    glGenTextures(1, &fbo_texture);
++    glBindTexture(GL_TEXTURE_2D, fbo_texture);
++    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
++    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
++    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
++    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
++    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
++    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture_width, texture_height, 0,
++                 GL_BGRA, GL_UNSIGNED_BYTE, NULL);
++
++    pOpenGLVTable->gl_gen_framebuffers(1, &fbo);
++    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, fbo);
++    pOpenGLVTable->gl_gen_renderbuffers(1, &fbo_buffer);
++    pOpenGLVTable->gl_bind_renderbuffer(GL_RENDERBUFFER_EXT, fbo_buffer);
++
++    glBindTexture(GL_TEXTURE_2D, texture);
++    pOpenGLVTable->gl_framebuffer_texture_2d(GL_FRAMEBUFFER_EXT,
++                                             GL_COLOR_ATTACHMENT0_EXT,
++                                             GL_TEXTURE_2D, texture, 0);
++
++    status = pOpenGLVTable->gl_check_framebuffer_status(GL_DRAW_FRAMEBUFFER_EXT);
++    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, 0);
++    if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
++        return -1;
++
++    pSurfaceGLX->fbo         = fbo;
++    pSurfaceGLX->fbo_buffer  = fbo_buffer;
++    pSurfaceGLX->fbo_texture = fbo_texture;
++    return 0;
++}
++
++// Destroy offscreen surface
++static void destroy_fbo_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
++
++    if (pSurfaceGLX->fbo_texture) {
++        glDeleteTextures(1, &pSurfaceGLX->fbo_texture);
++        pSurfaceGLX->fbo_texture = 0;
++    }
++
++    if (pSurfaceGLX->fbo_buffer) {
++        pOpenGLVTable->gl_delete_renderbuffers(1, &pSurfaceGLX->fbo_buffer);
++        pSurfaceGLX->fbo_buffer = 0;
++    }
++
++    if (pSurfaceGLX->fbo) {
++        pOpenGLVTable->gl_delete_framebuffers(1, &pSurfaceGLX->fbo);
++        pSurfaceGLX->fbo = 0;
++    }
++}
++
++// Setup matrices to match the FBO texture dimensions
++static void fbo_enter(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX)
++{
++    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
++    const unsigned int width  = pSurfaceGLX->width;
++    const unsigned int height = pSurfaceGLX->height;
++
++    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, pSurfaceGLX->fbo);
++    glPushAttrib(GL_VIEWPORT_BIT);
++    glMatrixMode(GL_PROJECTION);
++    glPushMatrix();
++    glLoadIdentity();
++    glMatrixMode(GL_MODELVIEW);
++    glPushMatrix();
++    glLoadIdentity();
++    glViewport(0, 0, width, height);
++    glTranslatef(-1.0f, -1.0f, 0.0f);
++    glScalef(2.0f / width, 2.0f / height, 1.0f);
++
++    glBindTexture(GL_TEXTURE_2D, pSurfaceGLX->fbo_texture);
++}
++
++// Restore original OpenGL matrices
++static void fbo_leave(VADriverContextP ctx)
++{
++    VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx);
++
++    glPopAttrib();
++    glMatrixMode(GL_PROJECTION);
++    glPopMatrix();
++    glMatrixMode(GL_MODELVIEW);
++    glPopMatrix();
++    pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, 0);
++}
++
++// Create VA/GLX surface
++VASurfaceGLXP
++va_glx_create_surface(VADriverContextP ctx, GLenum target, GLuint texture)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VASurfaceGLXP pSurfaceGLX;
++    unsigned int internal_format, border_width, width, height;
++    int is_error = 1;
++
++    /* Make sure binding succeeds, if texture was not already bound */
++    struct OpenGLTextureState ts;
++    if (bind_texture(&ts, target, texture) < 0)
++        goto end;
++
++    pSurfaceGLX = malloc(sizeof(*pSurfaceGLX));
++    if (!pSurfaceGLX)
++        goto end;
++
++    pSurfaceGLX->magic          = VA_SURFACE_GLX_MAGIC;
++    pSurfaceGLX->target         = target;
++    pSurfaceGLX->texture        = texture;
++    pSurfaceGLX->surface        = VA_INVALID_SURFACE;
++    pSurfaceGLX->is_bound       = 0;
++    pSurfaceGLX->pixmap         = None;
++    pSurfaceGLX->glx_pixmap     = None;
++    pSurfaceGLX->fbo            = 0;
++    pSurfaceGLX->fbo_buffer     = 0;
++    pSurfaceGLX->fbo_texture    = 0;
++    pSurfaceGLX->priv           = NULL;
++
++    /* XXX: we don't support other textures than RGBA */
++    if (gl_get_texture_param(GL_TEXTURE_INTERNAL_FORMAT, &internal_format) < 0)
++        goto end;
++    if (internal_format != GL_RGBA)
++        goto end;
++
++    /* Check texture dimensions */
++    if (gl_get_texture_param(GL_TEXTURE_BORDER, &border_width) < 0)
++        goto end;
++    if (gl_get_texture_param(GL_TEXTURE_WIDTH, &width) < 0)
++        goto end;
++    if (gl_get_texture_param(GL_TEXTURE_HEIGHT, &height) < 0)
++        goto end;
++
++    width  -= 2 * border_width;
++    height -= 2 * border_width;
++    if (width == 0 || height == 0)
++        goto end;
++
++    pSurfaceGLX->width  = width;
++    pSurfaceGLX->height = height;
++
++    /* Create Pixmaps for TFP */
++    if (pDriverContextGLX->use_tfp) {
++        if (create_tfp_surface(ctx, pSurfaceGLX) < 0)
++            goto end;
++    }
++
++    /* Create Pixmaps for FBO */
++    if (pDriverContextGLX->use_fbo) {
++        if (create_fbo_surface(ctx, pSurfaceGLX) < 0)
++            goto end;
++    }
++
++    is_error = 0;
++end:
++    if (is_error && pSurfaceGLX)
++        va_glx_destroy_surface(ctx, &pSurfaceGLX);
++
++    unbind_texture(&ts);
++    return pSurfaceGLX;
++}
++
++// Destroy VA/GLX surface
++void va_glx_destroy_surface(VADriverContextP ctx, VASurfaceGLXP *ppSurfaceGLX)
++{
++    VASurfaceGLXP pSurfaceGLX = *ppSurfaceGLX;
++
++    unbind_pixmap(ctx, pSurfaceGLX);
++    destroy_fbo_surface(ctx, pSurfaceGLX);
++    destroy_tfp_surface(ctx, pSurfaceGLX);
++
++    free(pSurfaceGLX);
++    *ppSurfaceGLX = NULL;
++}
++
++
++/* ========================================================================= */
++/* === VA/GLX implementation from the driver (fordward calls)            === */
++/* ========================================================================= */
++
++#define INVOKE(ctx, func, args) do {                    \
++        VADriverVTableGLXP vtable = &(ctx)->vtable.glx; \
++        if (!vtable->va##func##GLX)                     \
++            return VA_STATUS_ERROR_UNIMPLEMENTED;       \
++                                                        \
++        VAStatus status = vtable->va##func##GLX args;   \
++        if (status != VA_STATUS_SUCCESS)                \
++            return status;                              \
++    } while (0)
++
++static VAStatus
++vaCreateSurfaceGLX_impl_driver(
++    VADriverContextP    ctx,
++    GLenum              target,
++    GLuint              texture,
++    void              **gl_surface
++)
++{
++    INVOKE(ctx, CreateSurface, (ctx, target, texture, gl_surface));
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaDestroySurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface)
++{
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    INVOKE(ctx, DestroySurface, (ctx, pSurfaceGLX->priv));
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaAssociateSurfaceGLX_impl_driver(
++    VADriverContextP    ctx,
++    void               *gl_surface,
++    VASurfaceID         surface,
++    unsigned int        flags
++)
++{
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    INVOKE(ctx, AssociateSurface, (ctx, pSurfaceGLX->priv, surface, flags));
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaDeassociateSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface)
++{
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    INVOKE(ctx, DeassociateSurface, (ctx, pSurfaceGLX->priv));
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaSyncSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface)
++{
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    INVOKE(ctx, SyncSurface, (ctx, pSurfaceGLX->priv));
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaBeginRenderSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface)
++{
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    INVOKE(ctx, BeginRenderSurface, (ctx, pSurfaceGLX->priv));
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaEndRenderSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface)
++{
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    INVOKE(ctx, EndRenderSurface, (ctx, pSurfaceGLX->priv));
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaCopySurfaceGLX_impl_driver(
++    VADriverContextP    ctx,
++    void               *gl_surface,
++    VASurfaceID         surface,
++    unsigned int        flags
++)
++{
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    INVOKE(ctx, CopySurface, (ctx, pSurfaceGLX->priv, surface, flags));
++    return VA_STATUS_SUCCESS;
++}
++
++#undef INVOKE
++
++
++/* ========================================================================= */
++/* === VA/GLX implementation from libVA (generic and suboptimal path)    === */
++/* ========================================================================= */
++
++static VAStatus
++vaCreateSurfaceGLX_impl_libva(
++    VADriverContextP    ctx,
++    GLenum              target,
++    GLuint              texture,
++    void              **gl_surface
++)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++
++    if (!pDriverContextGLX->use_tfp)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    *gl_surface = NULL;
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaDestroySurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++
++    if (!pDriverContextGLX->use_tfp)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaAssociateSurfaceGLX_impl_libva(
++    VADriverContextP    ctx,
++    void               *gl_surface,
++    VASurfaceID         surface,
++    unsigned int        flags
++)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VADriverVTableGLXP vtable = &pDriverContextGLX->vtable;
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++    VAStatus status;
++
++    if (!pDriverContextGLX->use_tfp)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    /* XXX: only support VA_FRAME_PICTURE */
++    if (flags != VA_FRAME_PICTURE)
++        return VA_STATUS_ERROR_FLAG_NOT_SUPPORTED;
++
++    /* XXX: optimise case where we are associating the same VA surface
++       as before an no changed occurred to it */
++    status = vtable->vaDeassociateSurfaceGLX(ctx, gl_surface);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    x11_trap_errors();
++    status = ctx->vtable.vaPutSurface(ctx,
++                                      surface,
++                                      pSurfaceGLX->pixmap,
++                                      0, 0,
++                                      pSurfaceGLX->width,
++                                      pSurfaceGLX->height,
++                                      0, 0,
++                                      pSurfaceGLX->width,
++                                      pSurfaceGLX->height,
++                                      NULL, 0,
++                                      flags);
++    XSync(ctx->x11_dpy, False);
++    if (x11_untrap_errors() != 0)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    pSurfaceGLX->surface = surface;
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaDeassociateSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    if (!pDriverContextGLX->use_tfp)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    if (unbind_pixmap(ctx, pSurfaceGLX) < 0)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++
++    pSurfaceGLX->surface = VA_INVALID_SURFACE;
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaSyncSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    if (!pDriverContextGLX->use_tfp)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    if (pSurfaceGLX->surface == VA_INVALID_SURFACE)
++        return VA_STATUS_ERROR_INVALID_SURFACE;
++
++    return ctx->vtable.vaSyncSurface(ctx, pSurfaceGLX->surface);
++}
++
++static VAStatus
++vaBeginRenderSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++    VAStatus status;
++
++    if (!pDriverContextGLX->use_tfp)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    status = vaSyncSurfaceGLX_impl_libva(ctx, gl_surface);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    if (bind_pixmap(ctx, pSurfaceGLX) < 0)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaEndRenderSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++    VAStatus status;
++
++    if (!pDriverContextGLX->use_tfp)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    if (unbind_pixmap(ctx, pSurfaceGLX) < 0)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaCopySurfaceGLX_impl_libva(
++    VADriverContextP    ctx,
++    void               *gl_surface,
++    VASurfaceID         surface,
++    unsigned int        flags
++)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VADriverVTableGLXP vtable = &pDriverContextGLX->vtable;
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++    VAStatus status;
++
++    if (!pDriverContextGLX->use_fbo)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    /* XXX: only support VA_FRAME_PICTURE */
++    if (flags != VA_FRAME_PICTURE)
++        return VA_STATUS_ERROR_FLAG_NOT_SUPPORTED;
++
++    /* Associate VA surface */
++    status = vtable->vaAssociateSurfaceGLX(ctx, gl_surface, surface, flags);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    /* Make sure binding succeeds, if texture was not already bound */
++    struct OpenGLTextureState ts;
++    if (bind_texture(&ts, pSurfaceGLX->target, pSurfaceGLX->texture) < 0)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++
++    /* Render to FBO */
++    fbo_enter(ctx, pSurfaceGLX);
++    status = vtable->vaBeginRenderSurfaceGLX(ctx, gl_surface);
++    if (status == VA_STATUS_SUCCESS) {
++        render_pixmap(ctx, pSurfaceGLX);
++        status = vtable->vaEndRenderSurfaceGLX(ctx, gl_surface);
++    }
++    fbo_leave(ctx);
++    unbind_texture(&ts);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    return vtable->vaDeassociateSurfaceGLX(ctx, gl_surface);
++}
++
++
++/* ========================================================================= */
++/* === VA/GLX bind functions implementation with vaCopySurfaceGLX()      === */
++/* ========================================================================= */
++
++static VAStatus
++vaAssociateSurfaceGLX_impl_bind(
++    VADriverContextP    ctx,
++    void               *gl_surface,
++    VASurfaceID         surface,
++    unsigned int        flags
++)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VADriverVTableGLXP vtable = &pDriverContextGLX->vtable;
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++    VAStatus status;
++
++    if (!pDriverContextGLX->has_copy)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    status = vtable->vaCopySurfaceGLX(ctx, gl_surface, surface, flags);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    pSurfaceGLX->surface = surface;
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaDeassociateSurfaceGLX_impl_bind(VADriverContextP ctx, void *gl_surface)
++{
++    VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx);
++    VASurfaceGLXP pSurfaceGLX = gl_surface;
++
++    if (!pDriverContextGLX->has_copy)
++        return VA_STATUS_ERROR_UNIMPLEMENTED;
++
++    pSurfaceGLX->surface = VA_INVALID_SURFACE;
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaBeginRenderSurfaceGLX_impl_bind(VADriverContextP ctx, void *gl_surface)
++{
++    /* Surface is already copied into the texture, in vaAssociateSurfaceGLX() */
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus
++vaEndRenderSurfaceGLX_impl_bind(VADriverContextP ctx, void *gl_surface)
++{
++    return VA_STATUS_SUCCESS;
++}
++
++
++/* ========================================================================= */
++/* === Private VA/GLX vtable initialization                              === */
++/* ========================================================================= */
++
++// Initialize GLX driver context
++VAStatus va_glx_init_context(VADriverContextP ctx)
++{
++    VADriverContextGLXP glx_ctx = VA_DRIVER_CONTEXT_GLX(ctx);
++    VADriverVTableGLXP  vtable  = &glx_ctx->vtable;
++    int needs_tfp = 0, needs_fbo = 0;
++
++    if (glx_ctx->is_initialized)
++        return VA_STATUS_SUCCESS;
++
++    glx_ctx->has_copy = ctx->vtable.glx.vaCopySurfaceGLX != NULL;
++    glx_ctx->has_bind = (ctx->vtable.glx.vaAssociateSurfaceGLX   != NULL &&
++                         ctx->vtable.glx.vaBeginRenderSurfaceGLX != NULL &&
++                         ctx->vtable.glx.vaEndRenderSurfaceGLX   != NULL &&
++                         ctx->vtable.glx.vaDeassociateSurfaceGLX != NULL);
++
++    switch ((((unsigned int)glx_ctx->has_bind) << 1) | glx_ctx->has_copy) {
++    case 0:
++        /* Full implementation in libVA */
++        needs_tfp = 1;
++        needs_fbo = 1;
++        vtable->vaCreateSurfaceGLX      = vaCreateSurfaceGLX_impl_libva;
++        vtable->vaDestroySurfaceGLX     = vaDestroySurfaceGLX_impl_libva;
++        vtable->vaAssociateSurfaceGLX   = vaAssociateSurfaceGLX_impl_libva;
++        vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_libva;
++        vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_libva;
++        vtable->vaEndRenderSurfaceGLX   = vaEndRenderSurfaceGLX_impl_libva;
++        vtable->vaSyncSurfaceGLX        = vaSyncSurfaceGLX_impl_libva;
++        vtable->vaCopySurfaceGLX        = vaCopySurfaceGLX_impl_libva;
++        break;
++    case 1:
++        /* Add bind functions based on vaCopySurfaceGLX() */
++        /* XXX: override vaSyncSurfaceGLX()? */
++        vtable->vaCreateSurfaceGLX      = vaCreateSurfaceGLX_impl_driver;
++        vtable->vaDestroySurfaceGLX     = vaDestroySurfaceGLX_impl_driver;
++        vtable->vaAssociateSurfaceGLX   = vaAssociateSurfaceGLX_impl_bind;
++        vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_bind;
++        vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_bind;
++        vtable->vaEndRenderSurfaceGLX   = vaEndRenderSurfaceGLX_impl_bind;
++        vtable->vaSyncSurfaceGLX        = vaSyncSurfaceGLX_impl_driver;
++        vtable->vaCopySurfaceGLX        = vaCopySurfaceGLX_impl_driver;
++        break;
++    case 2:
++        /* Add copy function based on vaBeginRenderSurfaceGLX() et al. */
++        needs_fbo = 1;
++        vtable->vaCreateSurfaceGLX      = vaCreateSurfaceGLX_impl_driver;
++        vtable->vaDestroySurfaceGLX     = vaDestroySurfaceGLX_impl_driver;
++        vtable->vaAssociateSurfaceGLX   = vaAssociateSurfaceGLX_impl_driver;
++        vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_driver;
++        vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_driver;
++        vtable->vaEndRenderSurfaceGLX   = vaEndRenderSurfaceGLX_impl_driver;
++        vtable->vaSyncSurfaceGLX        = vaSyncSurfaceGLX_impl_driver;
++        vtable->vaCopySurfaceGLX        = vaCopySurfaceGLX_impl_libva;
++        break;
++    case 3:
++        /* Keep driver bind & copy functions */
++        vtable->vaCreateSurfaceGLX      = vaCreateSurfaceGLX_impl_driver;
++        vtable->vaDestroySurfaceGLX     = vaDestroySurfaceGLX_impl_driver;
++        vtable->vaAssociateSurfaceGLX   = vaAssociateSurfaceGLX_impl_driver;
++        vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_driver;
++        vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_driver;
++        vtable->vaEndRenderSurfaceGLX   = vaEndRenderSurfaceGLX_impl_driver;
++        vtable->vaSyncSurfaceGLX        = vaSyncSurfaceGLX_impl_driver;
++        vtable->vaCopySurfaceGLX        = vaCopySurfaceGLX_impl_driver;
++        break;
++    default:
++        /* Fatal error: this cannot happen */
++        assert(0);
++        return VA_STATUS_ERROR_UNKNOWN;
++    }
++
++    glx_ctx->has_tfp = 0;
++    glx_ctx->use_tfp = 0;
++    glx_ctx->has_fbo = 0;
++    glx_ctx->use_fbo = 0;
++
++    if (needs_tfp) {
++        glx_ctx->has_tfp = check_tfp_extensions(ctx);
++        if (!glx_ctx->has_tfp || !load_tfp_extensions(ctx))
++            return VA_STATUS_ERROR_UNIMPLEMENTED;
++        glx_ctx->use_tfp = 1;
++    }
++
++    if (needs_fbo) {
++        glx_ctx->has_fbo = check_fbo_extensions(ctx);
++        if (!glx_ctx->has_fbo || !load_fbo_extensions(ctx))
++            return VA_STATUS_ERROR_UNIMPLEMENTED;
++        glx_ctx->use_fbo = 1;
++    }
++
++    glx_ctx->is_initialized = 1;
++    return VA_STATUS_SUCCESS;
++}
+diff --git a/src/glx/va_glx_impl.h b/src/glx/va_glx_impl.h
+new file mode 100644
+index 0000000..977bfcc
+--- /dev/null
++++ b/src/glx/va_glx_impl.h
+@@ -0,0 +1,46 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef VA_GLX_IMPL_H
++#define VA_GLX_IMPL_H
++
++/**
++ * Initialize GLX driver context
++ *
++ * @param[in]  ctx        the VA driver context
++ * @return VA_STATUS_SUCCESS if successful
++ */
++VAStatus va_glx_init_context(VADriverContextP ctx)
++    ATTRIBUTE_HIDDEN;
++
++/** Create VA/GLX surface */
++VASurfaceGLXP
++va_glx_create_surface(VADriverContextP ctx, GLenum target, GLuint texture)
++    ATTRIBUTE_HIDDEN;
++
++/** Destroy VA/GLX surface */
++void va_glx_destroy_surface(VADriverContextP ctx, VASurfaceGLXP *pSurfaceGLX)
++    ATTRIBUTE_HIDDEN;
++
++#endif /* VA_GLX_IMPL_H */
+diff --git a/src/glx/va_glx_private.h b/src/glx/va_glx_private.h
+new file mode 100644
+index 0000000..8658ad3
+--- /dev/null
++++ b/src/glx/va_glx_private.h
+@@ -0,0 +1,98 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef VA_GLX_PRIVATE_H
++#define VA_GLX_PRIVATE_H
++
++#include "config.h"
++#include "va.h"
++#include "va_backend.h"
++#include "va_x11.h"
++#include "va_glx.h"
++
++#if GLX_GLXEXT_VERSION < 18
++typedef void (*PFNGLXBINDTEXIMAGEEXTPROC)(Display *, GLXDrawable, int, const int *);
++typedef void (*PFNGLXRELEASETEXIMAGEEXTPROC)(Display *, GLXDrawable, int);
++#endif
++
++typedef struct VAOpenGLVTable *VAOpenGLVTableP;
++
++struct VAOpenGLVTable {
++    PFNGLXBINDTEXIMAGEEXTPROC           glx_bind_tex_image;
++    PFNGLXRELEASETEXIMAGEEXTPROC        glx_release_tex_image;
++    PFNGLGENFRAMEBUFFERSEXTPROC         gl_gen_framebuffers;
++    PFNGLDELETEFRAMEBUFFERSEXTPROC      gl_delete_framebuffers;
++    PFNGLBINDFRAMEBUFFEREXTPROC         gl_bind_framebuffer;
++    PFNGLGENRENDERBUFFERSEXTPROC        gl_gen_renderbuffers;
++    PFNGLDELETERENDERBUFFERSEXTPROC     gl_delete_renderbuffers;
++    PFNGLBINDRENDERBUFFEREXTPROC        gl_bind_renderbuffer;
++    PFNGLRENDERBUFFERSTORAGEEXTPROC     gl_renderbuffer_storage;
++    PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC gl_framebuffer_renderbuffer;
++    PFNGLFRAMEBUFFERTEXTURE2DEXTPROC    gl_framebuffer_texture_2d;
++    PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC  gl_check_framebuffer_status;
++};
++
++typedef struct VADisplayContextGLX *VADisplayContextGLXP;
++typedef struct VADriverContextGLX  *VADriverContextGLXP;
++typedef struct VASurfaceGLX        *VASurfaceGLXP;
++typedef struct VADriverVTableGLX   *VADriverVTableGLXP;
++
++struct VADisplayContextGLX {
++    void (*vaDestroy)(VADisplayContextP ctx);
++};
++
++#define VA_DRIVER_CONTEXT_GLX(ctx) ((VADriverContextGLXP)((ctx)->glx))
++
++struct VADriverContextGLX {
++    struct VADriverVTableGLX    vtable;
++    struct VAOpenGLVTable       gl_vtable;
++    unsigned int                is_initialized  : 1;
++    unsigned int                has_copy        : 1;
++    unsigned int                has_bind        : 1;
++    unsigned int                has_tfp         : 1;
++    unsigned int                has_fbo         : 1;
++    unsigned int                use_tfp         : 1;
++    unsigned int                use_fbo         : 1;
++};
++
++/** Unique VASurfaceGLX identifier */
++#define VA_SURFACE_GLX_MAGIC VA_FOURCC('V','A','G','L')
++
++struct VASurfaceGLX {
++    uint32_t     magic;         ///< Magic number identifying a VASurfaceGLX
++    GLenum       target;        ///< GL target to which the texture is bound
++    GLuint       texture;       ///< GL texture
++    VASurfaceID  surface;       ///< Associated VA surface
++    unsigned int width;
++    unsigned int height;
++    int          is_bound;
++    Pixmap       pixmap;
++    GLXPixmap    glx_pixmap;
++    GLuint       fbo;
++    GLuint       fbo_buffer;
++    GLuint       fbo_texture;
++    void        *priv;          ///< Private VA/GLX surface data from driver
++};
++
++#endif /* VA_GLX_PRIVATE_H */
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/390_compat.base.patch b/meta-emenlow/packages/libva/libva-0.31.0/390_compat.base.patch
new file mode 100644
index 0000000000..f2e0d61b0d
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/390_compat.base.patch
@@ -0,0 +1,135 @@
+commit 483bc9e67afa9bcd8f99f08a74a78e7dfad4651f
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jul 2 09:24:04 2009 +0000
+
+    Fix make dist (va_compat_template.h).
+
+commit 0e0da9ea861f14e8129767dbf6f11be5c051d85f
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Wed Jun 24 11:40:56 2009 +0000
+
+    Add compatibility layer with original libva 0.29.
+
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -44,7 +44,7 @@ libva_x11_la_DEPENDENCIES = $(libvacorelib)
+ libva_x11_la_DEPENDENCIES = $(libvacorelib)
+ 
+ 
+-libva_la_SOURCES = va.c
++libva_la_SOURCES = va.c va_compat.c
+ 
+ libvaincludedir = ${includedir}/va
+ libvainclude_HEADERS = va.h va_backend.h va_version.h
+@@ -53,4 +53,8 @@ DISTCLEANFILES = \
+ 	va_version.h
+ 
+ EXTRA_DIST = \
+-	va_version.h.in
++	va_version.h.in \
++	va_compat.h \
++	va_compat_template.h
++
++va_compat.c: va_compat_template.h
+--- a/src/va.c
++++ b/src/va.c
+@@ -25,6 +25,7 @@
+ #define _GNU_SOURCE 1
+ #include "va.h"
+ #include "va_backend.h"
++#include "va_compat.h"
+ 
+ #include <assert.h>
+ #include <stdarg.h>
+@@ -41,6 +42,8 @@
+ 
+ #define DRIVER_INIT_FUNC	"__vaDriverInit_0_31"
+ #define DRIVER_INIT_FUNC_SDS	"__vaDriverInit_0_31_sds"
++#define DRIVER_INIT_FUNC_0_29	"__vaDriverInit_0_29"
++#define DRIVER_INIT_FUNC_0_30	"__vaDriverInit_0_30"
+ 
+ #define DRIVER_EXTENSION	"_drv_video.so"
+ 
+@@ -168,11 +171,22 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
+         else
+         {
+             VADriverInit init_func;
+-            init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC);
++            int compat_version = 0;
++            /* First, try SDS extensions (VDPAU and XvBA backends) */
++            init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_SDS);
+             if (!init_func)
+             {
+-                /* Then try SDS extensions (VDPAU and XvBA backends) */
+-                init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_SDS);
++                /* Otherwise, we need the compatibility layer for some buffers */
++                init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC);
++                compat_version = VA_MINOR_VERSION;
++                if (!init_func) {
++                    init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_0_29);
++                    compat_version = 29;
++                }
++                if (!init_func) {
++                    init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_0_30);
++                    compat_version = 30;
++                }
+             }
+             if (!init_func)
+             {
+@@ -181,7 +195,36 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name)
+             }
+             else
+             {
+-                vaStatus = (*init_func)(ctx);
++                struct VADriverContext_0_29 ctx_0_29;
++                struct VADriverContext_0_30 ctx_0_30;
++                void *compat_ctx = NULL;
++
++                switch (compat_version) {
++                case 29:
++                    compat_ctx           = &ctx_0_29;
++                    ctx_0_29.pDriverData = NULL;
++                    ctx_0_29.x11_dpy     = ctx->x11_dpy;
++                    ctx_0_29.x11_screen  = ctx->x11_screen;
++                    break;
++                case 30:
++                    compat_ctx           = &ctx_0_30;
++                    ctx_0_30.pDriverData = NULL;
++                    ctx_0_30.x11_dpy     = ctx->x11_dpy;
++                    ctx_0_30.x11_screen  = ctx->x11_screen;
++                    break;
++                case VA_MINOR_VERSION:
++                    compat_ctx           = ctx;
++                    break;
++                default:
++                    ASSERT(compat_version == 0);
++                    vaStatus = VA_STATUS_ERROR_UNKNOWN;
++                    break;
++                }
++
++                vaStatus = (*init_func)(compat_ctx ? compat_ctx : ctx);
++
++                if (VA_STATUS_SUCCESS == vaStatus)
++                    vaStatus = va_compat_init(dpy, compat_version, compat_ctx);
+ 
+                 if (VA_STATUS_SUCCESS == vaStatus)
+                 {
+@@ -377,6 +422,8 @@ VAStatus vaTerminate (
+       old_ctx->handle = NULL;
+   }
+ 
++  va_compat_fini(dpy);
++
+   if (VA_STATUS_SUCCESS == vaStatus)
+       pDisplayContext->vaDestroy(pDisplayContext);
+   return vaStatus;
+--- a/src/va_backend.h
++++ b/src/va_backend.h
+@@ -426,6 +426,7 @@ struct VADriverContext
+     
+     void *dri_state;
+     void *glx;                          /* opaque for GLX code */
++    void *compat;			/* opaque for compat code */
+ };
+ 
+ struct VADisplayContext
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/391_compat.patch b/meta-emenlow/packages/libva/libva-0.31.0/391_compat.patch
new file mode 100644
index 0000000000..5e09d22b82
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/391_compat.patch
@@ -0,0 +1,3273 @@
+commit 2e7aa803a8547dfcde6e97ae2bb4a8bbdbb2634e
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Mon Nov 23 12:22:09 2009 +0000
+
+    Update compat code for VDPAU/MPEG-4 additions.
+
+commit 30808b39d82cbf0c185052a2d2d5ed8a5fc065d1
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Sep 10 14:01:57 2009 +0000
+
+    Update compatibility glue for VASliceParameterBufferMPEG2.slice_horizontal_position addition.
+
+commit 27faf49366602637da223f3dc5f30ce4d6d72070
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Wed Sep 2 15:06:20 2009 +0000
+
+    Fix vaSyncSurface() compat code for VA API < 0.31 drivers.
+
+commit dc33a3e28b38b7d579ab768899963cf9b0d38677
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Wed Sep 2 12:28:43 2009 +0000
+
+    Fix check for 0.30 modules.
+
+commit bd913971bd9e7460b454513b006e16c18136625e
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Wed Sep 2 11:58:08 2009 +0000
+
+    Update for VA API 0.31.
+
+commit 9cc7f89d3cc0238ab5b3a47c316e261e06a16634
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jul 2 15:55:48 2009 +0000
+
+    Fix VAEncSliceParameterBuffer thunk.
+
+commit 483bc9e67afa9bcd8f99f08a74a78e7dfad4651f
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jul 2 09:24:04 2009 +0000
+
+    Fix make dist (va_compat_template.h).
+
+commit 7f41b22366142c4e476fbae929ad343dc33af3a4
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jun 25 14:05:57 2009 +0000
+
+    Drop superfluous semi-colon.
+
+commit dcc75aae23fc8f653179b6a331f4021acd6775fd
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jun 25 13:53:26 2009 +0000
+
+    Fix check for 0.30 modules.
+
+commit b34512e74ac4150a3f8ee4abe4fa5b17907f8869
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jun 25 13:17:48 2009 +0000
+
+    Fix vaTerminate() thunk.
+
+commit 3b006d1ac66429f6b8ffff00ce60e1e47a32c02c
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jun 25 12:48:22 2009 +0000
+
+    Cosmetics.
+
+commit 452295d5ac34643f8a316491888c3900f12c5bff
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Thu Jun 25 12:18:48 2009 +0000
+
+    Fix compatibility with 0.29 modules.
+
+commit 0e0da9ea861f14e8129767dbf6f11be5c051d85f
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Wed Jun 24 11:40:56 2009 +0000
+
+    Add compatibility layer with original libva 0.29.
+
+diff --git a/src/va_compat.c b/src/va_compat.c
+new file mode 100644
+index 0000000..0bd7385
+--- /dev/null
++++ b/src/va_compat.c
+@@ -0,0 +1,1171 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#include "config.h"
++#include "va.h"
++#include "va_compat.h"
++#include "va_backend.h"
++#include <string.h>
++#include <alloca.h>
++#include <assert.h>
++
++#define CTX(dpy)        (((VADisplayContextP)dpy)->pDriverContext)
++#define COMPAT_CTX(ctx) ((VACompatContextP)(ctx)->compat)
++#define ASSERT		assert
++
++/* Invoke the normal VA API entry-point. This one can be replaced with
++   one of the va_compat_*() functions */
++#define VA_INVOKE(FUNC, CTX, ...) \
++    (CTX)->vtable.FUNC(CTX, __VA_ARGS__)
++
++/* Invoke the real VA API entry-point. That is, the driver's function */
++#define VA_INVOKE_COMPAT_ARGS(CTX, ...) \
++    (COMPAT_CTX(CTX)->compat_ctx, __VA_ARGS__)
++#define VA_INVOKE_COMPAT(FUNC, CTX, ...) \
++    COMPAT_CTX(CTX)->vtable.FUNC VA_INVOKE_COMPAT_ARGS(CTX, __VA_ARGS__)
++
++typedef struct VACompatContext *VACompatContextP;
++
++typedef VAStatus (*VABufferTranslateFunc)(VACompatContextP ctx, void *dest, const void *src);
++
++typedef enum {
++    VA_DRIVER_ID_UNKNOWN,
++    VA_DRIVER_ID_POULSBO,
++    VA_DRIVER_ID_IEGD
++} VADriverID;
++
++typedef struct {
++    VABufferID                  id;
++    VABufferType                type;
++    unsigned int                size;
++    unsigned int                num_elements;
++    unsigned char              *data;
++    VABufferTranslateFunc       translate;
++    VABufferID                  compat_id;
++    unsigned int                compat_size;
++    unsigned char              *compat_data;
++    unsigned int                map_count;
++} VABufferCompat;
++
++typedef struct VAContextMap *VAContextMapP;
++typedef struct VAContextMap {
++    VASurfaceID                 surface;
++    VAContextID                 context;
++    VAContextMapP               next;
++} VAContextMap;
++
++typedef struct {
++    VAStatus (*vaTerminate)(void *);
++    VAStatus (*vaQueryConfigProfiles)(void *, VAProfile *, int *);
++    VAStatus (*vaQueryConfigEntrypoints)(void *, VAProfile, VAEntrypoint *, int *);
++    VAStatus (*vaGetConfigAttributes)(void *, VAProfile, VAEntrypoint, VAConfigAttrib *, int);
++    VAStatus (*vaCreateConfig)(void *, VAProfile, VAEntrypoint, VAConfigAttrib *, int, VAConfigID *);
++    VAStatus (*vaDestroyConfig)(void *, VAConfigID);
++    VAStatus (*vaQueryConfigAttributes)(void *, VAConfigID, VAProfile *, VAEntrypoint *, VAConfigAttrib *, int *);
++    VAStatus (*vaCreateSurfaces)(void *, int, int, int, int, VASurfaceID *);
++    VAStatus (*vaDestroySurfaces)(void *, VASurfaceID *, int);
++    VAStatus (*vaCreateContext)(void *, VAConfigID, int, int, int, VASurfaceID *, int, VAContextID *);
++    VAStatus (*vaDestroyContext)(void *, VAContextID);
++    VAStatus (*vaCreateBuffer)(void *, VAContextID, VABufferType, unsigned int, unsigned int, void *, VABufferID *);
++    VAStatus (*vaBufferSetNumElements)(void *, VABufferID, unsigned int);
++    VAStatus (*vaMapBuffer)(void *, VABufferID, void **);
++    VAStatus (*vaUnmapBuffer)(void *, VABufferID);
++    VAStatus (*vaDestroyBuffer)(void *, VABufferID);
++    VAStatus (*vaBeginPicture)(void *, VAContextID, VASurfaceID);
++    VAStatus (*vaRenderPicture)(void *, VAContextID, VABufferID *, int);
++    VAStatus (*vaEndPicture)(void *, VAContextID);
++    VAStatus (*vaSyncSurface_pre31)(void *, VAContextID, VASurfaceID);
++    VAStatus (*vaQuerySurfaceStatus)(void *, VASurfaceID, VASurfaceStatus *);
++    VAStatus (*vaPutSurface)(void *, VASurfaceID, unsigned long, short, short, unsigned short, unsigned short, short, short, unsigned short, unsigned short, VARectangle *, unsigned int, unsigned int);
++    VAStatus (*vaQueryImageFormats)(void *, VAImageFormat *, int *);
++    VAStatus (*vaCreateImage)(void *, VAImageFormat *, int, int, VAImage *);
++    VAStatus (*vaDeriveImage)(void *, VASurfaceID, VAImage *);
++    VAStatus (*vaDestroyImage)(void *, VAImageID);
++    VAStatus (*vaSetImagePalette)(void *, VAImageID, unsigned char *);
++    VAStatus (*vaGetImage)(void *, VASurfaceID, int, int, unsigned int, unsigned int, VAImageID);
++    VAStatus (*vaPutImage_pre31)(void *, VASurfaceID, VAImageID, int, int, unsigned int, unsigned int, int, int);
++    VAStatus (*vaPutImage2_pre31)(void *, VASurfaceID, VAImageID, int, int, unsigned int, unsigned int, int, int, unsigned int, unsigned int);
++    VAStatus (*vaQuerySubpictureFormats)(void *, VAImageFormat *, unsigned int *, unsigned int *);
++    VAStatus (*vaCreateSubpicture)(void *, VAImageID, VASubpictureID *);
++    VAStatus (*vaDestroySubpicture)(void *, VASubpictureID);
++    VAStatus (*vaSetSubpictureImage)(void *, VASubpictureID, VAImageID);
++    VAStatus (*vaSetSubpictureChromakey)(void *, VASubpictureID, unsigned int, unsigned int, unsigned int);
++    VAStatus (*vaSetSubpictureGlobalAlpha)(void *, VASubpictureID, float);
++    VAStatus (*vaAssociateSubpicture_pre31)(void *, VASubpictureID, VASurfaceID *, int, short, short, short, short, unsigned short, unsigned short, unsigned int);
++    VAStatus (*vaAssociateSubpicture2_pre31)(void *, VASubpictureID, VASurfaceID *, int, short, short, unsigned short, unsigned short, short, short, unsigned short, unsigned short, unsigned int);
++    VAStatus (*vaDeassociateSubpicture)(void *, VASubpictureID, VASurfaceID *, int);
++    VAStatus (*vaQueryDisplayAttributes)(void *, VADisplayAttribute *, int *);
++    VAStatus (*vaGetDisplayAttributes)(void *, VADisplayAttribute *, int);
++    VAStatus (*vaSetDisplayAttributes)(void *, VADisplayAttribute *, int);
++
++    /* 0.29 hooks */
++    VAStatus (*vaSetSubpicturePalette)(void *, VASubpictureID, unsigned char *);
++    VAStatus (*vaDbgCopySurfaceToBuffer)(void *, VASurfaceID, void **, unsigned int *);
++
++    /* 0.30 hooks */
++    VAStatus (*vaCreateSurfaceFromCIFrame)(void *, unsigned long, VASurfaceID *);
++    VAStatus (*vaCreateSurfaceFromV4L2Buf)(void *, int, struct v4l2_format *, struct v4l2_buffer *, VASurfaceID *);
++    VAStatus (*vaCopySurfaceToBuffer)(void *, VASurfaceID, unsigned int *, unsigned int *, unsigned int *, unsigned int *, unsigned int *, unsigned int *, unsigned int *, void **);
++
++    /* 0.31 hooks */
++    VAStatus (*vaPutImage)(void *, VASurfaceID, VAImageID, int, int, unsigned int, unsigned int, int, int, unsigned int, unsigned int);
++    VAStatus (*vaAssociateSubpicture)(void *, VASubpictureID, VASurfaceID *, int, short, short, unsigned short, unsigned short, short, short, unsigned short, unsigned short, unsigned int);
++    VAStatus (*vaSyncSurface)(void *, VASurfaceID);
++} VACompatDriverVTable;
++
++typedef struct VACompatContext {
++    VABufferCompat             *buffers;
++    unsigned int                buffers_count_max;
++    unsigned int                compat_version;
++    void                       *compat_ctx;
++    VACompatDriverVTable        vtable;                 /* original vtable */
++    VADriverID                  driver_id;
++    char                       *driver_name;
++    VAContextMapP               context_map;
++    VAContextMapP               last_context_map_match;
++    unsigned int                skip_frame : 1;
++} VACompatContext;
++
++#define COMPAT_MAJOR 0
++#define COMPAT_MINOR 29
++#include "va_compat_template.h"
++
++#define COMPAT_MAJOR 0
++#define COMPAT_MINOR 30
++#include "va_compat_template.h"
++
++#define COMPAT_MAJOR 0
++#define COMPAT_MINOR 31
++#include "va_compat_template.h"
++
++static inline int va_IsIntelBuffer(VADriverContextP ctx, VABufferID id)
++{
++    VACompatContextP compat = ctx->compat;
++
++    if (compat->driver_id == VA_DRIVER_ID_POULSBO) {
++        /* There were only Intel implementations for VA API. Besides, the
++           returned buffer IDs had the following format [ 0 BASE ID ] where
++           BASE is the 7-bit value 0x04 and ID an index into the heap of
++           objects */
++        return (id & 0x7f000000) == 0x04000000;
++    }
++
++    if (compat->driver_id == VA_DRIVER_ID_IEGD) {
++        /* XXX: there is no means to differentiate the buffers, they
++           are linearly generated (IEGD 10.0 build 1335) */
++        return 1;
++    }
++
++    return 0;
++}
++
++static VAContextMapP va_context_map_lookup_p(
++    VACompatContextP    ctx,
++    VASurfaceID         surface
++)
++{
++    VAContextMapP m = ctx->context_map;
++
++    while (m) {
++        if (m->surface == surface)
++            return m;
++        m = m->next;
++    }
++    return NULL;
++}
++
++static VAContextID va_context_map_lookup(
++    VACompatContextP    ctx,
++    VASurfaceID         surface
++)
++{
++    VAContextMapP m;
++
++    /* Lookup in cached */
++    m = ctx->last_context_map_match;
++    if (m && m->surface == surface)
++        return m->context;
++
++    /* Full (slow) lookup */
++    m = va_context_map_lookup_p(ctx, surface);
++    if (m) {
++        ctx->last_context_map_match = m;
++        return m->context;
++    }
++    return VA_INVALID_ID;
++}
++
++static void va_context_map_add(
++    VACompatContextP    ctx,
++    VAContextID         context,
++    VASurfaceID         surface
++)
++{
++    VAContextMapP m;
++
++    /* Update existing entry */
++    m = va_context_map_lookup_p(ctx, surface);
++    if (m) {
++        m->context = context;
++        return;
++    }
++
++    /* Create new mapping */
++    m = malloc(sizeof(*m));
++    ASSERT(m);
++    if (m) {
++        m->surface = surface;
++        m->context = context;
++        m->next    = ctx->context_map;
++        ctx->context_map = m;
++    }
++}
++
++static void va_context_map_remove(
++    VACompatContextP    ctx,
++    VAContextID         context
++)
++{
++    VAContextMapP p = NULL;
++    VAContextMapP m = ctx->context_map;
++    VAContextMapP d;
++
++    while (m) {
++        if (m->context == context) {
++            d = m;
++
++            /* Unlink current node */
++            if (p)
++                p->next = m->next;
++            else
++                ctx->context_map = m->next;
++            m = m->next;
++
++            /* Reset cache */
++            if (ctx->last_context_map_match == d)
++                ctx->last_context_map_match = NULL;
++
++            free(d);
++        }
++        else {
++            p = m;
++            m = m->next;
++        }
++    }
++}
++
++static VABufferCompat *va_GetBufferCompat (
++    VADriverContextP ctx,
++    VABufferID id
++)
++{
++    VACompatContextP compat = ctx->compat;
++    int index;
++
++    if (!va_IsIntelBuffer(ctx, id))
++        return NULL;
++
++    index = id & 0x00ffffff;
++    if (index >= compat->buffers_count_max)
++        return NULL;
++
++    if (compat->buffers[index].id != id)
++        return NULL;
++
++    return &compat->buffers[index];
++}
++
++static VAStatus va_TranslateBufferCompat (
++    VADriverContextP ctx,
++    VABufferCompat *compat_buffer
++)
++{
++    VAStatus status;
++    unsigned char *src, *dest;
++    int i;
++
++    status = VA_INVOKE(vaMapBuffer, ctx, compat_buffer->id, (void **)&src);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    ASSERT(compat_buffer->data);
++    ASSERT(src == compat_buffer->data);
++    ASSERT(compat_buffer->compat_data);
++    dest = compat_buffer->compat_data;
++    for (i = 0; i < compat_buffer->num_elements; i++)
++    {
++        /* XXX: check errors */
++        status = compat_buffer->translate(ctx->compat, dest, src);
++
++        src   += compat_buffer->size;
++        dest  += compat_buffer->compat_size;
++    }
++
++    return VA_INVOKE(vaUnmapBuffer, ctx, compat_buffer->id);
++}
++
++static VAStatus va_CreateBufferCompat (
++    VADriverContextP ctx,
++    VAContextID context,
++    VABufferID id,
++    VABufferType type,
++    unsigned int size,
++    unsigned int num_elements,
++    unsigned int compat_size,
++    VABufferTranslateFunc translate_func
++)
++{
++    VACompatContextP compat = ctx->compat;
++    VABufferCompat *compat_buffer;
++    int index;
++
++    if (!va_IsIntelBuffer(ctx, id))
++        return VA_STATUS_ERROR_INVALID_BUFFER;
++    index = id & 0x00ffffff;
++
++    /* XXX: this allocation strategy is not really space efficient... */
++    if (index >= compat->buffers_count_max)
++    {
++        compat->buffers_count_max = index + 1;
++        compat->buffers = realloc(compat->buffers,
++                                  (compat->buffers_count_max *
++                                   sizeof(VABufferCompat)));
++        if (compat->buffers == NULL)
++            return VA_STATUS_ERROR_ALLOCATION_FAILED;
++    }
++
++    compat_buffer = &compat->buffers[index];
++    compat_buffer->id           = id;
++    compat_buffer->type         = type;
++    compat_buffer->size         = size;
++    compat_buffer->num_elements = num_elements;
++    compat_buffer->data         = NULL;
++    compat_buffer->translate    = translate_func;
++    compat_buffer->compat_size  = compat_size;
++    compat_buffer->compat_data  = NULL;
++    compat_buffer->map_count    = 0;
++
++    return VA_INVOKE_COMPAT(vaCreateBuffer,
++                            ctx,
++                            context,
++                            type,
++                            compat_size,
++                            num_elements,
++                            NULL,
++                            &compat_buffer->compat_id);
++}
++
++static VAStatus va_DestroyBufferCompat (
++    VADriverContextP ctx,
++    VABufferID id
++)
++{
++    VABufferCompat *compat_buffer;
++    VAStatus status;
++
++    if ((compat_buffer = va_GetBufferCompat(ctx, id)) == NULL)
++        return VA_STATUS_SUCCESS;
++
++    /* Force unmap if there were more maps than unmaps */
++    if (compat_buffer->map_count > 1)
++        compat_buffer->map_count = 1;
++    if (compat_buffer->map_count > 1)
++    {
++        if ((status = VA_INVOKE(vaUnmapBuffer, ctx, id)) != VA_STATUS_SUCCESS)
++            return status;
++    }
++
++    compat_buffer->id = 0;
++    return VA_INVOKE_COMPAT(vaDestroyBuffer, ctx, compat_buffer->compat_id);
++}
++
++static VAStatus va_compat_CreateBuffer (
++    VADriverContextP ctx,
++    VAContextID context,	/* in */
++    VABufferType type,		/* in */
++    unsigned int size,		/* in */
++    unsigned int num_elements,	/* in */
++    void *data,			/* in */
++    VABufferID *buf_id		/* out */
++)
++{
++    VABufferTranslateFunc translate_func = NULL;
++    unsigned int compat_size = 0;
++    VAStatus status;
++
++    status = VA_INVOKE_COMPAT(vaCreateBuffer,
++                              ctx,
++                              context,
++                              type,
++                              size,
++                              num_elements,
++                              data,
++                              buf_id);
++
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++#define INIT_TRANSLATE_FUNC_(STRUCT, MAJOR, MINOR) do {                 \
++    translate_func = va_compat_translate_VA##STRUCT##_##MAJOR##_##MINOR; \
++    compat_size = sizeof(VA##STRUCT##_##MAJOR##_##MINOR);               \
++} while (0)
++#define INIT_TRANSLATE_FUNC(BUFFER, CODEC, MAJOR, MINOR) \
++    INIT_TRANSLATE_FUNC_(BUFFER##Buffer##CODEC, MAJOR, MINOR)
++
++    /* XXX: this assumes all structures have different sizes from each other */
++    switch (size) {
++    case sizeof(VAPictureParameterBufferH264):
++        if (type == VAPictureParameterBufferType && ctx->version_major == 0)
++        {
++            switch (ctx->version_minor) {
++            case 29: INIT_TRANSLATE_FUNC(PictureParameter,H264, 0,29); break;
++            case 30: INIT_TRANSLATE_FUNC(PictureParameter,H264, 0,30); break;
++            }
++        }
++        break;
++    case sizeof(VASliceParameterBufferH264):
++        if (type == VASliceParameterBufferType && ctx->version_major == 0)
++        {
++            switch (ctx->version_minor) {
++            case 29: INIT_TRANSLATE_FUNC(SliceParameter,H264, 0,29); break;
++            case 30: INIT_TRANSLATE_FUNC(SliceParameter,H264, 0,30); break;
++            }
++        }
++        break;
++    case sizeof(VAPictureParameterBufferVC1):
++        if (type == VAPictureParameterBufferType && ctx->version_major == 0)
++        {
++            switch (ctx->version_minor) {
++            case 29: INIT_TRANSLATE_FUNC(PictureParameter,VC1, 0,29); break;
++            case 30: INIT_TRANSLATE_FUNC(PictureParameter,VC1, 0,30); break;
++            }
++        }
++        break;
++    case sizeof(VAPictureParameterBufferMPEG2):
++        if (type == VAPictureParameterBufferType && ctx->version_major == 0)
++        {
++            switch (ctx->version_minor) {
++            case 29: INIT_TRANSLATE_FUNC(PictureParameter,MPEG2, 0,29); break;
++            case 30: INIT_TRANSLATE_FUNC(PictureParameter,MPEG2, 0,30); break;
++            }
++        }
++        break;
++    case sizeof(VASliceParameterBufferMPEG2):
++        if (type == VASliceParameterBufferType && ctx->version_major == 0)
++        {
++            switch (ctx->version_minor) {
++            case 29: INIT_TRANSLATE_FUNC(SliceParameter,MPEG2, 0,29); break;
++            case 30: INIT_TRANSLATE_FUNC(SliceParameter,MPEG2, 0,30); break;
++            }
++        }
++        break;
++    case sizeof(VAPictureParameterBufferMPEG4):
++        if (type == VAPictureParameterBufferType && ctx->version_major == 0)
++        {
++            switch (ctx->version_minor) {
++            case 29: INIT_TRANSLATE_FUNC(PictureParameter,MPEG4, 0,29); break;
++            case 30: INIT_TRANSLATE_FUNC(PictureParameter,MPEG4, 0,30); break;
++            case 31: INIT_TRANSLATE_FUNC(PictureParameter,MPEG4, 0,31); break;
++            }
++        }
++        break;
++    case sizeof(VAEncSliceParameterBuffer):
++        if (type == VAEncSliceParameterBufferType && ctx->version_major == 0)
++        {
++            switch (ctx->version_minor) {
++            case 30: INIT_TRANSLATE_FUNC_(EncSliceParameterBuffer, 0,30); break;
++            }
++        }
++        break;
++    }
++
++#undef INIT_TRANSLATE_FUNC
++
++    /* Create thunk */
++    if (buf_id && translate_func)
++    {
++        ASSERT(compat_size > 0);
++
++        status = va_CreateBufferCompat(ctx,
++                                       context,
++                                       *buf_id,
++                                       type,
++                                       size,
++                                       num_elements,
++                                       compat_size,
++                                       translate_func);
++    }
++
++    return status;
++}
++
++static VAStatus va_compat_BufferSetNumElements (
++    VADriverContextP ctx,
++    VABufferID buf_id,	/* in */
++    unsigned int num_elements /* in */
++)
++{
++    VABufferCompat *compat_buffer;
++    VAStatus status;
++
++    status = VA_INVOKE_COMPAT(vaBufferSetNumElements, ctx, buf_id, num_elements);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    if ((compat_buffer = va_GetBufferCompat(ctx, buf_id)) != NULL)
++    {
++        compat_buffer->num_elements = num_elements;
++        status = VA_INVOKE_COMPAT(vaBufferSetNumElements,
++                                  ctx,
++                                  compat_buffer->compat_id,
++                                  num_elements);
++    }
++
++    return status;
++}
++
++static VAStatus va_compat_DestroyBuffer (
++    VADriverContextP ctx,
++    VABufferID buffer_id
++)
++{
++    VAStatus status;
++    if ((status = va_DestroyBufferCompat(ctx, buffer_id)) != VA_STATUS_SUCCESS)
++        return status;
++
++    return VA_INVOKE_COMPAT(vaDestroyBuffer, ctx, buffer_id);
++}
++
++static VAStatus va_compat_MapBuffer (
++    VADriverContextP ctx,
++    VABufferID buf_id,	/* in */
++    void **pbuf 	/* out */
++)
++{
++    VABufferCompat *compat_buffer;
++    VAStatus status;
++
++    if ((compat_buffer = va_GetBufferCompat(ctx, buf_id)) == NULL)
++        return VA_INVOKE_COMPAT(vaMapBuffer, ctx, buf_id, pbuf);
++
++    if (compat_buffer->map_count++ == 0)
++    {
++        status = VA_INVOKE_COMPAT(vaMapBuffer, ctx, buf_id, (void **)&compat_buffer->data);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++
++        status = VA_INVOKE_COMPAT(vaMapBuffer, ctx, compat_buffer->compat_id, (void **)&compat_buffer->compat_data);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++    }
++
++    if (pbuf)
++        *pbuf = compat_buffer->data;
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus va_compat_UnmapBuffer (
++    VADriverContextP ctx,
++    VABufferID buf_id	/* in */
++)
++{
++    VABufferCompat *compat_buffer;
++    VAStatus status;
++
++    if ((compat_buffer = va_GetBufferCompat(ctx, buf_id)) == NULL)
++        return VA_INVOKE_COMPAT(vaUnmapBuffer, ctx, buf_id);
++
++    if (--compat_buffer->map_count == 0)
++    {
++        status = VA_INVOKE_COMPAT(vaUnmapBuffer, ctx, compat_buffer->compat_id);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++        compat_buffer->compat_data = NULL;
++
++        status = VA_INVOKE_COMPAT(vaUnmapBuffer, ctx, compat_buffer->id);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++        compat_buffer->data = NULL;
++    }
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus va_compat_BeginPicture (
++    VADriverContextP ctx,
++    VAContextID context,
++    VASurfaceID render_target
++)
++{
++    VACompatContextP compat = ctx->compat;
++    compat->skip_frame = 0;
++    return VA_INVOKE_COMPAT(vaBeginPicture, ctx, context, render_target);
++}
++
++static VAStatus va_compat_EndPicture (
++    VADriverContextP ctx,
++    VAContextID context
++)
++{
++    VACompatContextP compat = ctx->compat;
++    VAStatus status = VA_INVOKE_COMPAT(vaEndPicture, ctx, context);
++
++    /* Ignore errors if the HW decoder did not handle VC-1 skipped P-frames */
++    if (compat->skip_frame && status == VA_STATUS_ERROR_UNKNOWN)
++        status = VA_STATUS_SUCCESS;
++
++    return status;
++}
++
++static VAStatus va_compat_RenderPicture (
++    VADriverContextP ctx,
++    VAContextID context,
++    VABufferID *buffers,
++    int num_buffers
++)
++{
++    VACompatContextP compat = ctx->compat;
++    VABufferCompat *compat_buffer;
++    VABufferID *compat_buffer_ids;
++    VAStatus status;
++    int i, n;
++
++    if ((n = num_buffers) < 1)
++        n = 1;
++    compat_buffer_ids = alloca(n * sizeof(compat_buffer_ids[0]));
++
++    for (i = 0; i < num_buffers; i++)
++    {
++        if ((compat_buffer = va_GetBufferCompat(ctx, buffers[i])) == NULL)
++            compat_buffer_ids[i] = buffers[i];
++        else
++        {
++            status = va_TranslateBufferCompat(ctx, compat_buffer);
++            if (status != VA_STATUS_SUCCESS)
++                return status;
++            compat_buffer_ids[i] = compat_buffer->compat_id;
++        }
++    }
++
++    if (!compat->skip_frame)
++    {
++        status = VA_INVOKE_COMPAT(vaRenderPicture, ctx, context, compat_buffer_ids, num_buffers);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++    }
++
++    /* Buffers are automatically destroyed afterwards */
++    for (i = 0; i < num_buffers; i++)
++    {
++        if ((compat_buffer = va_GetBufferCompat(ctx, buffers[i])) != NULL)
++        {
++            status = VA_INVOKE_COMPAT(vaDestroyBuffer, ctx, compat_buffer->id);
++            if (status != VA_STATUS_SUCCESS)
++                return status;
++        }
++    }
++
++    return VA_STATUS_SUCCESS;
++}
++
++#define DEFINE_VTABLE_ENTRY_(RETVAL, PROC, ARGS, COMPAT_PROC, COMPAT_ARGS, COMPAT_PRE, COMPAT_POST) \
++static RETVAL va_compat_##PROC ARGS                                        \
++{                                                                          \
++    if (COMPAT_CTX(ctx)->vtable.va##COMPAT_PROC == NULL)                   \
++        return VA_STATUS_ERROR_OPERATION_FAILED;                           \
++    COMPAT_PRE;                                                            \
++    RETVAL ret = COMPAT_CTX(ctx)->vtable.va##COMPAT_PROC VA_INVOKE_COMPAT_ARGS COMPAT_ARGS; \
++    COMPAT_POST;                                                           \
++    return ret;                                                            \
++}
++
++#define DEFINE_VTABLE_ENTRY(RETVAL, PROC, DECL_ARGS, CALL_ARGS) \
++DEFINE_VTABLE_ENTRY_(RETVAL, PROC, DECL_ARGS, PROC, CALL_ARGS, {}, {})
++
++static VAStatus va_compat_Terminate(VADriverContextP ctx)
++{
++    if (COMPAT_CTX(ctx)->vtable.vaTerminate == NULL)
++        return VA_STATUS_ERROR_OPERATION_FAILED;
++    return COMPAT_CTX(ctx)->vtable.vaTerminate(COMPAT_CTX(ctx)->compat_ctx);
++}
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, QueryConfigProfiles,
++    (VADriverContextP ctx, VAProfile *profile_list, int *num_profiles),
++    (ctx, profile_list, num_profiles))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, QueryConfigEntrypoints,
++    (VADriverContextP ctx, VAProfile profile,
++     VAEntrypoint *entrypoint_list, int *num_entrypoints),
++    (ctx, profile, entrypoint_list, num_entrypoints))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, GetConfigAttributes,
++    (VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint,
++     VAConfigAttrib *attrib_list, int num_attribs),
++    (ctx, profile, entrypoint, attrib_list, num_attribs))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CreateConfig,
++    (VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint,
++     VAConfigAttrib *attrib_list, int num_attribs, VAConfigID *config_id),
++    (ctx, profile, entrypoint, attrib_list, num_attribs, config_id))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, DestroyConfig,
++    (VADriverContextP ctx, VAConfigID config_id),
++    (ctx, config_id))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, QueryConfigAttributes,
++    (VADriverContextP ctx, VAConfigID config_id, VAProfile *profile,
++     VAEntrypoint *entrypoint, VAConfigAttrib *attrib_list, int *num_attribs),
++    (ctx, config_id, profile, entrypoint, attrib_list, num_attribs))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CreateSurfaces,
++    (VADriverContextP ctx, int width, int height, int format,
++     int num_surfaces, VASurfaceID *surfaces),
++    (ctx, width, height, format, num_surfaces, surfaces))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, DestroySurfaces,
++    (VADriverContextP ctx, VASurfaceID *surface_list, int num_surfaces),
++    (ctx, surface_list, num_surfaces))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CreateContext,
++    (VADriverContextP ctx, VAConfigID config_id,
++     int picture_width, int picture_height, int flag,
++     VASurfaceID *render_targets, int num_render_targets, VAContextID *context),
++    (ctx, config_id, picture_width, picture_height, flag,
++     render_targets, num_render_targets, context))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, DestroyContext,
++    (VADriverContextP ctx, VAContextID context),
++    (ctx, context))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, SyncSurface,
++    (VADriverContextP ctx, VASurfaceID render_target),
++    (ctx, render_target))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, QuerySurfaceStatus,
++    (VADriverContextP ctx, VASurfaceID render_target, VASurfaceStatus *status),
++    (ctx, render_target, status))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, PutSurface,
++    (VADriverContextP ctx, VASurfaceID surface, Drawable draw,
++     short srcx, short srcy, unsigned short srcw, unsigned short srch,
++     short destx, short desty, unsigned short destw, unsigned short desth,
++     VARectangle *cliprects, unsigned int number_cliprects, unsigned int flags),
++    (ctx, surface, draw, srcx, srcy, srcw, srch, destx, desty, destw, desth,
++     cliprects, number_cliprects, flags))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, QueryImageFormats,
++    (VADriverContextP ctx, VAImageFormat *format_list, int *num_formats),
++    (ctx, format_list, num_formats))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CreateImage,
++    (VADriverContextP ctx, VAImageFormat *format,
++     int width, int height, VAImage *image),
++    (ctx, format, width, height, image))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, DeriveImage,
++    (VADriverContextP ctx, VASurfaceID surface, VAImage *image),
++    (ctx, surface, image))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, DestroyImage,
++    (VADriverContextP ctx, VAImageID image),
++    (ctx, image))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, SetImagePalette,
++    (VADriverContextP ctx, VAImageID image, unsigned char *palette),
++    (ctx, image, palette))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, GetImage,
++    (VADriverContextP ctx, VASurfaceID surface,
++     int x, int y, unsigned int width, unsigned int height, VAImageID image),
++    (ctx, surface, x, y, width, height, image))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, PutImage,
++    (VADriverContextP ctx, VASurfaceID surface, VAImageID image,
++     int srcx, int srcy, unsigned int srcw, unsigned int srch,
++     int destx, int desty, unsigned int destw, unsigned int desth),
++    (ctx, surface, image, srcx, srcy, srcw, srch, destx, desty, destw, desth))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, QuerySubpictureFormats,
++    (VADriverContextP ctx, VAImageFormat *format_list,
++     unsigned int *flags, unsigned int *num_formats),
++    (ctx, format_list, flags, num_formats))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CreateSubpicture,
++    (VADriverContextP ctx, VAImageID image, VASubpictureID *subpicture),
++    (ctx, image, subpicture))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, DestroySubpicture,
++    (VADriverContextP ctx, VASubpictureID subpicture),
++    (ctx, subpicture))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, SetSubpictureImage,
++    (VADriverContextP ctx, VASubpictureID subpicture, VAImageID image),
++    (ctx, subpicture, image))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, SetSubpictureChromakey,
++    (VADriverContextP ctx, VASubpictureID subpicture,
++     unsigned int chromakey_min,
++     unsigned int chromakey_max,
++     unsigned int chromakey_mask),
++    (ctx, subpicture, chromakey_min, chromakey_max, chromakey_mask))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, SetSubpictureGlobalAlpha,
++    (VADriverContextP ctx, VASubpictureID subpicture, float global_alpha),
++    (ctx, subpicture, global_alpha))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, AssociateSubpicture,
++    (VADriverContextP ctx, VASubpictureID subpicture,
++     VASurfaceID *target_surfaces, int num_surfaces,
++     short srcx, short srcy, unsigned short srcw, unsigned short srch,
++     short destx, short desty, unsigned short destw, unsigned short desth,
++     unsigned int flags),
++    (ctx, subpicture, target_surfaces, num_surfaces,
++     srcx, srcy, srcw, srch, destx, desty, destw, desth, flags))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, DeassociateSubpicture,
++    (VADriverContextP ctx, VASubpictureID subpicture,
++     VASurfaceID *target_surfaces, int num_surfaces),
++    (ctx, subpicture, target_surfaces, num_surfaces))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, QueryDisplayAttributes,
++    (VADriverContextP ctx, VADisplayAttribute *attr_list, int *num_attributes),
++    (ctx, attr_list, num_attributes))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, GetDisplayAttributes,
++    (VADriverContextP ctx, VADisplayAttribute *attr_list, int num_attributes),
++    (ctx, attr_list, num_attributes))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, SetDisplayAttributes,
++    (VADriverContextP ctx, VADisplayAttribute *attr_list, int num_attributes),
++    (ctx, attr_list, num_attributes))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CreateSurfaceFromCIFrame,
++    (VADriverContextP ctx, unsigned long frame_id, VASurfaceID *surface),
++    (ctx, frame_id, surface))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CreateSurfaceFromV4L2Buf,
++    (VADriverContextP ctx, int v4l2_fd,
++     struct v4l2_format *v4l2_fmt, struct v4l2_buffer *v4l2_buf,
++     VASurfaceID *surface),
++    (ctx, v4l2_fd, v4l2_fmt, v4l2_buf, surface))
++
++DEFINE_VTABLE_ENTRY(
++    VAStatus, CopySurfaceToBuffer,
++    (VADriverContextP ctx, VASurfaceID surface, unsigned int *fourcc,
++     unsigned int *luma_stride,
++     unsigned int *chroma_u_stride, unsigned int *chroma_v_stride,
++     unsigned int *luma_offset,
++     unsigned int *chroma_u_offset, unsigned int *chroma_v_offset,
++     void **buffer),
++    (ctx, surface, fourcc,
++     luma_stride, chroma_u_stride, chroma_v_stride,
++     luma_offset, chroma_u_offset, chroma_v_offset,
++     buffer))
++
++DEFINE_VTABLE_ENTRY_(
++    VAStatus, SyncSurface_pre31,
++    (VADriverContextP ctx, VASurfaceID render_target),
++    SyncSurface_pre31,
++    (ctx, va_context_map_lookup(COMPAT_CTX(ctx), render_target), render_target),
++    {}, {})
++
++DEFINE_VTABLE_ENTRY_(
++    VAStatus, PutImage_pre31,
++    (VADriverContextP ctx, VASurfaceID surface, VAImageID image,
++     int srcx, int srcy, unsigned int srcw, unsigned int srch,
++     int destx, int desty, unsigned int destw, unsigned int desth),
++    PutImage2_pre31,
++    (ctx, surface, image, srcx, srcy, srcw, srch, destx, desty, destw, desth),
++    {}, {})
++
++DEFINE_VTABLE_ENTRY_(
++    VAStatus, AssociateSubpicture_pre31,
++    (VADriverContextP ctx, VASubpictureID subpicture,
++     VASurfaceID *target_surfaces, int num_surfaces,
++     short srcx, short srcy, unsigned short srcw, unsigned short srch,
++     short destx, short desty, unsigned short destw, unsigned short desth,
++     unsigned int flags),
++    AssociateSubpicture2_pre31,
++    (ctx, subpicture, target_surfaces, num_surfaces,
++     srcx, srcy, srcw, srch, destx, desty, destw, desth, flags),
++    {}, {})
++
++DEFINE_VTABLE_ENTRY_(
++    VAStatus, CreateContext_pre31,
++    (VADriverContextP ctx, VAConfigID config_id,
++     int picture_width, int picture_height, int flag,
++     VASurfaceID *render_targets, int num_render_targets, VAContextID *context),
++    CreateContext,
++    (ctx, config_id, picture_width, picture_height, flag,
++     render_targets, num_render_targets, context),
++    {}, {
++        VACompatContextP const compat_ctx = COMPAT_CTX(ctx);
++        int i;
++        for (i = 0; i < num_render_targets; i++)
++            va_context_map_add(compat_ctx, *context, render_targets[i]);
++    })
++
++DEFINE_VTABLE_ENTRY_(
++    VAStatus, DestroyContext_pre31,
++    (VADriverContextP ctx, VAContextID context),
++    DestroyContext,
++    (ctx, context),
++    {}, { va_context_map_remove(COMPAT_CTX(ctx), context); })
++
++#undef DEFINE_VTABLE_ENTRY
++#undef DEFINE_VTABLE_ENTRY_
++
++static void va_compat_init_VADriverVTable(VADriverContextP ctx, int compat_version)
++{
++#define INIT_VTABLE_(CTX, DST_PROC, SRC_PROC) \
++    (CTX)->vtable.va##DST_PROC = va_compat_##SRC_PROC
++#define INIT_VTABLE(CTX, PROC) \
++    INIT_VTABLE_(CTX, PROC, PROC)
++
++    INIT_VTABLE(ctx, Terminate);
++    INIT_VTABLE(ctx, QueryConfigProfiles);
++    INIT_VTABLE(ctx, QueryConfigEntrypoints);
++    INIT_VTABLE(ctx, GetConfigAttributes);
++    INIT_VTABLE(ctx, CreateConfig);
++    INIT_VTABLE(ctx, DestroyConfig);
++    INIT_VTABLE(ctx, QueryConfigAttributes);
++    INIT_VTABLE(ctx, CreateSurfaces);
++    INIT_VTABLE(ctx, DestroySurfaces);
++    INIT_VTABLE(ctx, CreateContext);
++    INIT_VTABLE(ctx, DestroyContext);
++    INIT_VTABLE(ctx, CreateBuffer);
++    INIT_VTABLE(ctx, BufferSetNumElements);
++    INIT_VTABLE(ctx, MapBuffer);
++    INIT_VTABLE(ctx, UnmapBuffer);
++    INIT_VTABLE(ctx, DestroyBuffer);
++    INIT_VTABLE(ctx, BeginPicture);
++    INIT_VTABLE(ctx, RenderPicture);
++    INIT_VTABLE(ctx, EndPicture);
++    INIT_VTABLE(ctx, SyncSurface);
++    INIT_VTABLE(ctx, QuerySurfaceStatus);
++    INIT_VTABLE(ctx, PutSurface);
++    INIT_VTABLE(ctx, QueryImageFormats);
++    INIT_VTABLE(ctx, CreateImage);
++    INIT_VTABLE(ctx, DeriveImage);
++    INIT_VTABLE(ctx, DestroyImage);
++    INIT_VTABLE(ctx, SetImagePalette);
++    INIT_VTABLE(ctx, GetImage);
++    INIT_VTABLE(ctx, PutImage);
++    INIT_VTABLE(ctx, QuerySubpictureFormats);
++    INIT_VTABLE(ctx, CreateSubpicture);
++    INIT_VTABLE(ctx, DestroySubpicture);
++    INIT_VTABLE(ctx, SetSubpictureImage);
++    INIT_VTABLE(ctx, SetSubpictureChromakey);
++    INIT_VTABLE(ctx, SetSubpictureGlobalAlpha);
++    INIT_VTABLE(ctx, AssociateSubpicture);
++    INIT_VTABLE(ctx, DeassociateSubpicture);
++    INIT_VTABLE(ctx, QueryDisplayAttributes);
++    INIT_VTABLE(ctx, GetDisplayAttributes);
++    INIT_VTABLE(ctx, SetDisplayAttributes);
++    INIT_VTABLE(ctx, CreateSurfaceFromCIFrame);
++    INIT_VTABLE(ctx, CreateSurfaceFromV4L2Buf);
++    INIT_VTABLE(ctx, CopySurfaceToBuffer);
++
++    if (compat_version && compat_version < 31) {
++        INIT_VTABLE_(ctx, CreateContext,        CreateContext_pre31);
++        INIT_VTABLE_(ctx, DestroyContext,       DestroyContext_pre31);
++        INIT_VTABLE_(ctx, SyncSurface,          SyncSurface_pre31);
++        INIT_VTABLE_(ctx, PutImage,             PutImage_pre31);
++        INIT_VTABLE_(ctx, AssociateSubpicture,  AssociateSubpicture_pre31);
++    }
++
++#undef INIT_VTABLE
++#undef INIT_VTABLE__
++}
++
++VAStatus va_compat_init(VADisplay dpy, int compat_version, void *compat_ctx)
++{
++    VADisplayContextP pDisplayContext = (VADisplayContextP)dpy;
++    VADriverContextP ctx = CTX(dpy);
++    VADriverContextP_0_29 ctx_0_29;
++    VADriverContextP_0_30 ctx_0_30;
++    VACompatContextP compat;
++    VAStatus status;
++    char *driver_name;
++
++    ctx->compat                         = NULL;
++
++    if (compat_version == 0)
++        return VA_STATUS_SUCCESS;
++
++    ASSERT(compat_ctx);
++    if (compat_ctx == NULL)
++        return VA_STATUS_ERROR_UNKNOWN;
++
++    driver_name = NULL;
++    status = pDisplayContext->vaGetDriverName(pDisplayContext, &driver_name);
++    ASSERT(status == VA_STATUS_SUCCESS);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    if ((compat = malloc(sizeof(*compat))) == NULL)
++        return VA_STATUS_ERROR_ALLOCATION_FAILED;
++    compat->buffers                     = NULL;
++    compat->buffers_count_max           = 0;
++    compat->compat_version              = compat_version;
++    compat->compat_ctx                  = NULL;
++    compat->driver_name                 = driver_name;
++    compat->context_map                 = NULL;
++    compat->last_context_map_match      = NULL;
++    ctx->compat                         = compat;
++
++    if (strcmp(driver_name, "psb") == 0)
++        compat->driver_id = VA_DRIVER_ID_POULSBO;
++    else if (strcmp(driver_name, "iegd") == 0)
++        compat->driver_id = VA_DRIVER_ID_IEGD;
++    else
++        compat->driver_id = VA_DRIVER_ID_UNKNOWN;
++
++    switch (compat_version) {
++    case 29:
++        if ((ctx_0_29 = malloc(sizeof(*ctx_0_29))) == NULL)
++            return VA_STATUS_ERROR_ALLOCATION_FAILED;
++        memcpy(ctx_0_29, compat_ctx, sizeof(*ctx_0_29));
++        va_compat_translate_VADriverContext_0_29(compat, ctx_0_29);
++        compat->compat_ctx = ctx_0_29;
++        COPY_FIELD(ctx, ctx_0_29, version_major);
++        COPY_FIELD(ctx, ctx_0_29, version_minor);
++        COPY_FIELD(ctx, ctx_0_29, max_profiles);
++        COPY_FIELD(ctx, ctx_0_29, max_entrypoints);
++        COPY_FIELD(ctx, ctx_0_29, max_attributes);
++        COPY_FIELD(ctx, ctx_0_29, max_image_formats);
++        COPY_FIELD(ctx, ctx_0_29, max_subpic_formats);
++        COPY_FIELD(ctx, ctx_0_29, max_display_attributes);
++        COPY_FIELD(ctx, ctx_0_29, str_vendor);
++        break;
++    case 30:
++        if ((ctx_0_30 = malloc(sizeof(*ctx_0_30))) == NULL)
++            return VA_STATUS_ERROR_ALLOCATION_FAILED;
++        memcpy(ctx_0_30, compat_ctx, sizeof(*ctx_0_30));
++        va_compat_translate_VADriverContext_0_30(compat, ctx_0_30);
++        compat->compat_ctx = ctx_0_30;
++        COPY_FIELD(ctx, ctx_0_30, version_major);
++        COPY_FIELD(ctx, ctx_0_30, version_minor);
++        COPY_FIELD(ctx, ctx_0_30, max_profiles);
++        COPY_FIELD(ctx, ctx_0_30, max_entrypoints);
++        COPY_FIELD(ctx, ctx_0_30, max_attributes);
++        COPY_FIELD(ctx, ctx_0_30, max_image_formats);
++        COPY_FIELD(ctx, ctx_0_30, max_subpic_formats);
++        COPY_FIELD(ctx, ctx_0_30, max_display_attributes);
++        COPY_FIELD(ctx, ctx_0_30, str_vendor);
++        break;
++    case VA_MINOR_VERSION:
++        va_compat_translate_VADriverContext(compat, compat_ctx);
++        compat->compat_ctx = compat_ctx;
++        break;
++    default:
++        ASSERT(compat_version == 0);
++        return VA_STATUS_ERROR_UNKNOWN;
++    }
++
++    va_compat_init_VADriverVTable(ctx, compat_version);
++    return VA_STATUS_SUCCESS;
++}
++
++VAStatus va_compat_fini(VADisplay dpy)
++{
++    VADriverContextP ctx = CTX(dpy);
++    VACompatContextP compat = ctx->compat;
++    int i;
++
++    if (compat == NULL)
++        return VA_STATUS_SUCCESS;
++
++    if (compat->driver_name)
++    {
++        free(compat->driver_name);
++        compat->driver_name = NULL;
++    }
++
++    if (compat->buffers)
++    {
++        for (i = 0; i < compat->buffers_count_max; i++)
++        {
++            if (compat->buffers[i].id)
++                va_DestroyBufferCompat(ctx, compat->buffers[i].id);
++        }
++        free(compat->buffers);
++        compat->buffers = NULL;
++    }
++
++    if (compat->compat_ctx && compat->compat_version != VA_MINOR_VERSION)
++    {
++        free(compat->compat_ctx);
++        compat->compat_ctx = NULL;
++    }
++
++    if (compat->context_map)
++    {
++        VAContextMapP d, m = compat->context_map;
++        while (m) {
++            d = m;
++            m = m->next;
++            free(d);
++        }
++    }
++    compat->last_context_map_match = NULL;
++
++    free(compat);
++    ctx->compat = NULL;
++    return VA_STATUS_SUCCESS;
++}
+diff --git a/src/va_compat.h b/src/va_compat.h
+new file mode 100644
+index 0000000..2c9d801
+--- /dev/null
++++ b/src/va_compat.h
+@@ -0,0 +1,1467 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++#ifndef VA_COMPAT_H
++#define VA_COMPAT_H
++
++VAStatus va_compat_init(VADisplay dpy, int compat_version, void *compat_ctx);
++VAStatus va_compat_fini(VADisplay dpy);
++
++/* H.264 Picture (0.29) */
++typedef struct _VAPictureH264_0_29
++{
++    VASurfaceID picture_id;
++    unsigned int flags;
++    unsigned int TopFieldOrderCnt;
++    unsigned int BottomFieldOrderCnt;
++} VAPictureH264_0_29;
++
++/* H.264 Picture Parameter Buffer (0.29) */
++typedef struct _VAPictureParameterBufferH264_0_29
++{
++    VAPictureH264_0_29 CurrPic;
++    VAPictureH264_0_29 ReferenceFrames[16];	/* in DPB */
++    unsigned short picture_width_in_mbs_minus1;
++    unsigned short picture_height_in_mbs_minus1;
++    unsigned char bit_depth_luma_minus8;
++    unsigned char bit_depth_chroma_minus8;
++    unsigned char num_ref_frames;
++    union {
++        struct {
++            unsigned char chroma_format_idc			: 2; 
++            unsigned char residual_colour_transform_flag	: 1; 
++            unsigned char frame_mbs_only_flag			: 1; 
++            unsigned char mb_adaptive_frame_field_flag		: 1; 
++            unsigned char direct_8x8_inference_flag		: 1; 
++            unsigned char MinLumaBiPredSize8x8			: 1; /* see A.3.3.2 */
++        };
++        unsigned char seq_fields;
++    };
++    unsigned char num_slice_groups_minus1;
++    unsigned char slice_group_map_type;
++    signed char pic_init_qp_minus26;
++    signed char chroma_qp_index_offset;
++    signed char second_chroma_qp_index_offset;
++    union {
++        struct {
++            unsigned char entropy_coding_mode_flag		: 1;
++            unsigned char weighted_pred_flag			: 1;
++            unsigned char weighted_bipred_idc			: 2;
++            unsigned char transform_8x8_mode_flag		: 1;
++            unsigned char field_pic_flag			: 1;
++            unsigned char constrained_intra_pred_flag		: 1;
++        };
++        unsigned char pic_fields;
++    };
++    unsigned short frame_num;
++} VAPictureParameterBufferH264_0_29;
++
++/* H.264 Slice Parameter Buffer (0.29) */
++typedef struct _VASliceParameterBufferH264_0_29
++{
++    unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
++    unsigned int slice_data_offset;/* the offset to the NAL start code for this slice */
++    unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
++    unsigned short slice_data_bit_offset; /* bit offset from NAL start code to the beginning of slice data */
++    unsigned short first_mb_in_slice;
++    unsigned char slice_type;
++    unsigned char direct_spatial_mv_pred_flag;
++    unsigned char num_ref_idx_l0_active_minus1;
++    unsigned char num_ref_idx_l1_active_minus1;
++    unsigned char cabac_init_idc;
++    char slice_qp_delta;
++    unsigned char disable_deblocking_filter_idc;
++    char slice_alpha_c0_offset_div2;
++    char slice_beta_offset_div2;
++    VAPictureH264_0_29 RefPicList0[32];	/* See 8.2.4.2 */
++    VAPictureH264_0_29 RefPicList1[32];	/* See 8.2.4.2 */
++    unsigned char luma_log2_weight_denom;
++    unsigned char chroma_log2_weight_denom;
++    unsigned char luma_weight_l0_flag;
++    short luma_weight_l0[32];
++    short luma_offset_l0[32];
++    unsigned char chroma_weight_l0_flag;
++    short chroma_weight_l0[32][2];
++    short chroma_offset_l0[32][2];
++    unsigned char luma_weight_l1_flag;
++    short luma_weight_l1[32];
++    short luma_offset_l1[32];
++    unsigned char chroma_weight_l1_flag;
++    short chroma_weight_l1[32][2];
++    short chroma_offset_l1[32][2];
++} VASliceParameterBufferH264_0_29;
++
++/* VC-1 Picture Parameter Buffer (0.29) */
++typedef struct _VAPictureParameterBufferVC1_0_29
++{
++    VASurfaceID forward_reference_picture;
++    VASurfaceID backward_reference_picture;
++    /* if out-of-loop post-processing is done on the render
++       target, then we need to keep the in-loop decoded 
++       picture as a reference picture */
++    VASurfaceID inloop_decoded_picture;
++
++    /* sequence layer for AP or meta data for SP and MP */
++    union {
++        struct {
++            unsigned char interlace	: 1; /* SEQUENCE_LAYER::INTERLACE */
++            unsigned char syncmarker	: 1;/* METADATA::SYNCMARKER */
++            unsigned char overlap	: 1;/* METADATA::OVERLAP */
++        };
++        unsigned char sequence_fields;
++    };
++
++    unsigned short coded_width;		/* ENTRY_POINT_LAYER::CODED_WIDTH */
++    unsigned short coded_height;	/* ENTRY_POINT_LAYER::CODED_HEIGHT */
++    unsigned char closed_entry;		/* ENTRY_POINT_LAYER::CLOSED_ENTRY */
++    unsigned char broken_link;		/* ENTRY_POINT_LAYER::BROKEN_LINK */
++    unsigned char loopfilter;		/* ENTRY_POINT_LAYER::LOOPFILTER */
++    unsigned char conditional_overlap_flag; /* ENTRY_POINT_LAYER::CONDOVER */
++    unsigned char fast_uvmc_flag;	/* ENTRY_POINT_LAYER::FASTUVMC */
++    union {
++        struct {
++            unsigned char range_mapping_luma_flag: 	1; /* ENTRY_POINT_LAYER::RANGE_MAPY_FLAG */
++            unsigned char range_mapping_luma: 		3; /* ENTRY_POINT_LAYER::RANGE_MAPY */
++            unsigned char range_mapping_chroma_flag:	1; /* ENTRY_POINT_LAYER::RANGE_MAPUV_FLAG */
++            unsigned char range_mapping_chroma:		3; /* ENTRY_POINT_LAYER::RANGE_MAPUV */
++        };
++        unsigned char range_mapping_fields;
++    };
++
++    unsigned char b_picture_fraction;	/* PICTURE_LAYER::BFRACTION */
++    unsigned char cbp_table;		/* PICTURE_LAYER::CBPTAB/ICBPTAB */
++    unsigned char mb_mode_table;	/* PICTURE_LAYER::MBMODETAB */
++    unsigned char range_reduction_frame;/* PICTURE_LAYER::RANGEREDFRM */
++    unsigned char rounding_control;	/* PICTURE_LAYER::RNDCTRL */
++    unsigned char post_processing;	/* PICTURE_LAYER::POSTPROC */
++    unsigned char picture_resolution_index;	/* PICTURE_LAYER::RESPIC */
++    unsigned char luma_scale;		/* PICTURE_LAYER::LUMSCALE */
++    unsigned char luma_shift;		/* PICTURE_LAYER::LUMSHIFT */
++    union {
++        struct {
++            unsigned char picture_type	: 2; 	/* PICTURE_LAYER::PTYPE */
++            unsigned char frame_coding_mode	: 3;/* PICTURE_LAYER::FCM */
++            unsigned char top_field_first	: 1;/* PICTURE_LAYER::TFF */
++            unsigned char is_first_field	: 1; /* set to 1 if it is the first field */
++            unsigned char intensity_compensation: 1;/* PICTURE_LAYER::INTCOMP */
++        };
++        unsigned char picture_fields;
++    };
++    union {
++        struct {
++            unsigned char mv_type_mb	: 1; 	/* PICTURE::MVTYPEMB */
++            unsigned char direct_mb	: 1; 	/* PICTURE::DIRECTMB */
++            unsigned char skip_mb	: 1; 	/* PICTURE::SKIPMB */
++            unsigned char field_tx	: 1; 	/* PICTURE::FIELDTX */
++            unsigned char forward_mb	: 1;	/* PICTURE::FORWARDMB */
++            unsigned char ac_pred	: 1;	/* PICTURE::ACPRED */
++            unsigned char overflags	: 1;	/* PICTURE::OVERFLAGS */
++        };
++        unsigned char raw_coding_flag;
++    };
++    union {
++        struct {
++            unsigned char bp_mv_type_mb   : 1;    /* PICTURE::MVTYPEMB */
++            unsigned char bp_direct_mb    : 1;    /* PICTURE::DIRECTMB */
++            unsigned char bp_skip_mb      : 1;    /* PICTURE::SKIPMB */  
++            unsigned char bp_field_tx     : 1;    /* PICTURE::FIELDTX */ 
++            unsigned char bp_forward_mb   : 1;    /* PICTURE::FORWARDMB */
++            unsigned char bp_ac_pred      : 1;    /* PICTURE::ACPRED */   
++            unsigned char bp_overflags    : 1;    /* PICTURE::OVERFLAGS */
++        };
++        unsigned char bitplane_present_flag; /* signal what bitplane is being passed via the bitplane buffer */
++    };
++    union {
++        struct {
++            unsigned char reference_distance_flag : 1;/* PICTURE_LAYER::REFDIST_FLAG */
++            unsigned char reference_distance	: 5;/* PICTURE_LAYER::REFDIST */
++            unsigned char num_reference_pictures: 1;/* PICTURE_LAYER::NUMREF */
++            unsigned char reference_field_pic_indicator	: 1;/* PICTURE_LAYER::REFFIELD */
++        };
++        unsigned short reference_fields;
++    };
++    union {
++        struct {
++            VAMvModeVC1 mv_mode              : 3; /* PICTURE_LAYER::MVMODE */
++            VAMvModeVC1 mv_mode2             : 3; /* PICTURE_LAYER::MVMODE2 */
++            unsigned char mv_table           : 3; /* PICTURE_LAYER::MVTAB/IMVTAB */
++            unsigned char two_mv_block_pattern_table: 2; /* PICTURE_LAYER::2MVBPTAB */
++            unsigned char four_mv_switch     : 1; /* PICTURE_LAYER::4MVSWITCH */
++            unsigned char four_mv_block_pattern_table : 2; /* PICTURE_LAYER::4MVBPTAB */
++            unsigned char extended_mv_flag   : 1; /* ENTRY_POINT_LAYER::EXTENDED_MV */
++            unsigned char extended_mv_range  : 2; /* PICTURE_LAYER::MVRANGE */
++            unsigned char extended_dmv_flag  : 1; /* ENTRY_POINT_LAYER::EXTENDED_DMV */
++            unsigned char extended_dmv_range : 2; /* PICTURE_LAYER::DMVRANGE */
++        };
++        unsigned int mv_fields;
++    };
++    union {
++        struct {
++            unsigned char dquant	: 2; 	/* ENTRY_POINT_LAYER::DQUANT */
++            unsigned char quantizer     : 2; 	/* ENTRY_POINT_LAYER::QUANTIZER */
++            unsigned char half_qp	: 1; 	/* PICTURE_LAYER::HALFQP */
++            unsigned char pic_quantizer_scale : 5;/* PICTURE_LAYER::PQUANT */
++            unsigned char pic_quantizer_type : 1;/* PICTURE_LAYER::PQUANTIZER */
++            unsigned char dq_frame	: 1; 	/* VOPDQUANT::DQUANTFRM */
++            unsigned char dq_profile	: 2; 	/* VOPDQUANT::DQPROFILE */
++            unsigned char dq_sb_edge	: 2; 	/* VOPDQUANT::DQSBEDGE */
++            unsigned char dq_db_edge 	: 2; 	/* VOPDQUANT::DQDBEDGE */
++            unsigned char dq_binary_level : 1; 	/* VOPDQUANT::DQBILEVEL */
++            unsigned char alt_pic_quantizer : 5;/* VOPDQUANT::ALTPQUANT */
++        };
++        unsigned long pic_quantizer_fields;
++    };
++    union {
++        struct {
++            unsigned char variable_sized_transform_flag	: 1;/* ENTRY_POINT_LAYER::VSTRANSFORM */
++            unsigned char mb_level_transform_type_flag	: 1;/* PICTURE_LAYER::TTMBF */
++            unsigned char frame_level_transform_type	: 2;/* PICTURE_LAYER::TTFRM */
++            unsigned char transform_ac_codingset_idx1	: 2;/* PICTURE_LAYER::TRANSACFRM */
++            unsigned char transform_ac_codingset_idx2	: 2;/* PICTURE_LAYER::TRANSACFRM2 */
++            unsigned char intra_transform_dc_table	: 1;/* PICTURE_LAYER::TRANSDCTAB */
++        };
++        unsigned short transform_fields;
++    };
++} VAPictureParameterBufferVC1_0_29;
++
++/* MPEG-2 Picture Parameter Buffer (0.29) */
++typedef struct _VAPictureParameterBufferMPEG2_0_29
++{
++    unsigned short horizontal_size;
++    unsigned short vertical_size;
++    VASurfaceID forward_reference_picture;
++    VASurfaceID backward_reference_picture;
++    /* meanings of the following fields are the same as in the standard */
++    int picture_coding_type;
++    int f_code; /* pack all four fcode into this */
++    union {
++        struct {
++            unsigned char intra_dc_precision		: 2; 
++            unsigned char picture_structure		: 2; 
++            unsigned char top_field_first		: 1; 
++            unsigned char frame_pred_frame_dct		: 1; 
++            unsigned char concealment_motion_vectors	: 1;
++            unsigned char q_scale_type			: 1;
++            unsigned char intra_vlc_format		: 1;
++            unsigned char alternate_scan		: 1;
++            unsigned char repeat_first_field		: 1;
++            unsigned char progressive_frame		: 1;
++            unsigned char is_first_field		: 1; /* indicate whether the current field
++                                                              * is the first field for field picture
++                                                              */
++        };
++        unsigned int picture_coding_extension;
++    };
++} VAPictureParameterBufferMPEG2_0_29;
++
++/* MPEG-2 Slice Parameter Buffer (0.29) */
++typedef struct _VASliceParameterBufferMPEG2_0_29
++{
++    unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
++    unsigned int slice_data_offset;/* the offset to the first byte of slice data */
++    unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
++    unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */
++    unsigned int slice_vertical_position;
++    int quantiser_scale_code;
++    int intra_slice_flag;
++} VASliceParameterBufferMPEG2_0_29;
++
++/* MPEG-4 Picture Parameter Buffer (0.29) */
++typedef struct _VAPictureParameterBufferMPEG4_0_29
++{
++    unsigned short vop_width;
++    unsigned short vop_height;
++    VASurfaceID forward_reference_picture;
++    VASurfaceID backward_reference_picture;
++    union {
++        struct {
++            unsigned char short_video_header		: 1; 
++            unsigned char chroma_format			: 2; 
++            unsigned char interlaced			: 1; 
++            unsigned char obmc_disable			: 1; 
++            unsigned char sprite_enable			: 2; 
++            unsigned char sprite_warping_accuracy	: 2; 
++            unsigned char quant_type			: 1; 
++            unsigned char quarter_sample		: 1; 
++            unsigned char data_partitioned		: 1; 
++            unsigned char reversible_vlc		: 1; 
++        };
++        unsigned short vol_fields;
++    };
++    unsigned char no_of_sprite_warping_points;
++    short sprite_trajectory_du[3];
++    short sprite_trajectory_dv[3];
++    unsigned char quant_precision;
++    union {
++        struct {
++            unsigned char vop_coding_type		: 2; 
++            unsigned char backward_reference_vop_coding_type	: 2; 
++            unsigned char vop_rounding_type		: 1; 
++            unsigned char intra_dc_vlc_thr		: 3; 
++            unsigned char top_field_first		: 1; 
++            unsigned char alternate_vertical_scan_flag	: 1; 
++        };
++        unsigned short vop_fields;
++    };
++    unsigned char vop_fcode_forward;
++    unsigned char vop_fcode_backward;
++    /* short header related */
++    unsigned char num_gobs_in_vop;
++    unsigned char num_macroblocks_in_gob;
++    /* for direct mode prediction */
++    short TRB;
++    short TRD;
++} VAPictureParameterBufferMPEG4_0_29;
++
++/* H.264 Picture (0.30) */
++typedef struct _VAPictureH264_0_30
++{
++    VASurfaceID picture_id;
++    unsigned int flags;
++    unsigned int TopFieldOrderCnt;
++    unsigned int BottomFieldOrderCnt;
++} VAPictureH264_0_30;
++
++/* H.264 Picture Parameter Buffer (0.30) */
++typedef struct _VAPictureParameterBufferH264_0_30
++{
++    VAPictureH264 CurrPic;
++    VAPictureH264 ReferenceFrames[16];	/* in DPB */
++    unsigned short picture_width_in_mbs_minus1;
++    unsigned short picture_height_in_mbs_minus1;
++    unsigned char bit_depth_luma_minus8;
++    unsigned char bit_depth_chroma_minus8;
++    unsigned char num_ref_frames;
++    union {
++        struct {
++            unsigned char chroma_format_idc			: 2; 
++            unsigned char residual_colour_transform_flag		: 1; 
++            unsigned char frame_mbs_only_flag			: 1; 
++            unsigned char mb_adaptive_frame_field_flag		: 1; 
++            unsigned char direct_8x8_inference_flag		: 1; 
++            unsigned char MinLumaBiPredSize8x8			: 1; /* see A.3.3.2 */
++        } bits;
++        unsigned char value;
++    } seq_fields;
++    unsigned char num_slice_groups_minus1;
++    unsigned char slice_group_map_type;
++    signed char pic_init_qp_minus26;
++    signed char chroma_qp_index_offset;
++    signed char second_chroma_qp_index_offset;
++    union {
++        struct {
++            unsigned char entropy_coding_mode_flag	: 1;
++            unsigned char weighted_pred_flag		: 1;
++            unsigned char weighted_bipred_idc		: 2;
++            unsigned char transform_8x8_mode_flag	: 1;
++            unsigned char field_pic_flag			: 1;
++            unsigned char constrained_intra_pred_flag	: 1;
++        } bits;
++        unsigned char value;
++    } pic_fields;
++    unsigned short frame_num;
++} VAPictureParameterBufferH264_0_30;
++
++/* H.264 Slice Parameter Buffer (0.30) */
++typedef struct _VASliceParameterBufferH264_0_30
++{
++    unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
++    unsigned int slice_data_offset;/* the offset to the NAL start code for this slice */
++    unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
++    unsigned short slice_data_bit_offset; /* bit offset from NAL start code to the beginning of slice data */
++    unsigned short first_mb_in_slice;
++    unsigned char slice_type;
++    unsigned char direct_spatial_mv_pred_flag;
++    unsigned char num_ref_idx_l0_active_minus1;
++    unsigned char num_ref_idx_l1_active_minus1;
++    unsigned char cabac_init_idc;
++    char slice_qp_delta;
++    unsigned char disable_deblocking_filter_idc;
++    char slice_alpha_c0_offset_div2;
++    char slice_beta_offset_div2;
++    VAPictureH264 RefPicList0[32];	/* See 8.2.4.2 */
++    VAPictureH264 RefPicList1[32];	/* See 8.2.4.2 */
++    unsigned char luma_log2_weight_denom;
++    unsigned char chroma_log2_weight_denom;
++    unsigned char luma_weight_l0_flag;
++    short luma_weight_l0[32];
++    short luma_offset_l0[32];
++    unsigned char chroma_weight_l0_flag;
++    short chroma_weight_l0[32][2];
++    short chroma_offset_l0[32][2];
++    unsigned char luma_weight_l1_flag;
++    short luma_weight_l1[32];
++    short luma_offset_l1[32];
++    unsigned char chroma_weight_l1_flag;
++    short chroma_weight_l1[32][2];
++    short chroma_offset_l1[32][2];
++} VASliceParameterBufferH264_0_30;
++
++/* VC-1 Picture Parameter Buffer (0.30) */
++typedef struct _VAPictureParameterBufferVC1_0_30
++{
++    VASurfaceID forward_reference_picture;
++    VASurfaceID backward_reference_picture;
++    /* if out-of-loop post-processing is done on the render
++       target, then we need to keep the in-loop decoded 
++       picture as a reference picture */
++    VASurfaceID inloop_decoded_picture;
++
++    /* sequence layer for AP or meta data for SP and MP */
++    union {
++        struct {
++            unsigned char interlace	: 1; /* SEQUENCE_LAYER::INTERLACE */
++            unsigned char syncmarker	: 1;/* METADATA::SYNCMARKER */
++            unsigned char overlap	: 1;/* METADATA::OVERLAP */
++        } bits;
++        unsigned char value;
++    } sequence_fields;
++
++    unsigned short coded_width;		/* ENTRY_POINT_LAYER::CODED_WIDTH */
++    unsigned short coded_height;	/* ENTRY_POINT_LAYER::CODED_HEIGHT */
++    unsigned char closed_entry;		/* ENTRY_POINT_LAYER::CLOSED_ENTRY */
++    unsigned char broken_link;		/* ENTRY_POINT_LAYER::BROKEN_LINK */
++    unsigned char loopfilter;		/* ENTRY_POINT_LAYER::LOOPFILTER */
++    unsigned char conditional_overlap_flag; /* ENTRY_POINT_LAYER::CONDOVER */
++    unsigned char fast_uvmc_flag;	/* ENTRY_POINT_LAYER::FASTUVMC */
++    union {
++        struct {
++            unsigned char luma_flag	: 1; /* ENTRY_POINT_LAYER::RANGE_MAPY_FLAG */
++            unsigned char luma		: 3; /* ENTRY_POINT_LAYER::RANGE_MAPY */
++            unsigned char chroma_flag	: 1; /* ENTRY_POINT_LAYER::RANGE_MAPUV_FLAG */
++            unsigned char chroma		: 3; /* ENTRY_POINT_LAYER::RANGE_MAPUV */
++        } bits;
++        unsigned char value;
++    } range_mapping_fields;
++
++    unsigned char b_picture_fraction;	/* PICTURE_LAYER::BFRACTION */
++    unsigned char cbp_table;		/* PICTURE_LAYER::CBPTAB/ICBPTAB */
++    unsigned char mb_mode_table;	/* PICTURE_LAYER::MBMODETAB */
++    unsigned char range_reduction_frame;/* PICTURE_LAYER::RANGEREDFRM */
++    unsigned char rounding_control;	/* PICTURE_LAYER::RNDCTRL */
++    unsigned char post_processing;	/* PICTURE_LAYER::POSTPROC */
++    unsigned char picture_resolution_index;	/* PICTURE_LAYER::RESPIC */
++    unsigned char luma_scale;		/* PICTURE_LAYER::LUMSCALE */
++    unsigned char luma_shift;		/* PICTURE_LAYER::LUMSHIFT */
++    union {
++        struct {
++            unsigned char picture_type		: 2; /* PICTURE_LAYER::PTYPE */
++            unsigned char frame_coding_mode	: 3; /* PICTURE_LAYER::FCM */
++            unsigned char top_field_first	: 1; /* PICTURE_LAYER::TFF */
++            unsigned char is_first_field		: 1; /* set to 1 if it is the first field */
++            unsigned char intensity_compensation	: 1; /* PICTURE_LAYER::INTCOMP */
++        } bits;
++        unsigned char value;
++    } picture_fields;
++    union {
++        struct {
++            unsigned char mv_type_mb	: 1; 	/* PICTURE::MVTYPEMB */
++            unsigned char direct_mb	: 1; 	/* PICTURE::DIRECTMB */
++            unsigned char skip_mb	: 1; 	/* PICTURE::SKIPMB */
++            unsigned char field_tx	: 1; 	/* PICTURE::FIELDTX */
++            unsigned char forward_mb	: 1;	/* PICTURE::FORWARDMB */
++            unsigned char ac_pred	: 1;	/* PICTURE::ACPRED */
++            unsigned char overflags	: 1;	/* PICTURE::OVERFLAGS */
++        } flags;
++        unsigned char value;
++    } raw_coding;
++    union {
++        struct {
++            unsigned char bp_mv_type_mb   : 1;    /* PICTURE::MVTYPEMB */
++            unsigned char bp_direct_mb    : 1;    /* PICTURE::DIRECTMB */
++            unsigned char bp_skip_mb      : 1;    /* PICTURE::SKIPMB */  
++            unsigned char bp_field_tx     : 1;    /* PICTURE::FIELDTX */ 
++            unsigned char bp_forward_mb   : 1;    /* PICTURE::FORWARDMB */
++            unsigned char bp_ac_pred      : 1;    /* PICTURE::ACPRED */   
++            unsigned char bp_overflags    : 1;    /* PICTURE::OVERFLAGS */
++        } flags;
++        unsigned char value;
++    } bitplane_present; /* signal what bitplane is being passed via the bitplane buffer */
++    union {
++        struct {
++            unsigned char reference_distance_flag : 1;/* PICTURE_LAYER::REFDIST_FLAG */
++            unsigned char reference_distance	: 5;/* PICTURE_LAYER::REFDIST */
++            unsigned char num_reference_pictures: 1;/* PICTURE_LAYER::NUMREF */
++            unsigned char reference_field_pic_indicator	: 1;/* PICTURE_LAYER::REFFIELD */
++        } bits;
++        unsigned short value;
++    } reference_fields;
++    union {
++        struct {
++            unsigned char mv_mode		: 3; /* PICTURE_LAYER::MVMODE */
++            unsigned char mv_mode2		: 3; /* PICTURE_LAYER::MVMODE2 */
++            unsigned char mv_table		: 3; /* PICTURE_LAYER::MVTAB/IMVTAB */
++            unsigned char two_mv_block_pattern_table: 2; /* PICTURE_LAYER::2MVBPTAB */
++            unsigned char four_mv_switch		: 1; /* PICTURE_LAYER::4MVSWITCH */
++            unsigned char four_mv_block_pattern_table : 2; /* PICTURE_LAYER::4MVBPTAB */
++            unsigned char extended_mv_flag	: 1; /* ENTRY_POINT_LAYER::EXTENDED_MV */
++            unsigned char extended_mv_range	: 2; /* PICTURE_LAYER::MVRANGE */
++            unsigned char extended_dmv_flag	: 1; /* ENTRY_POCHAR_LAYER::EXTENDED_DMV */
++            unsigned char extended_dmv_range	: 2; /* PICTURE_LAYER::DMVRANGE */
++        } bits;
++        unsigned int value;
++    } mv_fields;
++    union {
++        struct {
++            unsigned char dquant	: 2; 	/* ENTRY_POINT_LAYER::DQUANT */
++            unsigned char quantizer     : 2; 	/* ENTRY_POINT_LAYER::QUANTIZER */
++            unsigned char half_qp	: 1; 	/* PICTURE_LAYER::HALFQP */
++            unsigned char pic_quantizer_scale : 5;/* PICTURE_LAYER::PQUANT */
++            unsigned char pic_quantizer_type : 1;/* PICTURE_LAYER::PQUANTIZER */
++            unsigned char dq_frame	: 1; 	/* VOPDQUANT::DQUANTFRM */
++            unsigned char dq_profile	: 2; 	/* VOPDQUANT::DQPROFILE */
++            unsigned char dq_sb_edge	: 2; 	/* VOPDQUANT::DQSBEDGE */
++            unsigned char dq_db_edge 	: 2; 	/* VOPDQUANT::DQDBEDGE */
++            unsigned char dq_binary_level : 1; 	/* VOPDQUANT::DQBILEVEL */
++            unsigned char alt_pic_quantizer : 5;/* VOPDQUANT::ALTPQUANT */
++        } bits;
++        unsigned long value;
++    } pic_quantizer_fields;
++    union {
++        struct {
++            unsigned char variable_sized_transform_flag	: 1;/* ENTRY_POINT_LAYER::VSTRANSFORM */
++            unsigned char mb_level_transform_type_flag	: 1;/* PICTURE_LAYER::TTMBF */
++            unsigned char frame_level_transform_type	: 2;/* PICTURE_LAYER::TTFRM */
++            unsigned char transform_ac_codingset_idx1	: 2;/* PICTURE_LAYER::TRANSACFRM */
++            unsigned char transform_ac_codingset_idx2	: 2;/* PICTURE_LAYER::TRANSACFRM2 */
++            unsigned char intra_transform_dc_table	: 1;/* PICTURE_LAYER::TRANSDCTAB */
++        } bits;
++        unsigned short value;
++    } transform_fields;
++} VAPictureParameterBufferVC1_0_30;
++
++/* MPEG-2 Picture Parameter Buffer (0.30) */
++typedef struct _VAPictureParameterBufferMPEG2_0_30
++{
++    unsigned short horizontal_size;
++    unsigned short vertical_size;
++    VASurfaceID forward_reference_picture;
++    VASurfaceID backward_reference_picture;
++    /* meanings of the following fields are the same as in the standard */
++    int picture_coding_type;
++    int f_code; /* pack all four fcode into this */
++    union {
++        struct {
++            unsigned int intra_dc_precision		: 2; 
++            unsigned int picture_structure		: 2; 
++            unsigned int top_field_first		: 1; 
++            unsigned int frame_pred_frame_dct		: 1; 
++            unsigned int concealment_motion_vectors	: 1;
++            unsigned int q_scale_type			: 1;
++            unsigned int intra_vlc_format		: 1;
++            unsigned int alternate_scan			: 1;
++            unsigned int repeat_first_field		: 1;
++            unsigned int progressive_frame		: 1;
++            unsigned int is_first_field			: 1; /* indicate whether the current field
++                                                              * is the first field for field picture
++                                                              */
++        } bits;
++        unsigned int value;
++    } picture_coding_extension;
++} VAPictureParameterBufferMPEG2_0_30;
++
++/* MPEG-2 Slice Parameter Buffer (0.29) */
++typedef VASliceParameterBufferMPEG2_0_29 VASliceParameterBufferMPEG2_0_30;
++
++/* MPEG-4 Picture Parameter Buffer (0.30) */
++typedef struct _VAPictureParameterBufferMPEG4_0_30
++{
++    unsigned short vop_width;
++    unsigned short vop_height;
++    VASurfaceID forward_reference_picture;
++    VASurfaceID backward_reference_picture;
++    union {
++        struct {
++            unsigned char short_video_header		: 1; 
++            unsigned char chroma_format			: 2; 
++            unsigned char interlaced			: 1; 
++            unsigned char obmc_disable			: 1; 
++            unsigned char sprite_enable			: 2; 
++            unsigned char sprite_warping_accuracy	: 2; 
++            unsigned char quant_type			: 1; 
++            unsigned char quarter_sample			: 1; 
++            unsigned char data_partitioned		: 1; 
++            unsigned char reversible_vlc			: 1; 
++        } bits;
++        unsigned short value;
++    } vol_fields;
++    unsigned char no_of_sprite_warping_points;
++    short sprite_trajectory_du[3];
++    short sprite_trajectory_dv[3];
++    unsigned char quant_precision;
++    union {
++        struct {
++            unsigned char vop_coding_type		: 2; 
++            unsigned char backward_reference_vop_coding_type	: 2; 
++            unsigned char vop_rounding_type		: 1; 
++            unsigned char intra_dc_vlc_thr		: 3; 
++            unsigned char top_field_first		: 1; 
++            unsigned char alternate_vertical_scan_flag	: 1; 
++        } bits;
++        unsigned short value;
++    } vop_fields;
++    unsigned char vop_fcode_forward;
++    unsigned char vop_fcode_backward;
++    /* short header related */
++    unsigned char num_gobs_in_vop;
++    unsigned char num_macroblocks_in_gob;
++    /* for direct mode prediction */
++    short TRB;
++    short TRD;
++} VAPictureParameterBufferMPEG4_0_30;
++
++/* Encode Slice Parameter Buffer (0.30) */
++typedef struct _VAEncSliceParameterBuffer_0_30
++{
++    unsigned int start_row_number;	/* starting MB row number for this slice */
++    unsigned int slice_height;	/* slice height measured in MB */
++    union {
++        struct {
++            unsigned char is_intra	: 1;
++            unsigned char disable_deblocking_filter_idc : 2;
++        } bits;
++        unsigned char value;
++    } slice_flags;
++} VAEncSliceParameterBuffer_0_30;
++
++/* MPEG-4 Picture Parameter Buffer (0.31) */
++typedef struct _VAPictureParameterBufferMPEG4_0_31
++{
++    unsigned short vop_width;
++    unsigned short vop_height;
++    VASurfaceID forward_reference_picture;
++    VASurfaceID backward_reference_picture;
++    union {
++        struct {
++            unsigned int short_video_header		: 1; 
++            unsigned int chroma_format			: 2; 
++            unsigned int interlaced			: 1; 
++            unsigned int obmc_disable			: 1; 
++            unsigned int sprite_enable			: 2; 
++            unsigned int sprite_warping_accuracy	: 2; 
++            unsigned int quant_type			: 1; 
++            unsigned int quarter_sample			: 1; 
++            unsigned int data_partitioned		: 1; 
++            unsigned int reversible_vlc			: 1; 
++        } bits;
++        unsigned int value;
++    } vol_fields;
++    unsigned char no_of_sprite_warping_points;
++    short sprite_trajectory_du[3];
++    short sprite_trajectory_dv[3];
++    unsigned char quant_precision;
++    union {
++        struct {
++            unsigned int vop_coding_type		: 2; 
++            unsigned int backward_reference_vop_coding_type	: 2; 
++            unsigned int vop_rounding_type		: 1; 
++            unsigned int intra_dc_vlc_thr		: 3; 
++            unsigned int top_field_first		: 1; 
++            unsigned int alternate_vertical_scan_flag	: 1; 
++        } bits;
++        unsigned int value;
++    } vop_fields;
++    unsigned char vop_fcode_forward;
++    unsigned char vop_fcode_backward;
++    /* short header related */
++    unsigned char num_gobs_in_vop;
++    unsigned char num_macroblocks_in_gob;
++    /* for direct mode prediction */
++    short TRB;
++    short TRD;
++} VAPictureParameterBufferMPEG4_0_31;
++
++typedef struct VADriverContext_0_29 *VADriverContextP_0_29;
++
++/* Driver VTable (0.29) */
++struct VADriverVTable_0_29
++{
++	VAStatus (*vaTerminate) ( VADriverContextP_0_29 ctx );
++
++	VAStatus (*vaQueryConfigProfiles) (
++		VADriverContextP_0_29 ctx,
++		VAProfile *profile_list,	/* out */
++		int *num_profiles			/* out */
++	);
++
++	VAStatus (*vaQueryConfigEntrypoints) (
++		VADriverContextP_0_29 ctx,
++		VAProfile profile,
++		VAEntrypoint  *entrypoint_list,	/* out */
++		int *num_entrypoints			/* out */
++	);
++
++	VAStatus (*vaGetConfigAttributes) (
++		VADriverContextP_0_29 ctx,
++		VAProfile profile,
++		VAEntrypoint entrypoint,
++		VAConfigAttrib *attrib_list,	/* in/out */
++		int num_attribs
++	);
++
++	VAStatus (*vaCreateConfig) (
++		VADriverContextP_0_29 ctx,
++		VAProfile profile, 
++		VAEntrypoint entrypoint, 
++		VAConfigAttrib *attrib_list,
++		int num_attribs,
++		VAConfigID *config_id		/* out */
++	);
++
++	VAStatus (*vaDestroyConfig) (
++		VADriverContextP_0_29 ctx,
++		VAConfigID config_id
++	);
++
++	VAStatus (*vaQueryConfigAttributes) (
++		VADriverContextP_0_29 ctx,
++		VAConfigID config_id, 
++		VAProfile *profile,		/* out */
++		VAEntrypoint *entrypoint, 	/* out */
++		VAConfigAttrib *attrib_list,	/* out */
++		int *num_attribs		/* out */
++	);
++
++	VAStatus (*vaCreateSurfaces) (
++		VADriverContextP_0_29 ctx,
++		int width,
++		int height,
++		int format,
++		int num_surfaces,
++		VASurfaceID *surfaces		/* out */
++	);
++
++	VAStatus (*vaDestroySurfaces) (
++		VADriverContextP_0_29 ctx,
++		VASurfaceID *surface_list,
++		int num_surfaces
++	);
++
++	VAStatus (*vaCreateContext) (
++		VADriverContextP_0_29 ctx,
++		VAConfigID config_id,
++		int picture_width,
++		int picture_height,
++		int flag,
++		VASurfaceID *render_targets,
++		int num_render_targets,
++		VAContextID *context		/* out */
++	);
++
++	VAStatus (*vaDestroyContext) (
++		VADriverContextP_0_29 ctx,
++		VAContextID context
++	);
++
++	VAStatus (*vaCreateBuffer) (
++		VADriverContextP_0_29 ctx,
++		VAContextID context,		/* in */
++		VABufferType type,		/* in */
++		unsigned int size,		/* in */
++		unsigned int num_elements,	/* in */
++		void *data,			/* in */
++		VABufferID *buf_id		/* out */
++	);
++
++	VAStatus (*vaBufferSetNumElements) (
++		VADriverContextP_0_29 ctx,
++		VABufferID buf_id,	/* in */
++		unsigned int num_elements	/* in */
++	);
++
++	VAStatus (*vaMapBuffer) (
++		VADriverContextP_0_29 ctx,
++		VABufferID buf_id,	/* in */
++		void **pbuf         /* out */
++	);
++
++	VAStatus (*vaUnmapBuffer) (
++		VADriverContextP_0_29 ctx,
++		VABufferID buf_id	/* in */
++	);
++
++	VAStatus (*vaDestroyBuffer) (
++		VADriverContextP_0_29 ctx,
++		VABufferID buffer_id
++	);
++
++	VAStatus (*vaBeginPicture) (
++		VADriverContextP_0_29 ctx,
++		VAContextID context,
++		VASurfaceID render_target
++	);
++
++	VAStatus (*vaRenderPicture) (
++		VADriverContextP_0_29 ctx,
++		VAContextID context,
++		VABufferID *buffers,
++		int num_buffers
++	);
++
++	VAStatus (*vaEndPicture) (
++		VADriverContextP_0_29 ctx,
++		VAContextID context
++	);
++
++	VAStatus (*vaSyncSurface) (
++		VADriverContextP_0_29 ctx,
++		VAContextID context,
++		VASurfaceID render_target
++	);
++
++	VAStatus (*vaQuerySurfaceStatus) (
++		VADriverContextP_0_29 ctx,
++		VASurfaceID render_target,
++		VASurfaceStatus *status	/* out */
++	);
++
++	VAStatus (*vaPutSurface) (
++    		VADriverContextP_0_29 ctx,
++		VASurfaceID surface,
++		unsigned long draw, /* X Drawable */
++		short srcx,
++		short srcy,
++		unsigned short srcw,
++		unsigned short srch,
++		short destx,
++		short desty,
++		unsigned short destw,
++		unsigned short desth,
++		VARectangle *cliprects, /* client supplied clip list */
++		unsigned int number_cliprects, /* number of clip rects in the clip list */
++		unsigned int flags /* de-interlacing flags */
++	);
++
++	VAStatus (*vaQueryImageFormats) (
++		VADriverContextP_0_29 ctx,
++		VAImageFormat *format_list,        /* out */
++		int *num_formats           /* out */
++	);
++
++	VAStatus (*vaCreateImage) (
++		VADriverContextP_0_29 ctx,
++		VAImageFormat *format,
++		int width,
++		int height,
++		VAImage *image     /* out */
++	);
++
++	VAStatus (*vaDeriveImage) (
++		VADriverContextP_0_29 ctx,
++		VASurfaceID surface,
++		VAImage *image     /* out */
++	);
++
++	VAStatus (*vaDestroyImage) (
++		VADriverContextP_0_29 ctx,
++		VAImageID image
++	);
++	
++	VAStatus (*vaSetImagePalette) (
++	        VADriverContextP_0_29 ctx,
++	        VAImageID image,
++	        /*
++                 * pointer to an array holding the palette data.  The size of the array is
++                 * num_palette_entries * entry_bytes in size.  The order of the components
++                 * in the palette is described by the component_order in VAImage struct
++                 */
++                unsigned char *palette
++	);
++	
++	VAStatus (*vaGetImage) (
++		VADriverContextP_0_29 ctx,
++		VASurfaceID surface,
++		int x,     /* coordinates of the upper left source pixel */
++		int y,
++		unsigned int width, /* width and height of the region */
++		unsigned int height,
++		VAImageID image
++	);
++
++	VAStatus (*vaPutImage) (
++		VADriverContextP_0_29 ctx,
++		VASurfaceID surface,
++		VAImageID image,
++		int src_x,
++		int src_y,
++		unsigned int width,
++		unsigned int height,
++		int dest_x,
++		int dest_y 
++	);
++
++	VAStatus (*vaPutImage2) (
++		VADriverContextP_0_29 ctx,
++		VASurfaceID surface,
++		VAImageID image,
++		int src_x,
++		int src_y,
++		unsigned int src_width,
++		unsigned int src_height,
++		int dest_x,
++		int dest_y,
++		unsigned int dest_width,
++		unsigned int dest_height
++	);
++
++	VAStatus (*vaQuerySubpictureFormats) (
++		VADriverContextP_0_29 ctx,
++		VAImageFormat *format_list,        /* out */
++		unsigned int *flags,       /* out */
++		unsigned int *num_formats  /* out */
++	);
++
++	VAStatus (*vaCreateSubpicture) (
++		VADriverContextP_0_29 ctx,
++		VAImageID image,
++		VASubpictureID *subpicture   /* out */
++	);
++
++	VAStatus (*vaDestroySubpicture) (
++		VADriverContextP_0_29 ctx,
++		VASubpictureID subpicture
++	);
++
++        VAStatus (*vaSetSubpictureImage) (
++                VADriverContextP_0_29 ctx,
++                VASubpictureID subpicture,
++                VAImageID image
++        );
++        
++	VAStatus (*vaSetSubpicturePalette) (
++		VADriverContextP_0_29 ctx,
++		VASubpictureID subpicture,
++		/*
++		 * pointer to an array holding the palette data.  The size of the array is
++		 * num_palette_entries * entry_bytes in size.  The order of the components
++		 * in the palette is described by the component_order in VASubpicture struct
++		 */
++		unsigned char *palette
++	);
++
++	VAStatus (*vaSetSubpictureChromakey) (
++		VADriverContextP_0_29 ctx,
++		VASubpictureID subpicture,
++		unsigned int chromakey_min,
++		unsigned int chromakey_max,
++		unsigned int chromakey_mask
++	);
++
++	VAStatus (*vaSetSubpictureGlobalAlpha) (
++		VADriverContextP_0_29 ctx,
++		VASubpictureID subpicture,
++		float global_alpha 
++	);
++
++	VAStatus (*vaAssociateSubpicture) (
++		VADriverContextP_0_29 ctx,
++		VASubpictureID subpicture,
++		VASurfaceID *target_surfaces,
++		int num_surfaces,
++		short src_x, /* upper left offset in subpicture */
++		short src_y,
++		short dest_x, /* upper left offset in surface */
++		short dest_y,
++		unsigned short width,
++		unsigned short height,
++		/*
++		 * whether to enable chroma-keying or global-alpha
++		 * see VA_SUBPICTURE_XXX values
++		 */
++		unsigned int flags
++	);
++
++	VAStatus (*vaAssociateSubpicture2) (
++		VADriverContextP_0_29 ctx,
++		VASubpictureID subpicture,
++		VASurfaceID *target_surfaces,
++		int num_surfaces,
++		short src_x, /* upper left offset in subpicture */
++		short src_y,
++		unsigned short src_width,
++		unsigned short src_height,
++		short dest_x, /* upper left offset in surface */
++		short dest_y,
++		unsigned short dest_width,
++		unsigned short dest_height,
++		/*
++		 * whether to enable chroma-keying or global-alpha
++		 * see VA_SUBPICTURE_XXX values
++		 */
++		unsigned int flags
++	);
++
++	VAStatus (*vaDeassociateSubpicture) (
++		VADriverContextP_0_29 ctx,
++		VASubpictureID subpicture,
++		VASurfaceID *target_surfaces,
++		int num_surfaces
++	);
++
++	VAStatus (*vaQueryDisplayAttributes) (
++		VADriverContextP_0_29 ctx,
++		VADisplayAttribute *attr_list,	/* out */
++		int *num_attributes		/* out */
++        );
++
++	VAStatus (*vaGetDisplayAttributes) (
++		VADriverContextP_0_29 ctx,
++		VADisplayAttribute *attr_list,	/* in/out */
++		int num_attributes
++        );
++        
++        VAStatus (*vaSetDisplayAttributes) (
++		VADriverContextP_0_29 ctx,
++                VADisplayAttribute *attr_list,
++                int num_attributes
++        );
++
++
++	VAStatus (*vaDbgCopySurfaceToBuffer) (
++		VADriverContextP_0_29 ctx,
++		VASurfaceID surface,
++		void **buffer, /* out */
++		unsigned int *stride /* out */
++	);
++};
++
++/* Driver context (0.29) */
++struct VADriverContext_0_29
++{
++    void *old_pNext;			/* preserved for binary compatibility */
++
++    void *pDriverData;
++    struct VADriverVTable_0_29 vtable;
++
++    void *x11_dpy;
++    int x11_screen;
++
++    int version_major;
++    int version_minor;
++    int max_profiles;
++    int max_entrypoints;
++    int max_attributes;
++    int max_image_formats;
++    int max_subpic_formats;
++    int max_display_attributes;
++    const char *str_vendor;
++
++    void *handle;			/* dlopen handle */
++};
++
++/* Forward declarations for VA API 0.30 */
++struct v4l2_format;
++struct v4l2_buffer;
++typedef struct VADriverContext_0_30 *VADriverContextP_0_30;
++
++/* Driver VTable (0.30) */
++struct VADriverVTable_0_30
++{
++	VAStatus (*vaTerminate) ( VADriverContextP_0_30 ctx );
++
++	VAStatus (*vaQueryConfigProfiles) (
++		VADriverContextP_0_30 ctx,
++		VAProfile *profile_list,	/* out */
++		int *num_profiles			/* out */
++	);
++
++	VAStatus (*vaQueryConfigEntrypoints) (
++		VADriverContextP_0_30 ctx,
++		VAProfile profile,
++		VAEntrypoint  *entrypoint_list,	/* out */
++		int *num_entrypoints			/* out */
++	);
++
++	VAStatus (*vaGetConfigAttributes) (
++		VADriverContextP_0_30 ctx,
++		VAProfile profile,
++		VAEntrypoint entrypoint,
++		VAConfigAttrib *attrib_list,	/* in/out */
++		int num_attribs
++	);
++
++	VAStatus (*vaCreateConfig) (
++		VADriverContextP_0_30 ctx,
++		VAProfile profile, 
++		VAEntrypoint entrypoint, 
++		VAConfigAttrib *attrib_list,
++		int num_attribs,
++		VAConfigID *config_id		/* out */
++	);
++
++	VAStatus (*vaDestroyConfig) (
++		VADriverContextP_0_30 ctx,
++		VAConfigID config_id
++	);
++
++	VAStatus (*vaQueryConfigAttributes) (
++		VADriverContextP_0_30 ctx,
++		VAConfigID config_id, 
++		VAProfile *profile,		/* out */
++		VAEntrypoint *entrypoint, 	/* out */
++		VAConfigAttrib *attrib_list,	/* out */
++		int *num_attribs		/* out */
++	);
++
++	VAStatus (*vaCreateSurfaces) (
++		VADriverContextP_0_30 ctx,
++		int width,
++		int height,
++		int format,
++		int num_surfaces,
++		VASurfaceID *surfaces		/* out */
++	);
++
++	VAStatus (*vaDestroySurfaces) (
++		VADriverContextP_0_30 ctx,
++		VASurfaceID *surface_list,
++		int num_surfaces
++	);
++
++	VAStatus (*vaCreateContext) (
++		VADriverContextP_0_30 ctx,
++		VAConfigID config_id,
++		int picture_width,
++		int picture_height,
++		int flag,
++		VASurfaceID *render_targets,
++		int num_render_targets,
++		VAContextID *context		/* out */
++	);
++
++	VAStatus (*vaDestroyContext) (
++		VADriverContextP_0_30 ctx,
++		VAContextID context
++	);
++
++	VAStatus (*vaCreateBuffer) (
++		VADriverContextP_0_30 ctx,
++		VAContextID context,		/* in */
++		VABufferType type,		/* in */
++		unsigned int size,		/* in */
++		unsigned int num_elements,	/* in */
++		void *data,			/* in */
++		VABufferID *buf_id		/* out */
++	);
++
++	VAStatus (*vaBufferSetNumElements) (
++		VADriverContextP_0_30 ctx,
++		VABufferID buf_id,	/* in */
++		unsigned int num_elements	/* in */
++	);
++
++	VAStatus (*vaMapBuffer) (
++		VADriverContextP_0_30 ctx,
++		VABufferID buf_id,	/* in */
++		void **pbuf         /* out */
++	);
++
++	VAStatus (*vaUnmapBuffer) (
++		VADriverContextP_0_30 ctx,
++		VABufferID buf_id	/* in */
++	);
++
++	VAStatus (*vaDestroyBuffer) (
++		VADriverContextP_0_30 ctx,
++		VABufferID buffer_id
++	);
++
++	VAStatus (*vaBeginPicture) (
++		VADriverContextP_0_30 ctx,
++		VAContextID context,
++		VASurfaceID render_target
++	);
++
++	VAStatus (*vaRenderPicture) (
++		VADriverContextP_0_30 ctx,
++		VAContextID context,
++		VABufferID *buffers,
++		int num_buffers
++	);
++
++	VAStatus (*vaEndPicture) (
++		VADriverContextP_0_30 ctx,
++		VAContextID context
++	);
++
++	VAStatus (*vaSyncSurface) (
++		VADriverContextP_0_30 ctx,
++		VAContextID context,
++		VASurfaceID render_target
++	);
++
++	VAStatus (*vaQuerySurfaceStatus) (
++		VADriverContextP_0_30 ctx,
++		VASurfaceID render_target,
++		VASurfaceStatus *status	/* out */
++	);
++
++	VAStatus (*vaPutSurface) (
++    		VADriverContextP_0_30 ctx,
++		VASurfaceID surface,
++		unsigned long draw, /* X Drawable */
++		short srcx,
++		short srcy,
++		unsigned short srcw,
++		unsigned short srch,
++		short destx,
++		short desty,
++		unsigned short destw,
++		unsigned short desth,
++		VARectangle *cliprects, /* client supplied clip list */
++		unsigned int number_cliprects, /* number of clip rects in the clip list */
++		unsigned int flags /* de-interlacing flags */
++	);
++
++	VAStatus (*vaQueryImageFormats) (
++		VADriverContextP_0_30 ctx,
++		VAImageFormat *format_list,        /* out */
++		int *num_formats           /* out */
++	);
++
++	VAStatus (*vaCreateImage) (
++		VADriverContextP_0_30 ctx,
++		VAImageFormat *format,
++		int width,
++		int height,
++		VAImage *image     /* out */
++	);
++
++	VAStatus (*vaDeriveImage) (
++		VADriverContextP_0_30 ctx,
++		VASurfaceID surface,
++		VAImage *image     /* out */
++	);
++
++	VAStatus (*vaDestroyImage) (
++		VADriverContextP_0_30 ctx,
++		VAImageID image
++	);
++	
++	VAStatus (*vaSetImagePalette) (
++	        VADriverContextP_0_30 ctx,
++	        VAImageID image,
++	        /*
++                 * pointer to an array holding the palette data.  The size of the array is
++                 * num_palette_entries * entry_bytes in size.  The order of the components
++                 * in the palette is described by the component_order in VAImage struct
++                 */
++                unsigned char *palette
++	);
++	
++	VAStatus (*vaGetImage) (
++		VADriverContextP_0_30 ctx,
++		VASurfaceID surface,
++		int x,     /* coordinates of the upper left source pixel */
++		int y,
++		unsigned int width, /* width and height of the region */
++		unsigned int height,
++		VAImageID image
++	);
++
++	VAStatus (*vaPutImage) (
++		VADriverContextP_0_30 ctx,
++		VASurfaceID surface,
++		VAImageID image,
++		int src_x,
++		int src_y,
++		unsigned int width,
++		unsigned int height,
++		int dest_x,
++		int dest_y 
++	);
++
++	VAStatus (*vaPutImage2) (
++		VADriverContextP_0_30 ctx,
++		VASurfaceID surface,
++		VAImageID image,
++		int src_x,
++		int src_y,
++		unsigned int src_width,
++		unsigned int src_height,
++		int dest_x,
++		int dest_y,
++		unsigned int dest_width,
++		unsigned int dest_height
++	);
++
++	VAStatus (*vaQuerySubpictureFormats) (
++		VADriverContextP_0_30 ctx,
++		VAImageFormat *format_list,        /* out */
++		unsigned int *flags,       /* out */
++		unsigned int *num_formats  /* out */
++	);
++
++	VAStatus (*vaCreateSubpicture) (
++		VADriverContextP_0_30 ctx,
++		VAImageID image,
++		VASubpictureID *subpicture   /* out */
++	);
++
++	VAStatus (*vaDestroySubpicture) (
++		VADriverContextP_0_30 ctx,
++		VASubpictureID subpicture
++	);
++
++        VAStatus (*vaSetSubpictureImage) (
++                VADriverContextP_0_30 ctx,
++                VASubpictureID subpicture,
++                VAImageID image
++        );
++
++	VAStatus (*vaSetSubpictureChromakey) (
++		VADriverContextP_0_30 ctx,
++		VASubpictureID subpicture,
++		unsigned int chromakey_min,
++		unsigned int chromakey_max,
++		unsigned int chromakey_mask
++	);
++
++	VAStatus (*vaSetSubpictureGlobalAlpha) (
++		VADriverContextP_0_30 ctx,
++		VASubpictureID subpicture,
++		float global_alpha 
++	);
++
++	VAStatus (*vaAssociateSubpicture) (
++		VADriverContextP_0_30 ctx,
++		VASubpictureID subpicture,
++		VASurfaceID *target_surfaces,
++		int num_surfaces,
++		short src_x, /* upper left offset in subpicture */
++		short src_y,
++		short dest_x, /* upper left offset in surface */
++		short dest_y,
++		unsigned short width,
++		unsigned short height,
++		/*
++		 * whether to enable chroma-keying or global-alpha
++		 * see VA_SUBPICTURE_XXX values
++		 */
++		unsigned int flags
++	);
++
++	VAStatus (*vaAssociateSubpicture2) (
++		VADriverContextP_0_30 ctx,
++		VASubpictureID subpicture,
++		VASurfaceID *target_surfaces,
++		int num_surfaces,
++		short src_x, /* upper left offset in subpicture */
++		short src_y,
++		unsigned short src_width,
++		unsigned short src_height,
++		short dest_x, /* upper left offset in surface */
++		short dest_y,
++		unsigned short dest_width,
++		unsigned short dest_height,
++		/*
++		 * whether to enable chroma-keying or global-alpha
++		 * see VA_SUBPICTURE_XXX values
++		 */
++		unsigned int flags
++	);
++
++	VAStatus (*vaDeassociateSubpicture) (
++		VADriverContextP_0_30 ctx,
++		VASubpictureID subpicture,
++		VASurfaceID *target_surfaces,
++		int num_surfaces
++	);
++
++	VAStatus (*vaQueryDisplayAttributes) (
++		VADriverContextP_0_30 ctx,
++		VADisplayAttribute *attr_list,	/* out */
++		int *num_attributes		/* out */
++        );
++
++	VAStatus (*vaGetDisplayAttributes) (
++		VADriverContextP_0_30 ctx,
++		VADisplayAttribute *attr_list,	/* in/out */
++		int num_attributes
++        );
++        
++        VAStatus (*vaSetDisplayAttributes) (
++		VADriverContextP_0_30 ctx,
++                VADisplayAttribute *attr_list,
++                int num_attributes
++        );
++
++        /* device specific */
++	VAStatus (*vaCreateSurfaceFromCIFrame) (
++		VADriverContextP_0_30 ctx,
++		unsigned long frame_id,
++		VASurfaceID *surface		/* out */
++	);
++    
++    
++        VAStatus (*vaCreateSurfaceFromV4L2Buf) (
++		VADriverContextP_0_30 ctx,
++                int v4l2_fd,         /* file descriptor of V4L2 device */
++                struct v4l2_format *v4l2_fmt,       /* format of V4L2 */
++                struct v4l2_buffer *v4l2_buf,       /* V4L2 buffer */
++                VASurfaceID *surface	           /* out */
++        );
++    
++        VAStatus (*vaCopySurfaceToBuffer) (
++		VADriverContextP_0_30 ctx,
++                VASurfaceID surface,
++                unsigned int *fourcc, /* out  for follow argument */
++                unsigned int *luma_stride,
++                unsigned int *chroma_u_stride,
++                unsigned int *chroma_v_stride,
++                unsigned int *luma_offset,
++                unsigned int *chroma_u_offset,
++                unsigned int *chroma_v_offset,
++                void **buffer
++        );
++};
++
++/* Driver context (0.30) */
++struct VADriverContext_0_30
++{
++    void *pDriverData;
++    struct VADriverVTable_0_30 vtable;
++
++    void *x11_dpy;
++    int x11_screen;
++    int version_major;
++    int version_minor;
++    int max_profiles;
++    int max_entrypoints;
++    int max_attributes;
++    int max_image_formats;
++    int max_subpic_formats;
++    int max_display_attributes;
++    const char *str_vendor;
++
++    void *handle;			/* dlopen handle */
++    
++    void *dri_state;
++};
++
++/* Driver VTable and context (0.31) */
++#define VADriverVTable_0_31     VADriverVTable
++#define VADriverContext_0_31    VADriverContext
++
++#endif /* VA_COMPAT_H */
+diff --git a/src/va_compat_template.h b/src/va_compat_template.h
+new file mode 100644
+index 0000000..18349de
+--- /dev/null
++++ b/src/va_compat_template.h
+@@ -0,0 +1,539 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
++ */
++
++#undef  CONCAT_
++#define CONCAT_(x, y)                   x##y
++#undef  CONCAT
++#define CONCAT(x, y)                    CONCAT_(x, y)
++#undef  MKCOMPAT_
++#define MKCOMPAT_(NAME,MINOR)           CONCAT(CONCAT(NAME,_0_),MINOR)
++#undef  MKCOMPAT
++#define MKCOMPAT(NAME)                  MKCOMPAT_(NAME,COMPAT_MINOR)
++#undef  STRUCT
++#define STRUCT(BUFFER, CODEC)           MKCOMPAT(VA##BUFFER##Buffer##CODEC)
++#undef  TRANSLATE_1
++#define TRANSLATE_1(NAME)               CONCAT(va_compat_translate_,NAME)
++#undef  TRANSLATE_
++#define TRANSLATE_(NAME)                TRANSLATE_1(MKCOMPAT(NAME))
++#undef  TRANSLATE
++#define TRANSLATE(BUFFER, CODEC)        TRANSLATE_1(STRUCT(BUFFER,CODEC))
++
++#undef  COPY_ARRAY
++#define COPY_ARRAY(DST, SRC, ARRAY) \
++    memcpy((DST)->ARRAY, (SRC)->ARRAY, sizeof((DST)->ARRAY))
++
++#undef  COPY_FIELD
++#define COPY_FIELD(DST, SRC, MEMBER) \
++    (DST)->MEMBER = (SRC)->MEMBER
++
++#undef  COPY_VTABLE__
++#define COPY_VTABLE__(DST, DST_MEMBER, SRC, SRC_MEMBER) \
++    (DST##_vtable)->DST_MEMBER = (SRC##_vtable)->SRC_MEMBER
++
++#undef  COPY_VTABLE_
++#define COPY_VTABLE_(DST, DST_SUFFIX, SRC, MEMBER) \
++    COPY_VTABLE__(DST, MEMBER##_##DST_SUFFIX, SRC, MEMBER)
++
++#undef  COPY_VTABLE
++#define COPY_VTABLE(DST, SRC, MEMBER) \
++    COPY_VTABLE__(DST, MEMBER, SRC, MEMBER)
++
++/* 0.29 */
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 29
++#undef  BFV
++#define BFV(a, b) a
++#undef  BFM
++#define BFM(a, b, c) c
++#undef  COPY_BIT_FIELD
++#define COPY_BIT_FIELD(DST, SRC, FIELD, MEMBER)  \
++    (DST)->MEMBER = (SRC)->FIELD.bits.MEMBER
++#undef  COPY_BIT_FLAG
++#define COPY_BIT_FLAG(DST, SRC, FIELD, MEMBER)  \
++    (DST)->MEMBER = (SRC)->FIELD.flags.MEMBER
++#endif
++
++/* 0.29 glue to match 0.30 names */
++#undef M_raw_coding
++#undef M_bitplane_present
++#undef M_luma_flag
++#undef M_luma
++#undef M_chroma_flag
++#undef M_chroma
++
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 29
++#define M_raw_coding            raw_coding_flag
++#define M_bitplane_present      bitplane_present_flag
++#define M_luma_flag             range_mapping_luma_flag
++#define M_luma                  range_mapping_luma
++#define M_chroma_flag           range_mapping_chroma_flag
++#define M_chroma                range_mapping_chroma
++#else
++#define M_raw_coding            raw_coding
++#define M_bitplane_present      bitplane_present
++#define M_luma_flag             luma_flag
++#define M_luma                  luma
++#define M_chroma_flag           chroma_flag
++#define M_chroma                chroma
++#endif
++
++/* 0.30 */
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 30
++#undef  BFV
++#define BFV(a, b) a.b
++#undef  BFM
++#define BFM(a, b, c) a.b.c
++#undef  COPY_BIT_FIELD
++#define COPY_BIT_FIELD(DST, SRC, FIELD, MEMBER)  \
++    (DST)->FIELD.bits.MEMBER = (SRC)->FIELD.bits.MEMBER
++#undef  COPY_BIT_FLAG
++#define COPY_BIT_FLAG(DST, SRC, FIELD, MEMBER)  \
++    (DST)->FIELD.flags.MEMBER = (SRC)->FIELD.flags.MEMBER
++#endif
++
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR < 31
++static VAStatus TRANSLATE_(VAPictureH264)(
++    VACompatContextP    ctx,
++    void               *dest_pic,
++    const void         *src_pic
++)
++{
++    MKCOMPAT(VAPictureH264) *dest = dest_pic;
++    const VAPictureH264 *src = src_pic;
++
++    COPY_FIELD(dest, src, picture_id);
++    COPY_FIELD(dest, src, flags);
++    COPY_FIELD(dest, src, TopFieldOrderCnt);
++    COPY_FIELD(dest, src, BottomFieldOrderCnt);
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus TRANSLATE(PictureParameter,H264)(
++    VACompatContextP    ctx,
++    void               *dest_buffer,
++    const void         *src_buffer
++)
++{
++    STRUCT(PictureParameter,H264) *dest = dest_buffer;
++    const VAPictureParameterBufferH264 *src = src_buffer;
++    VAStatus status;
++    int i;
++
++    status = TRANSLATE_(VAPictureH264)(ctx,
++                                      &dest->CurrPic, &src->CurrPic);
++    if (status != VA_STATUS_SUCCESS)
++        return status;
++
++    for (i = 0; i < 16; i++) {
++        status = TRANSLATE_(VAPictureH264)(ctx,
++                                           &dest->ReferenceFrames[i],
++                                           &src->ReferenceFrames[i]);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++    }
++
++    COPY_FIELD(dest, src, picture_width_in_mbs_minus1);
++    COPY_FIELD(dest, src, picture_height_in_mbs_minus1);
++    COPY_FIELD(dest, src, bit_depth_luma_minus8);
++    COPY_FIELD(dest, src, bit_depth_chroma_minus8);
++    COPY_FIELD(dest, src, num_ref_frames);
++    dest->BFV(seq_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, seq_fields, chroma_format_idc);
++    COPY_BIT_FIELD(dest, src, seq_fields, residual_colour_transform_flag);
++    COPY_BIT_FIELD(dest, src, seq_fields, frame_mbs_only_flag);
++    COPY_BIT_FIELD(dest, src, seq_fields, mb_adaptive_frame_field_flag);
++    COPY_BIT_FIELD(dest, src, seq_fields, direct_8x8_inference_flag);
++    COPY_BIT_FIELD(dest, src, seq_fields, MinLumaBiPredSize8x8);
++    COPY_FIELD(dest, src, num_slice_groups_minus1);
++    COPY_FIELD(dest, src, slice_group_map_type);
++    COPY_FIELD(dest, src, pic_init_qp_minus26);
++    COPY_FIELD(dest, src, chroma_qp_index_offset);
++    COPY_FIELD(dest, src, second_chroma_qp_index_offset);
++    dest->BFV(pic_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, pic_fields, entropy_coding_mode_flag);
++    COPY_BIT_FIELD(dest, src, pic_fields, weighted_pred_flag);
++    COPY_BIT_FIELD(dest, src, pic_fields, weighted_bipred_idc);
++    COPY_BIT_FIELD(dest, src, pic_fields, transform_8x8_mode_flag);
++    COPY_BIT_FIELD(dest, src, pic_fields, field_pic_flag);
++    COPY_BIT_FIELD(dest, src, pic_fields, constrained_intra_pred_flag);
++    COPY_FIELD(dest, src, frame_num);
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus TRANSLATE(SliceParameter,H264)(
++    VACompatContextP    ctx,
++    void               *dest_buffer,
++    const void         *src_buffer
++)
++{
++    STRUCT(SliceParameter,H264) *dest = dest_buffer;
++    const VASliceParameterBufferH264 *src = src_buffer;
++    VAStatus status;
++    int i;
++
++    COPY_FIELD(dest, src, slice_data_size);
++    COPY_FIELD(dest, src, slice_data_offset);
++    COPY_FIELD(dest, src, slice_data_flag);
++    COPY_FIELD(dest, src, slice_data_bit_offset);
++    COPY_FIELD(dest, src, first_mb_in_slice);
++    COPY_FIELD(dest, src, slice_type);
++    COPY_FIELD(dest, src, direct_spatial_mv_pred_flag);
++    COPY_FIELD(dest, src, num_ref_idx_l0_active_minus1);
++    COPY_FIELD(dest, src, num_ref_idx_l1_active_minus1);
++    COPY_FIELD(dest, src, cabac_init_idc);
++    COPY_FIELD(dest, src, slice_qp_delta);
++    COPY_FIELD(dest, src, disable_deblocking_filter_idc);
++    COPY_FIELD(dest, src, slice_alpha_c0_offset_div2);
++    COPY_FIELD(dest, src, slice_beta_offset_div2);
++    for (i = 0; i < 32; i++) {
++        status = TRANSLATE_(VAPictureH264)(ctx,
++                                           &dest->RefPicList0[i],
++                                           &src->RefPicList0[i]);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++        status = TRANSLATE_(VAPictureH264)(ctx,
++                                           &dest->RefPicList1[i],
++                                           &src->RefPicList1[i]);
++        if (status != VA_STATUS_SUCCESS)
++            return status;
++    }
++    COPY_FIELD(dest, src, luma_log2_weight_denom);
++    COPY_FIELD(dest, src, chroma_log2_weight_denom);
++    COPY_FIELD(dest, src, luma_weight_l0_flag);
++    COPY_ARRAY(dest, src, luma_weight_l0);
++    COPY_ARRAY(dest, src, luma_offset_l0);
++    COPY_FIELD(dest, src, chroma_weight_l0_flag);
++    COPY_ARRAY(dest, src, chroma_weight_l0);
++    COPY_ARRAY(dest, src, chroma_offset_l0);
++    COPY_FIELD(dest, src, luma_weight_l1_flag);
++    COPY_ARRAY(dest, src, luma_weight_l1);
++    COPY_ARRAY(dest, src, luma_offset_l1);
++    COPY_FIELD(dest, src, chroma_weight_l1_flag);
++    COPY_ARRAY(dest, src, chroma_weight_l1);
++    COPY_ARRAY(dest, src, chroma_offset_l1);
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus TRANSLATE(PictureParameter,VC1)(
++    VACompatContextP    ctx,
++    void               *dest_buffer,
++    const void         *src_buffer
++)
++{
++    STRUCT(PictureParameter,VC1) *dest = dest_buffer;
++    const VAPictureParameterBufferVC1 *src = src_buffer;
++
++    COPY_FIELD(dest, src, forward_reference_picture);
++    COPY_FIELD(dest, src, backward_reference_picture);
++    COPY_FIELD(dest, src, inloop_decoded_picture);
++    dest->BFV(sequence_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, sequence_fields, interlace);
++    COPY_BIT_FIELD(dest, src, sequence_fields, syncmarker);
++    COPY_BIT_FIELD(dest, src, sequence_fields, overlap);
++    COPY_FIELD(dest, src, coded_width);
++    COPY_FIELD(dest, src, coded_height);
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 30
++    dest->closed_entry = src->entrypoint_fields.bits.closed_entry;
++    dest->broken_link  = src->entrypoint_fields.bits.broken_link;
++    dest->loopfilter   = src->entrypoint_fields.bits.loopfilter;
++#else
++    COPY_BIT_FIELD(dest, src, entrypoint_fields, closed_entry);
++    COPY_BIT_FIELD(dest, src, entrypoint_fields, broken_link);
++    COPY_BIT_FIELD(dest, src, entrypoint_fields, loopfilter);
++#endif
++    COPY_FIELD(dest, src, conditional_overlap_flag);
++    COPY_FIELD(dest, src, fast_uvmc_flag);
++    dest->BFV(range_mapping_fields, value) = 0; /* reset all bits */
++    dest->BFM(range_mapping_fields, bits, M_luma_flag) =
++        src->range_mapping_fields.bits.luma_flag;
++    dest->BFM(range_mapping_fields, bits, M_luma) =
++        src->range_mapping_fields.bits.luma;
++    dest->BFM(range_mapping_fields, bits, M_chroma_flag) =
++        src->range_mapping_fields.bits.chroma_flag;
++    dest->BFM(range_mapping_fields, bits, M_chroma) =
++        src->range_mapping_fields.bits.chroma;
++    COPY_FIELD(dest, src, b_picture_fraction);
++    COPY_FIELD(dest, src, cbp_table);
++    COPY_FIELD(dest, src, mb_mode_table);
++    COPY_FIELD(dest, src, range_reduction_frame);
++    COPY_FIELD(dest, src, rounding_control);
++    COPY_FIELD(dest, src, post_processing);
++    COPY_FIELD(dest, src, picture_resolution_index);
++    COPY_FIELD(dest, src, luma_scale);
++    COPY_FIELD(dest, src, luma_shift);
++    dest->BFV(picture_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, picture_fields, picture_type);
++    COPY_BIT_FIELD(dest, src, picture_fields, frame_coding_mode);
++    COPY_BIT_FIELD(dest, src, picture_fields, top_field_first);
++    COPY_BIT_FIELD(dest, src, picture_fields, is_first_field);
++    COPY_BIT_FIELD(dest, src, picture_fields, intensity_compensation);
++    dest->BFV(M_raw_coding, value) = 0; /* reset all bits */
++    COPY_BIT_FLAG(dest, src, raw_coding, mv_type_mb);
++    COPY_BIT_FLAG(dest, src, raw_coding, direct_mb);
++    COPY_BIT_FLAG(dest, src, raw_coding, skip_mb);
++    COPY_BIT_FLAG(dest, src, raw_coding, field_tx);
++    COPY_BIT_FLAG(dest, src, raw_coding, forward_mb);
++    COPY_BIT_FLAG(dest, src, raw_coding, ac_pred);
++    COPY_BIT_FLAG(dest, src, raw_coding, overflags);
++    dest->BFV(M_bitplane_present, value) = 0; /* reset all bits */
++    COPY_BIT_FLAG(dest, src, bitplane_present, bp_mv_type_mb);
++    COPY_BIT_FLAG(dest, src, bitplane_present, bp_direct_mb);
++    COPY_BIT_FLAG(dest, src, bitplane_present, bp_skip_mb);
++    COPY_BIT_FLAG(dest, src, bitplane_present, bp_field_tx);
++    COPY_BIT_FLAG(dest, src, bitplane_present, bp_forward_mb);
++    COPY_BIT_FLAG(dest, src, bitplane_present, bp_ac_pred);
++    COPY_BIT_FLAG(dest, src, bitplane_present, bp_overflags);
++    dest->BFV(reference_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, reference_fields, reference_distance_flag);
++    COPY_BIT_FIELD(dest, src, reference_fields, reference_distance);
++    COPY_BIT_FIELD(dest, src, reference_fields, num_reference_pictures);
++    COPY_BIT_FIELD(dest, src, reference_fields, reference_field_pic_indicator);
++    dest->BFV(mv_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, mv_fields, mv_mode);
++    COPY_BIT_FIELD(dest, src, mv_fields, mv_mode2);
++    COPY_BIT_FIELD(dest, src, mv_fields, mv_table);
++    COPY_BIT_FIELD(dest, src, mv_fields, two_mv_block_pattern_table);
++    COPY_BIT_FIELD(dest, src, mv_fields, four_mv_switch);
++    COPY_BIT_FIELD(dest, src, mv_fields, four_mv_block_pattern_table);
++    COPY_BIT_FIELD(dest, src, mv_fields, extended_mv_flag);
++    COPY_BIT_FIELD(dest, src, mv_fields, extended_mv_range);
++    COPY_BIT_FIELD(dest, src, mv_fields, extended_dmv_flag);
++    COPY_BIT_FIELD(dest, src, mv_fields, extended_dmv_range);
++    dest->BFV(pic_quantizer_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dquant);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, quantizer);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, half_qp);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, pic_quantizer_scale);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, pic_quantizer_type);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_frame);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_profile);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_sb_edge);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_db_edge);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_binary_level);
++    COPY_BIT_FIELD(dest, src, pic_quantizer_fields, alt_pic_quantizer);
++    dest->BFV(transform_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, transform_fields, variable_sized_transform_flag);
++    COPY_BIT_FIELD(dest, src, transform_fields, mb_level_transform_type_flag);
++    COPY_BIT_FIELD(dest, src, transform_fields, frame_level_transform_type);
++    COPY_BIT_FIELD(dest, src, transform_fields, transform_ac_codingset_idx1);
++    COPY_BIT_FIELD(dest, src, transform_fields, transform_ac_codingset_idx2);
++    COPY_BIT_FIELD(dest, src, transform_fields, intra_transform_dc_table);
++
++    if (src->picture_fields.bits.picture_type == 4) {
++        dest->BFM(picture_fields, bits, picture_type) = 1; /* P-frame */
++        ctx->skip_frame = 1;
++    }
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus TRANSLATE(PictureParameter,MPEG2)(
++    VACompatContextP    ctx,
++    void               *dest_buffer,
++    const void         *src_buffer
++)
++{
++    STRUCT(PictureParameter,MPEG2) *dest = dest_buffer;
++    const VAPictureParameterBufferMPEG2 *src = src_buffer;
++
++    COPY_FIELD(dest, src, horizontal_size);
++    COPY_FIELD(dest, src, vertical_size);
++    COPY_FIELD(dest, src, forward_reference_picture);
++    COPY_FIELD(dest, src, backward_reference_picture);
++    COPY_FIELD(dest, src, picture_coding_type);
++    COPY_FIELD(dest, src, f_code);
++    dest->BFV(picture_coding_extension, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, intra_dc_precision);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, picture_structure);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, top_field_first);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, frame_pred_frame_dct);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, concealment_motion_vectors);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, q_scale_type);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, intra_vlc_format);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, alternate_scan);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, repeat_first_field);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, progressive_frame);
++    COPY_BIT_FIELD(dest, src, picture_coding_extension, is_first_field);
++
++    return VA_STATUS_SUCCESS;
++}
++
++static VAStatus TRANSLATE(SliceParameter,MPEG2)(
++    VACompatContextP    ctx,
++    void               *dest_buffer,
++    const void         *src_buffer
++)
++{
++    STRUCT(SliceParameter,MPEG2) *dest = dest_buffer;
++    const VASliceParameterBufferMPEG2 *src = src_buffer;
++
++    COPY_FIELD(dest, src, slice_data_size);
++    COPY_FIELD(dest, src, slice_data_offset);
++    COPY_FIELD(dest, src, slice_data_flag);
++    COPY_FIELD(dest, src, macroblock_offset);
++    COPY_FIELD(dest, src, slice_vertical_position);
++    COPY_FIELD(dest, src, quantiser_scale_code);
++    COPY_FIELD(dest, src, intra_slice_flag);
++
++    return VA_STATUS_SUCCESS;
++}
++#endif
++
++static VAStatus TRANSLATE(PictureParameter,MPEG4)(
++    VACompatContextP    ctx,
++    void               *dest_buffer,
++    const void         *src_buffer
++)
++{
++    STRUCT(PictureParameter,MPEG4) *dest = dest_buffer;
++    const VAPictureParameterBufferMPEG4 *src = src_buffer;
++
++    COPY_FIELD(dest, src, vop_width);
++    COPY_FIELD(dest, src, vop_height);
++    COPY_FIELD(dest, src, forward_reference_picture);
++    COPY_FIELD(dest, src, backward_reference_picture);
++    dest->BFV(vol_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, vol_fields, short_video_header);
++    COPY_BIT_FIELD(dest, src, vol_fields, chroma_format);
++    COPY_BIT_FIELD(dest, src, vol_fields, interlaced);
++    COPY_BIT_FIELD(dest, src, vol_fields, obmc_disable);
++    COPY_BIT_FIELD(dest, src, vol_fields, sprite_enable);
++    COPY_BIT_FIELD(dest, src, vol_fields, sprite_warping_accuracy);
++    COPY_BIT_FIELD(dest, src, vol_fields, quant_type);
++    COPY_BIT_FIELD(dest, src, vol_fields, quarter_sample);
++    COPY_BIT_FIELD(dest, src, vol_fields, data_partitioned);
++    COPY_BIT_FIELD(dest, src, vol_fields, reversible_vlc);
++    COPY_FIELD(dest, src, no_of_sprite_warping_points);
++    COPY_ARRAY(dest, src, sprite_trajectory_du);
++    COPY_ARRAY(dest, src, sprite_trajectory_dv);
++    COPY_FIELD(dest, src, quant_precision);
++    dest->BFV(vop_fields, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, vop_fields, vop_coding_type);
++    COPY_BIT_FIELD(dest, src, vop_fields, backward_reference_vop_coding_type);
++    COPY_BIT_FIELD(dest, src, vop_fields, vop_rounding_type);
++    COPY_BIT_FIELD(dest, src, vop_fields, intra_dc_vlc_thr);
++    COPY_BIT_FIELD(dest, src, vop_fields, top_field_first);
++    COPY_BIT_FIELD(dest, src, vop_fields, alternate_vertical_scan_flag);
++    COPY_FIELD(dest, src, vop_fcode_forward);
++    COPY_FIELD(dest, src, vop_fcode_backward);
++    COPY_FIELD(dest, src, num_gobs_in_vop);
++    COPY_FIELD(dest, src, num_macroblocks_in_gob);
++    COPY_FIELD(dest, src, TRB);
++    COPY_FIELD(dest, src, TRD);
++
++    return VA_STATUS_SUCCESS;
++}
++
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 30
++static VAStatus TRANSLATE_(VAEncSliceParameterBuffer)(
++    VACompatContextP    ctx,
++    void               *dest_buffer,
++    const void         *src_buffer
++)
++{
++    MKCOMPAT(VAEncSliceParameterBuffer) * const dest = dest_buffer;
++    const VAEncSliceParameterBuffer * const src = src_buffer;
++
++    COPY_FIELD(dest, src, start_row_number);
++    COPY_FIELD(dest, src, slice_height);
++    dest->BFV(slice_flags, value) = 0; /* reset all bits */
++    COPY_BIT_FIELD(dest, src, slice_flags, is_intra);
++    COPY_BIT_FIELD(dest, src, slice_flags, disable_deblocking_filter_idc);
++
++    return VA_STATUS_SUCCESS;
++}
++#endif
++
++static void TRANSLATE_(VADriverContext)(
++    VACompatContext *dest,
++    const struct MKCOMPAT(VADriverContext) *src
++)
++{
++    VACompatDriverVTable *dest_vtable = &dest->vtable;
++    const struct MKCOMPAT(VADriverVTable) *src_vtable = &src->vtable;
++
++    memset(dest_vtable, 0, sizeof(*dest_vtable));
++    COPY_VTABLE(dest, src, vaTerminate);
++    COPY_VTABLE(dest, src, vaQueryConfigProfiles);
++    COPY_VTABLE(dest, src, vaQueryConfigEntrypoints);
++    COPY_VTABLE(dest, src, vaGetConfigAttributes);
++    COPY_VTABLE(dest, src, vaCreateConfig);
++    COPY_VTABLE(dest, src, vaDestroyConfig);
++    COPY_VTABLE(dest, src, vaQueryConfigAttributes);
++    COPY_VTABLE(dest, src, vaCreateSurfaces);
++    COPY_VTABLE(dest, src, vaDestroySurfaces);
++    COPY_VTABLE(dest, src, vaCreateContext);
++    COPY_VTABLE(dest, src, vaDestroyContext);
++    COPY_VTABLE(dest, src, vaCreateBuffer);
++    COPY_VTABLE(dest, src, vaBufferSetNumElements);
++    COPY_VTABLE(dest, src, vaMapBuffer);
++    COPY_VTABLE(dest, src, vaUnmapBuffer);
++    COPY_VTABLE(dest, src, vaDestroyBuffer);
++    COPY_VTABLE(dest, src, vaBeginPicture);
++    COPY_VTABLE(dest, src, vaRenderPicture);
++    COPY_VTABLE(dest, src, vaEndPicture);
++    COPY_VTABLE(dest, src, vaQuerySurfaceStatus);
++    COPY_VTABLE(dest, src, vaPutSurface);
++    COPY_VTABLE(dest, src, vaQueryImageFormats);
++    COPY_VTABLE(dest, src, vaCreateImage);
++    COPY_VTABLE(dest, src, vaDeriveImage);
++    COPY_VTABLE(dest, src, vaDestroyImage);
++    COPY_VTABLE(dest, src, vaSetImagePalette);
++    COPY_VTABLE(dest, src, vaGetImage);
++    COPY_VTABLE(dest, src, vaQuerySubpictureFormats);
++    COPY_VTABLE(dest, src, vaCreateSubpicture);
++    COPY_VTABLE(dest, src, vaDestroySubpicture);
++    COPY_VTABLE(dest, src, vaSetSubpictureImage);
++    COPY_VTABLE(dest, src, vaSetSubpictureChromakey);
++    COPY_VTABLE(dest, src, vaSetSubpictureGlobalAlpha);
++    COPY_VTABLE(dest, src, vaDeassociateSubpicture);
++    COPY_VTABLE(dest, src, vaQueryDisplayAttributes);
++    COPY_VTABLE(dest, src, vaGetDisplayAttributes);
++    COPY_VTABLE(dest, src, vaSetDisplayAttributes);
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR <= 29
++    COPY_VTABLE(dest, src, vaSetSubpicturePalette);
++    COPY_VTABLE(dest, src, vaDbgCopySurfaceToBuffer);
++#endif
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR >= 30
++    COPY_VTABLE(dest, src, vaCreateSurfaceFromCIFrame);
++    COPY_VTABLE(dest, src, vaCreateSurfaceFromV4L2Buf);
++    COPY_VTABLE(dest, src, vaCopySurfaceToBuffer);
++#endif
++#if COMPAT_MAJOR == 0 && COMPAT_MINOR >= 31
++    COPY_VTABLE(dest, src, vaSyncSurface);
++    COPY_VTABLE(dest, src, vaPutImage);
++    COPY_VTABLE(dest, src, vaAssociateSubpicture);
++#else
++    COPY_VTABLE_(dest, pre31, src, vaSyncSurface);
++    COPY_VTABLE_(dest, pre31, src, vaPutImage);
++    COPY_VTABLE_(dest, pre31, src, vaPutImage2);
++    COPY_VTABLE_(dest, pre31, src, vaAssociateSubpicture);
++    COPY_VTABLE_(dest, pre31, src, vaAssociateSubpicture2);
++#endif
++}
++
++#undef COMPAT_MAJOR
++#undef COMPAT_MINOR
diff --git a/meta-emenlow/packages/libva/libva-0.31.0/392_compat.dso.patch b/meta-emenlow/packages/libva/libva-0.31.0/392_compat.dso.patch
new file mode 100644
index 0000000000..57ae44f9d4
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva-0.31.0/392_compat.dso.patch
@@ -0,0 +1,183 @@
+commit 389323f728fb2d6392d266d967eddde40465fd93
+Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com>
+Date:   Fri Oct 16 12:35:27 2009 +0000
+
+    Fix compatibility with older programs linked against libva.so.0.
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index 232d8e8..2d696f1 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -72,3 +72,8 @@ EXTRA_DIST = \
+ 	va_compat_template.h
+ 
+ va_compat.c: va_compat_template.h
++
++lib_LTLIBRARIES			+= libva-compat.la
++libva_compat_la_SOURCES		= va_compat_lib.c
++libva_compat_la_LIBADD		= libva-x11.la -ldl
++libva_compat_la_DEPENDENCIES	= libva-x11.la
+diff --git a/src/va_compat_lib.c b/src/va_compat_lib.c
+new file mode 100644
+index 0000000..b7e9ea5
+--- /dev/null
++++ b/src/va_compat_lib.c
+@@ -0,0 +1,158 @@
++/*
++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a
++ * copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sub license, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject to
++ * the following conditions:
++ * 
++ * The above copyright notice and this permission notice (including the
++ * next paragraph) shall be included in all copies or substantial portions
++ * of the Software.
++ * 
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.
++ */
++
++#define _GNU_SOURCE 1
++#include <dlfcn.h>
++#include <assert.h>
++#include <stddef.h>
++
++typedef void           *VADisplay;
++typedef int             VAStatus;
++typedef unsigned int    VAGenericID;
++typedef VAGenericID     VAContextID;
++typedef VAGenericID     VASurfaceID;
++typedef VAGenericID     VAImageID;
++typedef VAGenericID     VASubpictureID;
++
++#define PREPARE_FUNC(NAME, RET, ARGS)           \
++    static RET (*lib_##NAME) ARGS;              \
++    if (lib_##NAME == NULL)                     \
++        lib_##NAME = dlsym(RTLD_NEXT, #NAME);   \
++    assert(lib_##NAME != NULL)
++
++VAStatus
++vaSyncSurface(
++    VADisplay           dpy,
++    VAContextID         context,
++    VASurfaceID         render_target
++)
++{
++    PREPARE_FUNC(vaSyncSurface, VAStatus, (VADisplay, VASurfaceID));
++
++    return lib_vaSyncSurface(dpy, render_target);
++}
++
++VAStatus
++vaPutImage(
++    VADisplay           dpy,
++    VASurfaceID         surface,
++    VAImageID           image,
++    int                 src_x,
++    int                 src_y,
++    unsigned int        width,
++    unsigned int        height,
++    int                 dest_x,
++    int                 dest_y
++)
++{
++    PREPARE_FUNC(vaPutImage, VAStatus, (VADisplay, VASurfaceID, VAImageID,
++                                        int, int, unsigned int, unsigned int,
++                                        int, int, unsigned int, unsigned int));
++
++    return lib_vaPutImage(dpy, surface, image,
++                          src_x, src_y, width, height,
++                          dest_x, dest_y, width, height);
++}
++
++VAStatus
++vaPutImage2(
++    VADisplay           dpy,
++    VASurfaceID         surface,
++    VAImageID           image,
++    int                 src_x,
++    int                 src_y,
++    unsigned int        src_width,
++    unsigned int        src_height,
++    int                 dest_x,
++    int                 dest_y,
++    unsigned int        dest_width,
++    unsigned int        dest_height
++)
++{
++    PREPARE_FUNC(vaPutImage, VAStatus, (VADisplay, VASurfaceID, VAImageID,
++                                        int, int, unsigned int, unsigned int,
++                                        int, int, unsigned int, unsigned int));
++
++    return lib_vaPutImage(dpy, surface, image,
++                          src_x, src_y, src_width, src_height,
++                          dest_x, dest_y, dest_width, dest_height);
++}
++
++VAStatus
++vaAssociateSubpicture(
++    VADisplay           dpy,
++    VASubpictureID      subpicture,
++    VASurfaceID        *target_surfaces,
++    int                 num_surfaces,
++    short               src_x,
++    short               src_y,
++    short               dest_x,
++    short               dest_y,
++    unsigned short      width,
++    unsigned short      height,
++    unsigned int        flags
++)
++{
++    PREPARE_FUNC(vaAssociateSubpicture,
++                 VAStatus, (VADisplay, VASubpictureID, VASurfaceID *, int,
++                            short, short, unsigned short, unsigned short,
++                            short, short, unsigned short, unsigned short,
++                            unsigned int));
++
++    return lib_vaAssociateSubpicture(dpy, subpicture,
++                                     target_surfaces, num_surfaces,
++                                     src_x, src_y, width, height,
++                                     dest_x, dest_y, width, height,
++                                     flags);
++}
++
++VAStatus
++vaAssociateSubpicture2(
++    VADisplay           dpy,
++    VASubpictureID      subpicture,
++    VASurfaceID        *target_surfaces,
++    int                 num_surfaces,
++    short               src_x,
++    short               src_y,
++    unsigned short      src_width,
++    unsigned short      src_height,
++    short               dest_x,
++    short               dest_y,
++    unsigned short      dest_width,
++    unsigned short      dest_height,
++    unsigned int        flags
++)
++{
++    PREPARE_FUNC(vaAssociateSubpicture,
++                 VAStatus, (VADisplay, VASubpictureID, VASurfaceID *, int,
++                            short, short, unsigned short, unsigned short,
++                            short, short, unsigned short, unsigned short,
++                            unsigned int));
++
++    return lib_vaAssociateSubpicture(dpy, subpicture,
++                                     target_surfaces, num_surfaces,
++                                     src_x, src_y, src_width, src_height,
++                                     dest_x, dest_y, dest_width, dest_height,
++                                     flags);
++}
diff --git a/meta-emenlow/packages/libva/libva_0.31.0.bb b/meta-emenlow/packages/libva/libva_0.31.0.bb
new file mode 100644
index 0000000000..52cd599957
--- /dev/null
+++ b/meta-emenlow/packages/libva/libva_0.31.0.bb
@@ -0,0 +1,35 @@
+DESCRIPTION = "Video Acceleration (VA) API for Linux"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://COPYING;md5=efc13a0998e678466e556756613c582e"
+PR = "r0"
+
+inherit autotools
+
+SRC_URI = "https://launchpad.net/~gma500/+archive/ppa/+files/libva_0.31.0-1+sds9.1ubuntu1.tar.gz \
+	file://033_g45_add_rgba_subpic.patch;patch=1 \
+	file://034_g45_fix_return_for_unimpl.patch;patch=1 \
+	file://035_g45_add_yv12_image_format.patch;patch=1 \
+	file://036_g45_add_vaGetImage.patch;patch=1 \
+	file://037_g45_add_vaPutImage.patch;patch=1 \
+	file://038_g45_vaPutSurface_cliprects.patch;patch=1 \
+	file://102_attribute_visibility.patch;patch=1 \
+	file://103_fix_vainfo_deps.patch;patch=1 \
+	file://104_fix_libva_pkgconfig_deps.patch;patch=1 \
+	file://105_dont_search_LIBGL_DRIVERS_PATH.patch;patch=1 \
+	file://108_drivers_path.patch;patch=1 \
+	file://203_fix_fglrx_detection.patch;patch=1 \
+	file://204_check_ATIFGLEXTENSION.patch;patch=1 \
+	file://300_sds_version.patch;patch=1 \
+	file://301_vdpau_mpeg4.patch;patch=1 \
+	file://320_move_vaPutSurface_flags_def.patch;patch=1 \
+	file://321_libva_glx.base.patch;patch=1 \
+	file://322_libva_glx.patch;patch=1 \
+	file://390_compat.base.patch;patch=1 \
+	file://391_compat.patch;patch=1 \
+	file://392_compat.dso.patch;patch=1"
+
+export LDFLAGS="-Wl,-z,defs"
+
+EXTRA_OECONF = "--disable-i965-driver"
+
+FILES_${PN} += "${libdir}/va/drivers/*"
diff --git a/meta-emenlow/packages/linux/linux-2.6.33.2/defconfig b/meta-emenlow/packages/linux/linux-2.6.33.2/defconfig
new file mode 100644
index 0000000000..7aa76d9177
--- /dev/null
+++ b/meta-emenlow/packages/linux/linux-2.6.33.2/defconfig
@@ -0,0 +1,55 @@
+CONFIG_X86_32=y
+CONFIG_PRINTK=y
+
+# Basic hardware support for the box - network, USB, PCI
+CONFIG_NETDEVICES=y
+CONFIG_NETDEV_1000=y
+CONFIG_ATA=y
+CONFIG_ATA_GENERIC=y
+CONFIG_ATA_SFF=y
+CONFIG_PCI=y
+CONFIG_MMC=y
+CONFIG_MMC_SDHCI=y
+CONFIG_USB_SUPPORT=y
+CONFIG_USB=y
+CONFIG_USB_ARCH_HAS_EHCI=y
+CONFIG_E1000E=y
+CONFIG_PATA_SCH=y
+CONFIG_MMC_SDHCI_PCI=y
+CONFIG_USB_EHCI_HCD=y
+CONFIG_PCIEPORTBUS=y
+CONFIG_NET=y
+CONFIG_USB_UHCI_HCD=y
+CONFIG_BLK_DEV_SD=y
+CONFIG_CHR_DEV_SG=y
+
+# Make sure these are on, otherwise the bootup won't be fun
+CONFIG_EXT3_FS=y
+CONFIG_UNIX=y
+CONFIG_INET=y
+CONFIG_MODULES=y
+CONFIG_SHMEM=y
+CONFIG_TMPFS=y
+CONFIG_PACKET=y
+
+# These are needed for the Poulsbo kernel modules
+CONFIG_I2C=y
+CONFIG_AGP=y
+CONFIG_VFAT_FS=y
+CONFIG_PM=y
+CONFIG_ACPI=y
+CONFIG_FB=y
+CONFIG_BACKLIGHT_LCD_SUPPORT=y
+CONFIG_BACKLIGHT_CLASS_DEVICE=y
+CONFIG_INPUT=y
+CONFIG_VIDEO_V4L2=y
+CONFIG_VIDEO_IVTV=y
+CONFIG_MEDIA_SUPPORT=y
+CONFIG_VIDEO_CAPTURE_DRIVERS=y
+CONFIG_VIDEO_DEV=y
+CONFIG_VIDEO_V4L2_COMMON=y
+CONFIG_I2C_ALGOBIT=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_VIDEO_FB_IVTV=y
diff --git a/meta-emenlow/packages/linux/linux_2.6.33.2.bbappend b/meta-emenlow/packages/linux/linux_2.6.33.2.bbappend
new file mode 100644
index 0000000000..fac0921401
--- /dev/null
+++ b/meta-emenlow/packages/linux/linux_2.6.33.2.bbappend
@@ -0,0 +1,3 @@
+FILESPATH := "${FILESPATH}:${@os.path.dirname(bb.data.getVar('FILE', d, True))}"
+SRC_URI += "file://defconfig"
+COMPATIBLE_MACHINE_emenlow = "emenlow"
diff --git a/meta-emenlow/packages/psb-firmware/psb-firmware_0.30.bb b/meta-emenlow/packages/psb-firmware/psb-firmware_0.30.bb
new file mode 100644
index 0000000000..0a4117397b
--- /dev/null
+++ b/meta-emenlow/packages/psb-firmware/psb-firmware_0.30.bb
@@ -0,0 +1,13 @@
+DESCRIPTION = "Binary firmware for the Poulsbo (psb) 3D X11 driver"
+LICENSE = "Intel-binary-only"
+LIC_FILES_CHKSUM = "file://COPYING;md5=02c597a2f082b4581596065bb5a521a8"
+PR = "r0"
+
+SRC_URI = "https://launchpad.net/~gma500/+archive/ppa/+files/psb-firmware_0.30-0ubuntu1netbook1ubuntu1.tar.gz"
+
+do_install() {
+        install -d ${D}${base_libdir}/firmware/
+	install -m 0644 ${WORKDIR}/psb-firmware-0.30/msvdx_fw.bin ${D}${base_libdir}/firmware/
+}
+
+FILES_${PN} += "${base_libdir}/firmware/msvdx_fw.bin"
diff --git a/meta-emenlow/packages/psb-kernel-source/psb-kernel-source-4.42.0/build.patch b/meta-emenlow/packages/psb-kernel-source/psb-kernel-source-4.42.0/build.patch
new file mode 100644
index 0000000000..ce6f2aa41b
--- /dev/null
+++ b/meta-emenlow/packages/psb-kernel-source/psb-kernel-source-4.42.0/build.patch
@@ -0,0 +1,175 @@
+# These are various fixes needed to make the psb kernel driver build against
+# 2.6.33.2.
+# The Makefile patch is specific to the Poky environment - the external kernel
+# module build expects the kernel tree it's building against to have fixdep
+# and modpost built, which isn't the case here.  So, the modules rule makes
+# sure that they are built before the module is built.
+# Aside from that, the changes involve adding missing header files and 
+# compensating for a structure field changing name and type.
+
+Index: psb-kernel-source-4.42.0/drm_os_linux.h
+===================================================================
+--- psb-kernel-source-4.42.0.orig/drm_os_linux.h
++++ psb-kernel-source-4.42.0/drm_os_linux.h
+@@ -50,12 +50,6 @@
+ 
+ /** IRQ handler arguments and return type and values */
+ #define DRM_IRQ_ARGS		int irq, void *arg
+-/** backwards compatibility with old irq return values */
+-#ifndef IRQ_HANDLED
+-typedef void irqreturn_t;
+-#define IRQ_HANDLED		/* nothing */
+-#define IRQ_NONE		/* nothing */
+-#endif
+ 
+ /** AGP types */
+ #if __OS_HAS_AGP
+Index: psb-kernel-source-4.42.0/Makefile
+===================================================================
+--- psb-kernel-source-4.42.0.orig/Makefile
++++ psb-kernel-source-4.42.0/Makefile
+@@ -165,7 +165,10 @@ endif
+ all: modules
+ 
+ modules: includes
+-	+make -C $(LINUXDIR) $(GETCONFIG) SUBDIRS=`pwd` DRMSRCDIR=`pwd` modules
++	+make -C $(LINUXDIR)/scripts/basic fixdep
++#	+make -C $(LINUXDIR) SUBDIRS=scripts/mod modpost
++	+make -C $(LINUXDIR) SUBDIRS=scripts
++	+make -k -C $(LINUXDIR) $(GETCONFIG) SUBDIRS=`pwd` DRMSRCDIR=`pwd` modules
+ 
+ ifeq ($(HEADERFROMBOOT),1)
+ 
+@@ -243,7 +246,7 @@ dristat: dristat.c
+ drmstat: drmstat.c
+ 	$(CC) $(PRGCFLAGS) $< -o $@ $(DRMSTATLIBS)
+ 
+-install:
++modules_install:
+ 	make -C $(LINUXDIR) $(GETCONFIG) SUBDIRS=`pwd` DRMSRCDIR=`pwd` modules_install
+ 
+ else
+Index: psb-kernel-source-4.42.0/drm_edid.c
+===================================================================
+--- psb-kernel-source-4.42.0.orig/drm_edid.c
++++ psb-kernel-source-4.42.0/drm_edid.c
+@@ -11,6 +11,7 @@
+ #include "drm_edid.h"
+ 
+ #include <acpi/acpi_drivers.h>
++#include <linux/i2c.h>
+ 
+ /* Valid EDID header has these bytes */
+ static u8 edid_header[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 };
+@@ -39,7 +40,7 @@ int drm_get_acpi_edid(char *method, char
+ 	if (obj && obj->type == ACPI_TYPE_BUFFER)
+ 		memcpy(edid, obj->buffer.pointer, obj->buffer.length);
+ 	else {
+-		printk(KERN_ERR PREFIX "Invalid _DDC data\n");
++		printk(KERN_ERR "Invalid _DDC data\n");
+ 		status = -EFAULT;
+ 		kfree(obj);
+ 	}
+Index: psb-kernel-source-4.42.0/drm_ttm.c
+===================================================================
+--- psb-kernel-source-4.42.0.orig/drm_ttm.c
++++ psb-kernel-source-4.42.0/drm_ttm.c
+@@ -28,6 +28,8 @@
+  * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+  */
+ 
++#include "linux/spinlock.h"
++#include "asm/agp.h"
+ #include "drmP.h"
+ 
+ static void drm_ttm_ipi_handler(void *null)
+Index: psb-kernel-source-4.42.0/psb_drv.c
+===================================================================
+--- psb-kernel-source-4.42.0.orig/psb_drv.c
++++ psb-kernel-source-4.42.0/psb_drv.c
+@@ -34,8 +34,10 @@
+ #include <linux/cpu.h>
+ #include <linux/notifier.h>
+ #include <linux/fb.h>
++#include "linux/spinlock.h"
++#include "asm/agp.h"
+ 
+-int drm_psb_debug = 0;
++int drm_psb_debug = 255;
+ EXPORT_SYMBOL(drm_psb_debug);
+ static int drm_psb_trap_pagefaults = 0;
+ static int drm_psb_clock_gating = 0;
+Index: psb-kernel-source-4.42.0/intel_lvds.c
+===================================================================
+--- psb-kernel-source-4.42.0.orig/intel_lvds.c
++++ psb-kernel-source-4.42.0/intel_lvds.c
+@@ -29,6 +29,7 @@
+ 
+ #include <linux/i2c.h>
+ #include <linux/backlight.h>
++#include <linux/i2c.h>
+ #include "drm_crtc.h"
+ #include "drm_edid.h"
+ #include "intel_lvds.h"
+Index: psb-kernel-source-4.42.0/drm_memory.c
+===================================================================
+--- psb-kernel-source-4.42.0.orig/drm_memory.c
++++ psb-kernel-source-4.42.0/drm_memory.c
+@@ -264,9 +264,9 @@ static void *agp_remap(unsigned long off
+ 		return NULL;
+ 
+ 	phys_addr_map =
+-	    agpmem->memory->memory + (offset - agpmem->bound) / PAGE_SIZE;
++	    agpmem->memory->pages + (offset - agpmem->bound) / PAGE_SIZE;
+ 	for (i = 0; i < num_pages; ++i)
+-		page_map[i] = pfn_to_page(phys_addr_map[i] >> PAGE_SHIFT);
++                page_map[i] = phys_addr_map[i];
+ 	addr = vmap(page_map, num_pages, VM_IOREMAP, PAGE_AGP);
+ 	vfree(page_map);
+ 
+Index: psb-kernel-source-4.42.0/drm_agpsupport.c
+===================================================================
+--- psb-kernel-source-4.42.0.orig/drm_agpsupport.c
++++ psb-kernel-source-4.42.0/drm_agpsupport.c
+@@ -524,7 +524,7 @@ static int drm_agp_populate(struct drm_t
+ 	DRM_DEBUG("Current page count is %ld\n", (long) mem->page_count);
+ 	mem->page_count = 0;
+ 	for (cur_page = pages; cur_page < last_page; ++cur_page)
+-		mem->pages[mem->page_count++] = phys_to_gart(page_to_phys(*cur_page));
++		mem->pages[mem->page_count++] = page_to_phys(*cur_page);
+ 	agp_be->mem = mem;
+ 	return 0;
+ }
+Index: psb-kernel-source-4.42.0/drm_vm.c
+===================================================================
+--- psb-kernel-source-4.42.0.orig/drm_vm.c
++++ psb-kernel-source-4.42.0/drm_vm.c
+@@ -145,13 +145,13 @@ static int drm_do_vm_fault(struct vm_are
+ 		 * Get the page, inc the use count, and return it
+ 		 */
+ 		offset = (baddr - agpmem->bound) >> PAGE_SHIFT;
+-		page = virt_to_page(__va(agpmem->memory->memory[offset]));
++		page = agpmem->memory->pages[offset];
+ 		get_page(page);
+ 		vmf->page = page;
+ 
+ 		DRM_DEBUG
+ 		    ("baddr = 0x%lx page = 0x%p, offset = 0x%lx, count=%d\n",
+-		     baddr, __va(agpmem->memory->memory[offset]), offset,
++		     baddr, agpmem->memory->pages[offset], offset,
+ 		     page_count(page));
+ 		return 0;
+ 	}
+Index: psb-kernel-source-4.42.0/psb_drv.h
+===================================================================
+--- psb-kernel-source-4.42.0.orig/psb_drv.h
++++ psb-kernel-source-4.42.0/psb_drv.h
+@@ -809,7 +809,7 @@ extern int drm_psb_detear;
+ #define PSB_DEBUG(_flag, _fmt, _arg...)					\
+ 	do {								\
+ 	  if (unlikely((_flag) & drm_psb_debug))			\
+-			printk(KERN_DEBUG				\
++			printk(KERN_ERR				\
+ 			       "[psb:0x%02x:%s] " _fmt , _flag,	\
+ 			       __FUNCTION__ , ##_arg);			\
+ 	} while (0)
diff --git a/meta-emenlow/packages/psb-kernel-source/psb-kernel-source_4.42.0.bb b/meta-emenlow/packages/psb-kernel-source/psb-kernel-source_4.42.0.bb
new file mode 100644
index 0000000000..b6a0a3a7a0
--- /dev/null
+++ b/meta-emenlow/packages/psb-kernel-source/psb-kernel-source_4.42.0.bb
@@ -0,0 +1,22 @@
+DESCRIPTION = "Kernel module for the Poulsbo (psb) 2D X11 driver"
+LICENSE = "GPLv2"
+LIC_FILES_CHKSUM = "file://GPLv2_License.txt;md5=f5ca3155cfeaa64a6ea228b11ad6916d"
+PR = "r1"
+
+inherit module
+
+SRC_URI = "https://launchpad.net/~gma500/+archive/ppa/+files/psb-kernel-source_4.42.0-0ubuntu2~1004um2.tar.gz \
+	file://build.patch;patch=1"
+
+do_compile () {
+	oe_runmake LINUXDIR=${STAGING_KERNEL_DIR} DRM_MODULES="psb"
+}
+
+do_install () {
+        mkdir -p ${D}/lib/modules/${KERNEL_VERSION}/extra
+        cp ${WORKDIR}/${PN}-${PV}/*.ko ${D}/lib/modules/${KERNEL_VERSION}/extra
+}
+
+FILES_${PN} += "${base_libdir}/modules/${KERNEL_VERSION}/extra/*.ko"
+
+DEPENDS += "virtual/kernel"
diff --git a/meta-emenlow/packages/xorg-xserver/files/crosscompile.patch b/meta-emenlow/packages/xorg-xserver/files/crosscompile.patch
new file mode 100644
index 0000000000..2341e40bca
--- /dev/null
+++ b/meta-emenlow/packages/xorg-xserver/files/crosscompile.patch
@@ -0,0 +1,19 @@
+Index: xorg-server-1.7.99.2/configure.ac
+===================================================================
+--- xorg-server-1.7.99.2.orig/configure.ac	2010-01-29 16:38:49.000000000 +0000
++++ xorg-server-1.7.99.2/configure.ac	2010-01-29 16:42:39.000000000 +0000
+@@ -503,14 +503,10 @@
+ 
+ dnl Uses --default-font-path if set, otherwise checks for /etc/X11/fontpath.d,
+ dnl otherwise uses standard subdirectories of FONTROOTDIR
+-AC_CHECK_FILE([${sysconfdir}/X11/fontpath.d],
+-	[DEFAULT_FONT_PATH='catalogue:${sysconfdir}/X11/fontpath.d'],
+-	[
+ 		DEFAULT_FONT_PATH="${FONTMISCDIR}/,${FONTTTFDIR}/,${FONTOTFDIR}/,${FONTTYPE1DIR}/,${FONT100DPIDIR}/,${FONT75DPIDIR}/"
+ 		case $host_os in
+ 			darwin*)    DEFAULT_FONT_PATH="${DEFAULT_FONT_PATH},/Library/Fonts,/System/Library/Fonts" ;;
+ 		esac
+-	])
+ AC_ARG_WITH(default-font-path, AS_HELP_STRING([--with-default-font-path=PATH], [Comma separated list of font dirs]),
+ 				[ FONTPATH="$withval" ],
+ 				[ FONTPATH="${DEFAULT_FONT_PATH}" ])
diff --git a/meta-emenlow/packages/xorg-xserver/files/fix_open_max_preprocessor_error.patch b/meta-emenlow/packages/xorg-xserver/files/fix_open_max_preprocessor_error.patch
new file mode 100644
index 0000000000..565832eed8
--- /dev/null
+++ b/meta-emenlow/packages/xorg-xserver/files/fix_open_max_preprocessor_error.patch
@@ -0,0 +1,13 @@
+Index: git/os/osdep.h
+===================================================================
+--- git.orig/os/osdep.h	2008-10-07 18:38:21.000000000 +0100
++++ git/os/osdep.h	2008-10-07 18:39:36.000000000 +0100
+@@ -92,7 +92,7 @@
+  * like sysconf(_SC_OPEN_MAX) is not supported.
+  */
+ 
+-#if OPEN_MAX <= 256
++#if 0
+ #define MAXSOCKS (OPEN_MAX - 1)
+ #else
+ #define MAXSOCKS 256
diff --git a/meta-emenlow/packages/xorg-xserver/files/macro_tweak.patch b/meta-emenlow/packages/xorg-xserver/files/macro_tweak.patch
new file mode 100644
index 0000000000..6998adffe9
--- /dev/null
+++ b/meta-emenlow/packages/xorg-xserver/files/macro_tweak.patch
@@ -0,0 +1,18 @@
+Index: xorg-server-1.5.0/xorg-server.m4
+===================================================================
+--- xorg-server-1.5.0.orig/xorg-server.m4	2007-05-29 20:36:51.000000000 +0100
++++ xorg-server-1.5.0/xorg-server.m4	2008-11-04 23:56:55.000000000 +0000
+@@ -28,9 +28,12 @@
+ # Checks for the $1 define in xorg-server.h (from the sdk).  If it
+ # is defined, then add $1 to $REQUIRED_MODULES.
+ 
++m4_pattern_allow(PKG_CONFIG_SYSROOT_DIR)
++
+ AC_DEFUN([XORG_DRIVER_CHECK_EXT],[
++	PKG_PROG_PKG_CONFIG
+ 	SAVE_CFLAGS="$CFLAGS"
+-	CFLAGS="$CFLAGS -I`pkg-config --variable=sdkdir xorg-server`"
++	CFLAGS="$CFLAGS -I$PKG_CONFIG_SYSROOT_DIR`pkg-config --variable=sdkdir xorg-server`"
+ 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+ #include "xorg-server.h"
+ #if !defined $1
diff --git a/meta-emenlow/packages/xorg-xserver/files/nodolt.patch b/meta-emenlow/packages/xorg-xserver/files/nodolt.patch
new file mode 100644
index 0000000000..6b34032a39
--- /dev/null
+++ b/meta-emenlow/packages/xorg-xserver/files/nodolt.patch
@@ -0,0 +1,12 @@
+Index: git/configure.ac
+===================================================================
+--- git.orig/configure.ac	2009-01-15 20:35:31.000000000 +0000
++++ git/configure.ac	2009-01-15 20:35:38.000000000 +0000
+@@ -62,7 +62,6 @@
+ AC_LIBTOOL_WIN32_DLL
+ AC_DISABLE_STATIC
+ AC_PROG_LIBTOOL
+-DOLT
+ AC_PROG_MAKE_SET
+ PKG_PROG_PKG_CONFIG
+ AC_PROG_LEX
diff --git a/meta-emenlow/packages/xorg-xserver/xserver-psb_1.7.99.2.bb b/meta-emenlow/packages/xorg-xserver/xserver-psb_1.7.99.2.bb
new file mode 100644
index 0000000000..d6ecdae259
--- /dev/null
+++ b/meta-emenlow/packages/xorg-xserver/xserver-psb_1.7.99.2.bb
@@ -0,0 +1,17 @@
+require ../meta/packages/xorg-xserver/xserver-xf86-dri-lite.inc
+
+PR = "r1"
+
+PROTO_DEPS += "xf86driproto dri2proto"
+
+DEPENDS += "font-util"
+
+SRC_URI += "file://nodolt.patch;patch=1 \
+            file://crosscompile.patch;patch=1"
+
+# Misc build failure for master HEAD
+SRC_URI += "file://fix_open_max_preprocessor_error.patch;patch=1"
+
+EXTRA_OECONF += "--enable-dri --enable-dri2 --enable-dga --enable-glx"
+
+DEPENDS += "psb-firmware xpsb-glx psb-kernel-source libdrm-poulsbo libva"
diff --git a/meta-emenlow/packages/xorg-xserver/xserver-xf86-config/xorg.conf b/meta-emenlow/packages/xorg-xserver/xserver-xf86-config/xorg.conf
new file mode 100644
index 0000000000..6846263839
--- /dev/null
+++ b/meta-emenlow/packages/xorg-xserver/xserver-xf86-config/xorg.conf
@@ -0,0 +1,13 @@
+Section "ServerFlags"
+    Option "AutoAddDevices" "False"
+EndSection
+
+Section "Device"
+    Identifier	"Configured Video Device"
+    Driver	"psb"
+    Option	"ShadowFB" "False"
+EndSection
+
+Section "DRI"
+    Mode 0666
+EndSection
diff --git a/meta-emenlow/packages/xorg-xserver/xserver-xf86-config_0.1.bbappend b/meta-emenlow/packages/xorg-xserver/xserver-xf86-config_0.1.bbappend
new file mode 100644
index 0000000000..1e9c3789e5
--- /dev/null
+++ b/meta-emenlow/packages/xorg-xserver/xserver-xf86-config_0.1.bbappend
@@ -0,0 +1 @@
+FILESPATH := "${FILESPATH}:${@os.path.dirname(bb.data.getVar('FILE', d, True))}"
diff --git a/meta-emenlow/packages/xpsb-glx/xpsb-glx-0.18/cross-compile.patch b/meta-emenlow/packages/xpsb-glx/xpsb-glx-0.18/cross-compile.patch
new file mode 100644
index 0000000000..a231596810
--- /dev/null
+++ b/meta-emenlow/packages/xpsb-glx/xpsb-glx-0.18/cross-compile.patch
@@ -0,0 +1,58 @@
+Index: mesa/configs/linux-dri
+===================================================================
+--- mesa.orig/configs/linux-dri
++++ mesa/configs/linux-dri
+@@ -3,11 +3,9 @@
+ 
+ include $(TOP)/configs/default
+ 
+-CONFIG_NAME = linux-dri
++$(warning ENVIRONMENT = $(shell printenv))
+ 
+-# Compiler and flags
+-CC = gcc
+-CXX = g++
++CONFIG_NAME = linux-dri
+ 
+ #MKDEP = /usr/X11R6/bin/makedepend
+ #MKDEP = gcc -M
+@@ -25,8 +23,6 @@ DEFINES = -D_POSIX_SOURCE -D_POSIX_C_SOU
+ 	-DGLX_DIRECT_RENDERING -DGLX_INDIRECT_RENDERING \
+ 	-DHAVE_ALIAS -DHAVE_POSIX_MEMALIGN
+ 
+-X11_INCLUDES = -I/usr/X11R6/include
+-
+ CFLAGS = -Wall -Wmissing-prototypes -std=c99 -ffast-math \
+ 	$(OPT_FLAGS) $(PIC_FLAGS) $(ARCH_FLAGS) $(DEFINES) $(ASM_FLAGS)
+ 
+@@ -40,9 +36,6 @@ CXXFLAGS += -fno-strict-aliasing
+ 
+ ASM_SOURCES = 
+ 
+-# Library/program dependencies
+-EXTRA_LIB_PATH=-L/usr/X11R6/lib
+-
+ LIBDRM_CFLAGS = `pkg-config --cflags libdrm-poulsbo`
+ LIBDRM_LIB = `pkg-config --libs libdrm-poulsbo`
+ DRI_LIB_DEPS  = $(EXTRA_LIB_PATH) -lm -lpthread -lexpat -ldl $(LIBDRM_LIB)
+Index: mesa/configs/default
+===================================================================
+--- mesa.orig/configs/default
++++ mesa/configs/default
+@@ -17,8 +17,6 @@ MESA_VERSION = $(MESA_MAJOR).$(MESA_MINO
+ DRM_SOURCE_PATH=$(TOP)/../drm
+ 
+ # Compiler and flags
+-CC = cc
+-CXX = CC
+ CFLAGS = -O
+ CXXFLAGS = -O
+ LDFLAGS =
+@@ -67,7 +65,6 @@ ASM_SOURCES = 
+ # GLw widget sources (Append "GLwMDrawA.c" here and add -lXm to GLW_LIB_DEPS in
+ # order to build the Motif widget too)
+ GLW_SOURCES = GLwDrawA.c
+-MOTIF_CFLAGS = -I/usr/include/Motif1.2
+ 
+ 
+ # Directories to build
diff --git a/meta-emenlow/packages/xpsb-glx/xpsb-glx_0.18.bb b/meta-emenlow/packages/xpsb-glx/xpsb-glx_0.18.bb
new file mode 100644
index 0000000000..41b15890fa
--- /dev/null
+++ b/meta-emenlow/packages/xpsb-glx/xpsb-glx_0.18.bb
@@ -0,0 +1,40 @@
+DESCRIPTION = "X11 drivers for Poulsbo (psb) 3D acceleration"
+
+# There's a mesa implementation in this package, which is presumably
+# not Intel proprietary, but it has no obvious license attached to it.
+LICENSE = "Intel-binary-only"
+LIC_FILES_CHKSUM = "file://${WORKDIR}/${PN}-${PV}/COPYING;md5=02c597a2f082b4581596065bb5a521a8"
+PR = "r1"
+
+inherit autotools
+
+PROVIDES = "virtual/libgl mesa-dri"
+
+SRC_URI="https://launchpad.net/~gma500/+archive/ppa/+files/xpsb-glx_0.18-0ubuntu1netbook2~1004um1ubuntu1.tar.gz \
+	file://cross-compile.patch;patch=1"
+
+do_configure () {
+	chmod +x autogen.sh && ./autogen.sh && make realclean
+}
+
+do_install() {
+	make DESTDIR=${D} install
+	install -d -m 0755 ${D}/${libdir}/xorg/modules/dri \
+		${D}/${libdir}/xorg/modules/drivers
+	install -m 0644 ${WORKDIR}/${PN}-${PV}/dri/* \
+		${D}/${libdir}/xorg/modules/dri
+	install -m 0644 ${WORKDIR}/${PN}-${PV}/drivers/* \
+		${D}/${libdir}/xorg/modules/drivers
+}
+
+S = "${WORKDIR}/${PN}-${PV}/mesa"
+
+EXTRA_OEMAKE = "linux-dri-x86"
+
+DEPENDS += "libdrm-poulsbo libxxf86vm dri2proto libxmu libxi glproto"
+
+FILES_${PN} = "${libdir}/* ${libdir}/xorg/modules/dri/* \
+	    ${libdir}/xorg/modules/drivers/*"
+
+# Multiple virtual/gl providers being built breaks staging
+EXCLUDE_FROM_WORLD = "1"
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/01_disable_lid_timer.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/01_disable_lid_timer.patch
new file mode 100644
index 0000000000..47da3bce04
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/01_disable_lid_timer.patch
@@ -0,0 +1,12 @@
+diff -Nurp xserver-xorg-video-psb-0.30.0+repack.orig/src/psb_driver.c xserver-xorg-video-psb-0.30.0+repack/src/psb_driver.c
+--- xserver-xorg-video-psb-0.30.0+repack.orig/src/psb_driver.c	2009-04-17 00:00:46.000000000 +0200
++++ xserver-xorg-video-psb-0.30.0+repack/src/psb_driver.c	2009-08-06 18:13:43.000000000 +0200
+@@ -753,7 +753,7 @@ psbInitOutputs(ScrnInfoPtr pScrn)
+ 
+     xf86GetOptValBool(pPsb->options, OPTION_NOPANEL, &pPsb->noPanel);
+ 
+-    pPsb->lidTimer = TRUE;
++    pPsb->lidTimer = FALSE;
+     xf86GetOptValBool(pPsb->options, OPTION_LIDTIMER, &pPsb->lidTimer);
+ 
+     xf86GetOptValBool(pPsb->options, OPTION_NOFITTING, &pPsb->noFitting);
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/dri-h.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/dri-h.patch
new file mode 100644
index 0000000000..98ffa27199
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/dri-h.patch
@@ -0,0 +1,20 @@
+Index: xserver-xorg-video-psb-0.32.1/configure.ac
+===================================================================
+--- xserver-xorg-video-psb-0.32.1.orig/configure.ac
++++ xserver-xorg-video-psb-0.32.1/configure.ac
+@@ -75,12 +75,9 @@ AM_CONDITIONAL(BUILD_EXA, [test "$build_
+ AC_HEADER_STDC
+ 
+ if test "$DRI" != no; then
+-        AC_CHECK_FILE([${sdkdir}/dri.h],
+-                      [have_dri_h="yes"], [have_dri_h="no"])
+-        AC_CHECK_FILE([${sdkdir}/sarea.h],
+-                      [have_sarea_h="yes"], [have_sarea_h="no"])
+-        AC_CHECK_FILE([${sdkdir}/dristruct.h],
+-                      [have_dristruct_h="yes"], [have_dristruct_h="no"])
++        have_dri_h="yes"
++        have_sarea_h="yes"
++        have_dristruct_h="yes"
+ fi
+ 
+ AC_MSG_CHECKING([whether to include DRI support])
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/psb_mixed.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/psb_mixed.patch
new file mode 100644
index 0000000000..6065fa5cac
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/psb_mixed.patch
@@ -0,0 +1,35 @@
+--- xserver-xorg-video-psb-0.32.1/src/psb_accel.c.orig	2010-07-04 19:27:48.691227698 +0200
++++ xserver-xorg-video-psb-0.32.1/src/psb_accel.c	2010-07-04 19:27:15.338230809 +0200
+@@ -308,6 +308,14 @@
+ }
+ #endif
+ 
++static void*
++psbExaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth, int usage_hint, int bpp, int* new_pitch  )
++{
++	return NULL;
++}
++static void
++psbExaDestroyPixmap(ScreenPtr pScreen, void* driverPriv ){
++}
+ static Bool
+ psbExaPixmapIsOffscreen(PixmapPtr p)
+ {
+@@ -1313,6 +1321,7 @@
+     pExa->pixmapOffsetAlign = 8;
+     pExa->pixmapPitchAlign = 32 * 4;
+     pExa->flags = EXA_OFFSCREEN_PIXMAPS;
++    pExa->flags |= EXA_HANDLES_PIXMAPS | EXA_MIXED_PIXMAPS;
+     pExa->maxX = 2047;
+     pExa->maxY = 2047;
+     pExa->WaitMarker = psbExaWaitMarker;
+@@ -1328,6 +1337,9 @@
+     pExa->Composite = psbExaSuperComposite;
+     pExa->DoneComposite = psbExaDoneComposite;
+     pExa->PixmapIsOffscreen = psbExaPixmapIsOffscreen;
++	pExa->CreatePixmap = NULL;
++	pExa->CreatePixmap2 = psbExaCreatePixmap;
++	pExa->DestroyPixmap = psbExaDestroyPixmap;
+     pExa->PrepareAccess = psbExaPrepareAccess;
+     pExa->FinishAccess = psbExaFinishAccess;
+     pExa->UploadToScreen = psbExaUploadToScreen;
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/psb_xvtempfix.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/psb_xvtempfix.patch
new file mode 100644
index 0000000000..34798c07e9
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/psb_xvtempfix.patch
@@ -0,0 +1,17 @@
+--- xserver-xorg-video-psb-0.36.0-ref/src/psb_video.c	2010-06-07 22:17:46.302760345 +0200
++++ xserver-xorg-video-psb-0.32/src/psb_video.c	2010-06-10 17:29:23.400003434 +0200
+@@ -686,8 +684,13 @@
+      * coordinates) to the backing pixmap.
+      */
+ 
+-    while (!psbExaGetSuperOffset(pPixmap, &pre_add, &dstBuf))
++    if(!psbExaGetSuperOffset(pPixmap, &pre_add, &dstBuf)){
+ 	exaMoveInPixmap(pPixmap);
++        if(!psbExaGetSuperOffset(pPixmap, &pre_add, &dstBuf)){
++             return FALSE;
++        }
++    }
++	
+ 
+     dst.buffer = mmKernelBuf(dstBuf);
+     dst.offset = pre_add;
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/stubs.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/stubs.patch
new file mode 100644
index 0000000000..b201d7e314
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/stubs.patch
@@ -0,0 +1,23 @@
+diff -p -up xserver-xorg-video-psb-0.31.0/src/psb_driver.c.orig xserver-xorg-video-psb-0.31.0/src/psb_driver.c
+--- xserver-xorg-video-psb-0.31.0/src/psb_driver.c.orig	2010-04-30 08:58:06.798598457 +0200
++++ xserver-xorg-video-psb-0.31.0/src/psb_driver.c	2010-04-30 09:03:04.186597975 +0200
+@@ -643,6 +643,19 @@ psbPreInitDRI(ScrnInfoPtr pScrn)
+     return TRUE;
+ }
+ 
++/* removed in Xserver 1.7, add it again so that proprietary Xpsb can be loaded */
++void
++xf86AddModuleInfo(pointer info, pointer module)
++{
++}
++
++/* removed in mesa, add it again so that proprietary Xpsb can be loaded */
++typedef void (*_glapi_warning_func)(void *ctx, const char *str, ...);
++void
++_glapi_set_warning_func( _glapi_warning_func func )
++{
++}
++
+ static Bool
+ psbPreInitXpsb(ScrnInfoPtr pScrn)
+ {
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/visibility.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/visibility.patch
new file mode 100644
index 0000000000..2c68805871
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/visibility.patch
@@ -0,0 +1,12 @@
+Index: xserver-xorg-video-psb-0.32.1/configure.ac
+===================================================================
+--- xserver-xorg-video-psb-0.32.1.orig/configure.ac
++++ xserver-xorg-video-psb-0.32.1/configure.ac
+@@ -107,6 +107,7 @@ AC_DEFINE(INTEL_PSB_DRIVER, 1, [Compatib
+ 
+ AC_SUBST([DRI_CFLAGS])
+ AC_SUBST([XORG_CFLAGS])
++XORG_CFLAGS = `echo $XORG_CFLAGS | sed 's/hidden/default/'`
+ AC_SUBST([moduledir])
+ 
+ DRIVER_NAME=psb
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xorg-x11-drv-psb-0.31.0-ignoreacpi.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xorg-x11-drv-psb-0.31.0-ignoreacpi.patch
new file mode 100644
index 0000000000..a73a493ec1
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xorg-x11-drv-psb-0.31.0-ignoreacpi.patch
@@ -0,0 +1,11 @@
+--- xserver-xorg-video-psb-0.31.0/src/psb_driver.c	2009-04-17 11:22:26.000000000 -0700
++++ xserver-xorg-video-psb-0.31.0/src/psb_driver.c.new	2009-08-14 15:41:35.047596131 -0700
+@@ -909,7 +909,7 @@
+     xf86DrvMsg(pScrn->scrnIndex, from, "Use %s cursor.\n",
+ 	       pPsb->sWCursor ? "software" : "hardware");
+ 
+-    pPsb->ignoreACPI = FALSE;
++    pPsb->ignoreACPI = TRUE;
+     from =
+ 	xf86GetOptValBool(pPsb->options, OPTION_IGNORE_ACPI,
+ 			  &pPsb->ignoreACPI)
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xorg-x11-drv-psb-0.31.0-xserver17.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xorg-x11-drv-psb-0.31.0-xserver17.patch
new file mode 100644
index 0000000000..defed50363
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xorg-x11-drv-psb-0.31.0-xserver17.patch
@@ -0,0 +1,85 @@
+--- xserver-xorg-video-psb-0.31.0/src/Xpsb.h	2009-04-17 11:22:26.000000000 -0700
++++ xserver-xorg-video-psb-0.31.0/src/Xpsb.h.new	2009-08-28 09:24:16.333677591 -0700
+@@ -38,7 +38,9 @@
+ #include "xf86drm.h"
+ #include "xf86.h"
+ #include "xf86_OSproc.h"
++#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
+ #include "xf86Resources.h"
++#endif
+ #include "compiler.h"
+ 
+ #define XPSB_VOFFSET_X 0
+--- xserver-xorg-video-psb-0.31.0/src/psb_driver.h	2009-04-17 11:22:25.000000000 -0700
++++ xserver-xorg-video-psb-0.31.0/src/psb_driver.h.new	2009-08-28 09:24:11.822679667 -0700
+@@ -34,7 +34,6 @@
+ 
+ #include "xf86.h"
+ #include "xf86_OSproc.h"
+-#include "xf86Resources.h"
+ #include "compiler.h"
+ #include "xf86PciInfo.h"
+ #include "vgaHW.h"
+@@ -46,8 +45,10 @@
+ #include "xf86int10.h"
+ #include "mibank.h"
+ #include "dgaproc.h"
++#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
+ #include "xf86Resources.h"
+ #include "xf86RAC.h"
++#endif
+ #include "fb.h"
+ #include "xaa.h"
+ #include "xf86xv.h"
+--- xserver-xorg-video-psb-0.31.0/src/i830_i2c.c	2009-04-17 11:22:24.000000000 -0700
++++ xserver-xorg-video-psb-0.31.0/src/i830_i2c.c.new	2009-08-28 09:33:06.789804272 -0700
+@@ -31,8 +31,10 @@
+ 
+ #include "xf86.h"
+ #include "xf86_OSproc.h"
++#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
+ #include "xf86Resources.h"
+ #include "xf86RAC.h"
++#endif
+ #include "xf86cmap.h"
+ #include "compiler.h"
+ #include "mibstore.h"
+--- xserver-xorg-video-psb-0.31.0/src/psb_video.c	2009-04-17 11:22:26.000000000 -0700
++++ xserver-xorg-video-psb-0.31.0/src/psb_video.c.new	2009-08-28 09:35:03.874805663 -0700
+@@ -36,7 +36,9 @@
+ 
+ #include "xf86.h"
+ #include "xf86_OSproc.h"
++#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
+ #include "xf86Resources.h"
++#endif
+ #include "compiler.h"
+ 
+ #include "xf86xv.h"
+--- xserver-xorg-video-psb-0.31.0/src/psb_driver.c	2009-04-17 11:22:26.000000000 -0700
++++ xserver-xorg-video-psb-0.31.0/src/psb_driver.c.new	2009-08-28 10:30:32.325553685 -0700
+@@ -317,7 +317,7 @@
+  * This data is accessed by the loader.  The name must be the module name
+  * followed by "ModuleData".
+  */
+-XF86ModuleData psbModuleData = { &psbVersionRec, psbSetup, NULL };
++_X_EXPORT XF86ModuleData psbModuleData = { &psbVersionRec, psbSetup, NULL };
+ 
+ static pointer
+ psbSetup(pointer Module, pointer Options, int *ErrorMajor, int *ErrorMinor)
+@@ -1023,11 +1023,13 @@
+ 
+     PSB_DEBUG(scrnIndex, 3, "Initializing device\n");
+ 
++#ifndef XSERVER_LIBPCIACCESS
+     if (xf86RegisterResources(pDevice->pEnt->index, NULL, ResExclusive)) {
+ 	xf86DrvMsg(scrnIndex, X_ERROR,
+ 		   "Could not registrer device. Resource conflict.\n");
+ 	return FALSE;
+     }
++#endif
+ 
+     if (!xf86LoadSubModule(pDevice->pScrns[0], "vgahw"))
+ 	return FALSE;
+
+
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-assert.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-assert.patch
new file mode 100644
index 0000000000..5137a59041
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-assert.patch
@@ -0,0 +1,11 @@
+diff -p -up xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c.assert xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c
+--- xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c.assert	2010-04-26 13:40:50.000000000 +0200
++++ xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c	2010-04-26 13:48:28.000000000 +0200
+@@ -30,6 +30,7 @@
+ #include "xf86mm.h"
+ #include "xf86drm.h"
+ #include "stdio.h"
++#include <assert.h>
+ 
+ /*
+  * This is a simple wrapper around libdrm's buffer interface to be used 
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-comment_unused.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-comment_unused.patch
new file mode 100644
index 0000000000..ca811b6967
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-comment_unused.patch
@@ -0,0 +1,75 @@
+diff -p -up xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c.comment_unused xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c
+--- xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c.comment_unused	2009-04-17 20:22:26.000000000 +0200
++++ xserver-xorg-video-psb-0.31.0/libmm/mm_drm.c	2010-04-26 13:40:50.000000000 +0200
+@@ -277,6 +277,7 @@ createFence(struct _MMManager *mm,
+     return &dFence->mf;
+ }
+ 
++/*
+ static void
+ fenceDestroy(struct _MMFence *mf)
+ {
+@@ -288,6 +289,7 @@ fenceDestroy(struct _MMFence *mf)
+     assert(ret == 0);
+     free(dFence);
+ }
++*/
+ 
+ static int
+ fenceEmit(struct _MMFence *mf, unsigned fence_class,
+@@ -369,7 +371,7 @@ mmCreateDRM(int drmFD)
+     mm->fenceSignaled = fenceSignaled;
+     mm->fenceWait = fenceWait;
+     mm->fenceError = NULL;
+-    mm->fenceDestroy = fenceDestroy;
++    /* mm->fenceDestroy = fenceDestroy; */
+     mm->destroy = destroy;
+     return mm;
+ 
+diff -p -up xserver-xorg-video-psb-0.31.0/libmm/mm_interface.h.comment_unused xserver-xorg-video-psb-0.31.0/libmm/mm_interface.h
+--- xserver-xorg-video-psb-0.31.0/libmm/mm_interface.h.comment_unused	2009-04-17 20:22:26.000000000 +0200
++++ xserver-xorg-video-psb-0.31.0/libmm/mm_interface.h	2010-04-26 13:45:22.000000000 +0200
+@@ -141,7 +141,7 @@ typedef struct _MMManager
+     int (*fenceWait) (struct _MMFence * mf, unsigned flushMask,
+ 		      unsigned flags);
+     unsigned (*fenceError) (struct _MMFence * mf);
+-    void (*fenceDestroy) (struct _MMFence * mf);
++    /* void (*fenceDestroy) (struct _MMFence * mf); */
+ } MMManager;
+ 
+ /*
+@@ -204,6 +204,7 @@ mmFenceEmit(struct _MMFence *mf, unsigne
+     return mf->man->fenceEmit(mf, class, type, flags);
+ }
+ 
++/*
+ static inline void
+ mmFenceUnReference(struct _MMFence **mfP)
+ {
+@@ -214,6 +215,7 @@ mmFenceUnReference(struct _MMFence **mfP
+     }
+     *mfP = NULL;
+ }
++*/
+ 
+ static inline struct _MMFence *
+ mmFenceReference(struct _MMFence *mf)
+diff -p -up xserver-xorg-video-psb-0.31.0/libmm/mm_user.c.comment_unused xserver-xorg-video-psb-0.31.0/libmm/mm_user.c
+--- xserver-xorg-video-psb-0.31.0/libmm/mm_user.c.comment_unused	2009-04-17 20:22:26.000000000 +0200
++++ xserver-xorg-video-psb-0.31.0/libmm/mm_user.c	2010-04-26 13:05:15.000000000 +0200
+@@ -77,6 +77,7 @@ typedef struct _UserSignal
+     UserManager *man;
+ } UserSignal;
+ 
++/*
+ void
+ mmFenceSignal(struct _MMSignal *signal, unsigned class,
+ 	      unsigned type, unsigned sequence, unsigned error,
+@@ -148,6 +149,7 @@ mmFenceSignal(struct _MMSignal *signal,
+ 	type |= fence->signalPrevious;
+     }
+ }
++*/
+ 
+ static int
+ fenceEmit(struct _MMFence *mf, unsigned class, unsigned type, unsigned flags)
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-greedy.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-greedy.patch
new file mode 100644
index 0000000000..8758911c71
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-greedy.patch
@@ -0,0 +1,19 @@
+diff -p -up xserver-xorg-video-psb-0.31.0/src/psb_accel.c.greedy xserver-xorg-video-psb-0.31.0/src/psb_accel.c
+--- xserver-xorg-video-psb-0.31.0/src/psb_accel.c.greedy	2009-04-17 20:22:24.000000000 +0200
++++ xserver-xorg-video-psb-0.31.0/src/psb_accel.c	2010-04-23 14:52:47.000000000 +0200
+@@ -1331,6 +1331,15 @@ psbExaInit(ScrnInfoPtr pScrn)
+     pExa->FinishAccess = psbExaFinishAccess;
+     pExa->UploadToScreen = psbExaUploadToScreen;
+ 
++    if (!xf86FindOptionValue(pScrn->options, "MigrationHeuristic")) {
++      const char *default_migration = "greedy";
++      xf86DrvMsg(pScrn->scrnIndex, X_INFO,
++		 "Using default MigrationHeuristic: %s\n",
++		 default_migration);
++      xf86ReplaceStrOption(pScrn->options, "MigrationHeuristic", default_migration);
++    }
++
++
+     if (!exaDriverInit(pScrn->pScreen, pExa)) {
+ 	goto out_err;
+     }
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-loader.patch b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-loader.patch
new file mode 100644
index 0000000000..24cbc0d30e
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb-0.32.1/xserver-xorg-video-psb-0.31.0-loader.patch
@@ -0,0 +1,84 @@
+diff -p -up xserver-xorg-video-psb-0.31.0/src/psb_dri.c.loader xserver-xorg-video-psb-0.31.0/src/psb_dri.c
+--- xserver-xorg-video-psb-0.31.0/src/psb_dri.c.loader	2009-04-17 20:22:24.000000000 +0200
++++ xserver-xorg-video-psb-0.31.0/src/psb_dri.c	2010-03-12 15:03:33.000000000 +0100
+@@ -548,8 +548,6 @@ psbDRIScreenInit(ScreenPtr pScreen)
+ 
+     PSB_DEBUG(pScrn->scrnIndex, 3, "psbDRIScreenInit\n");
+ 
+-    xf86LoaderReqSymLists(driReqSymbols, NULL);
+-
+     pPsb->pDRIInfo = NULL;
+ 
+     /*
+diff -p -up xserver-xorg-video-psb-0.31.0/src/psb_driver.c.loader xserver-xorg-video-psb-0.31.0/src/psb_driver.c
+--- xserver-xorg-video-psb-0.31.0/src/psb_driver.c.loader	2010-03-12 13:48:52.000000000 +0100
++++ xserver-xorg-video-psb-0.31.0/src/psb_driver.c	2010-03-12 15:03:26.000000000 +0100
+@@ -329,12 +329,6 @@ psbSetup(pointer Module, pointer Options
+     if (!Initialised) {
+ 	Initialised = TRUE;
+ 	xf86AddDriver(&psb, Module, 0);
+-	LoaderRefSymLists(fbSymbols, ddcSymbols, shadowSymbols,
+-			  psbvgahwSymbols,
+-#ifdef XF86DRI
+-			  psbDRMSymbols, psbDRISymbols,
+-#endif
+-			  NULL);
+ 	return (pointer) TRUE;
+     }
+ 
+@@ -639,7 +633,6 @@ psbPreInitDRI(ScrnInfoPtr pScrn)
+     if (!xf86LoadSubModule(pScrn, "dri"))
+ 	return FALSE;
+ 
+-    xf86LoaderReqSymLists(psbDRISymbols, psbDRMSymbols, NULL);
+     return TRUE;
+ }
+ 
+@@ -660,7 +653,6 @@ psbPreInitXpsb(ScrnInfoPtr pScrn)
+ 
+     pPsb->xpsb = TRUE;
+ 
+-    xf86LoaderReqSymLists(psbXpsbSymbols, NULL);
+     return TRUE;
+ }
+ #endif
+@@ -680,7 +672,6 @@ psbPreInitAccel(ScrnInfoPtr pScrn)
+ 	if (!xf86LoadSubModule(pScrn, "exa"))
+ 	    return FALSE;
+ 
+-	xf86LoaderReqSymLists(exaSymbols, NULL);
+     }
+ 
+     xf86DrvMsg(pScrn->scrnIndex, from, "Acceleration %sabled\n",
+@@ -720,7 +711,6 @@ psbPreInitShadowFB(ScrnInfoPtr pScrn)
+ 	if (!xf86LoadSubModule(pScrn, "shadow"))
+ 	    return FALSE;
+ 
+-	xf86LoaderReqSymLists(shadowSymbols, NULL);
+     }
+ 
+     xf86DrvMsg(pScrn->scrnIndex, from, "Shadow framebuffer %sabled\n",
+@@ -854,7 +844,6 @@ psbPreInit(ScrnInfoPtr pScrn, int flags)
+ 
+     if (!xf86LoadSubModule(pScrn, "vbe"))
+ 	return FALSE;
+-    xf86LoaderReqSymLists(vbeSymbols, NULL);
+ 
+     /*
+      * Parse options and load required modules here.
+@@ -874,7 +863,6 @@ psbPreInit(ScrnInfoPtr pScrn, int flags)
+ 
+     if (!xf86LoadSubModule(pScrn, "fb"))
+ 	return (FALSE);
+-    xf86LoaderReqSymLists(fbSymbols, NULL);
+ 
+     pScrn->chipset = "Intel GMA500";
+     pScrn->monitor = pScrn->confScreen->monitor;
+@@ -1033,7 +1021,6 @@ psbDeviceInit(PsbDevicePtr pDevice, int
+ 
+     if (!xf86LoadSubModule(pDevice->pScrns[0], "vgahw"))
+ 	return FALSE;
+-    xf86LoaderReqSymLists(psbvgahwSymbols, NULL);
+ 
+     if (!vgaHWGetHWRec(pDevice->pScrns[0]))
+ 	return FALSE;
diff --git a/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb_0.32.1.bb b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb_0.32.1.bb
new file mode 100644
index 0000000000..fc014fca05
--- /dev/null
+++ b/meta-emenlow/packages/xserver-xorg-video-psb/xserver-xorg-video-psb_0.32.1.bb
@@ -0,0 +1,31 @@
+DESCRIPTION = "2D graphics driver for Poulsbo"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://MIT_License.txt;md5=732825ecdcf420261531d935fcd914a7"
+PR = "r1"
+
+inherit autotools
+
+SRC_URI = "https://launchpad.net/~gma500/+archive/ppa/+files/xserver-xorg-video-psb_0.36.0-0ubuntu3~1004um9.tar.gz \
+	file://xorg-x11-drv-psb-0.31.0-ignoreacpi.patch;patch=1 \
+	file://xorg-x11-drv-psb-0.31.0-xserver17.patch;patch=1 \
+	file://xserver-xorg-video-psb-0.31.0-assert.patch;patch=1 \
+	file://xserver-xorg-video-psb-0.31.0-comment_unused.patch;patch=1 \
+	file://xserver-xorg-video-psb-0.31.0-greedy.patch;patch=1 \
+	file://xserver-xorg-video-psb-0.31.0-loader.patch;patch=1 \
+	file://stubs.patch;patch=1 \
+	file://01_disable_lid_timer.patch;patch=1 \
+	file://psb_xvtempfix.patch;patch=1 \
+	file://psb_mixed.patch;patch=1 \
+	file://dri-h.patch"
+
+export DRI_CFLAGS="-I${STAGING_INCDIR}/psb -I${STAGING_INCDIR}/psb/drm \
+	-I${STAGING_INCDIR}/X11/dri"
+
+export CFLAGS = "-fvisibility=default"
+export XORG_CFLAGS="-fvisibility=default -I${STAGING_INCDIR}/xorg \
+       -I${STAGING_INCDIR}/pixman-1"
+
+FILES_${PN} += "${libdir}/xorg/modules/drivers/libmm.so \
+	     ${libdir}/xorg/modules/drivers/psb_drv.so"
+
+DEPENDS += "virtual/libgl virtual/xserver"