summaryrefslogtreecommitdiff
path: root/meta-emenlow/packages/libva
diff options
context:
space:
mode:
authorJeff Dike <jdike@x86_64.user-mode-linux.org>2010-07-21 17:31:45 -0400
committerRichard Purdie <rpurdie@linux.intel.com>2010-07-21 22:39:43 +0100
commite8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304 (patch)
treec8ed16e490e2e30de292c8a10eedb084d5abdea8 /meta-emenlow/packages/libva
parent0c3b1aa0a5461c9b5f3833feb091f7c8a459ca9b (diff)
downloadopenembedded-core-e8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304.tar.gz
openembedded-core-e8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304.tar.bz2
openembedded-core-e8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304.tar.xz
openembedded-core-e8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304.zip
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>
Diffstat (limited to 'meta-emenlow/packages/libva')
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/033_g45_add_rgba_subpic.patch111
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/034_g45_fix_return_for_unimpl.patch83
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/035_g45_add_yv12_image_format.patch102
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/036_g45_add_vaGetImage.patch71
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/037_g45_add_vaPutImage.patch111
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/038_g45_vaPutSurface_cliprects.patch531
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/102_attribute_visibility.patch47
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/103_fix_vainfo_deps.patch24
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/104_fix_libva_pkgconfig_deps.patch18
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/105_dont_search_LIBGL_DRIVERS_PATH.patch21
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/108_drivers_path.patch25
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/203_fix_fglrx_detection.patch542
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/204_check_ATIFGLEXTENSION.patch312
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/300_sds_version.patch87
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/301_vdpau_mpeg4.patch26
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/320_move_vaPutSurface_flags_def.patch60
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/321_libva_glx.base.patch212
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/322_libva_glx.patch2024
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/390_compat.base.patch135
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/391_compat.patch3273
-rw-r--r--meta-emenlow/packages/libva/libva-0.31.0/392_compat.dso.patch183
-rw-r--r--meta-emenlow/packages/libva/libva_0.31.0.bb35
22 files changed, 8033 insertions, 0 deletions
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 000000000..1b928b4c0
--- /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 000000000..a4612133b
--- /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 000000000..92d814c1a
--- /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 000000000..dc25d9f9e
--- /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 000000000..ce638cce5
--- /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 000000000..ca2e1bd47
--- /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 000000000..2885ab7b5
--- /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 000000000..942c26d1b
--- /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 000000000..bd212bf39
--- /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 000000000..de873d601
--- /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 000000000..073c98705
--- /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 000000000..ce7f10653
--- /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 000000000..02920a894
--- /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 000000000..07531c90c
--- /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 000000000..86188902a
--- /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 000000000..f00c52ca4
--- /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 000000000..43af6f40c
--- /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 000000000..ccd9ae090
--- /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 000000000..f2e0d61b0
--- /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 000000000..5e09d22b8
--- /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 000000000..57ae44f9d
--- /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 000000000..52cd59995
--- /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/*"
generated by cgit v1.2.3 (git 2.46.0) at 2024-12-24 00:43:49 +0000