diff options
| author | Jeff Dike <jdike@x86_64.user-mode-linux.org> | 2010-07-21 17:31:45 -0400 |
|---|---|---|
| committer | Richard Purdie <rpurdie@linux.intel.com> | 2010-07-21 22:39:43 +0100 |
| commit | e8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304 (patch) | |
| tree | c8ed16e490e2e30de292c8a10eedb084d5abdea8 /meta-emenlow/packages/libva | |
| parent | 0c3b1aa0a5461c9b5f3833feb091f7c8a459ca9b (diff) | |
| download | openembedded-core-e8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304.tar.gz openembedded-core-e8e3ac9b1e0e4342fc3a6d7b435ddaf93f274304.tar.bz2 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')
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 0000000000..1b928b4c09 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/033_g45_add_rgba_subpic.patch @@ -0,0 +1,111 @@ +From 6622e8eba85cea476f8ef5b8c3620c4a0f024dcd Mon Sep 17 00:00:00 2001 +From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed, 4 Nov 2009 10:56:54 +0000 +Subject: [PATCH] [G45] Add RGBA subpictures. + +--- + i965_drv_video/i965_drv_video.c | 18 ++++++++++++++++++ + i965_drv_video/i965_drv_video.h | 3 ++- + i965_drv_video/i965_render.c | 8 ++++---- + 3 files changed, 24 insertions(+), 5 deletions(-) + +diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c +index 8f4bfc1..92c4785 100644 +--- a/i965_drv_video/i965_drv_video.c ++++ b/i965_drv_video/i965_drv_video.c +@@ -70,6 +70,14 @@ i965_subpic_formats_map[I965_MAX_SUBPIC_FORMATS + 1] = { + { I965_SURFACETYPE_INDEXED, I965_SURFACEFORMAT_A4P4_UNORM, + { VA_FOURCC('A','I','4','4'), VA_MSB_FIRST, 8, }, + 0 }, ++ { I965_SURFACETYPE_RGBA, I965_SURFACEFORMAT_B8G8R8A8_UNORM, ++ { VA_FOURCC('B','G','R','A'), VA_LSB_FIRST, 32, ++ 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }, ++ 0 }, ++ { I965_SURFACETYPE_RGBA, I965_SURFACEFORMAT_R8G8B8A8_UNORM, ++ { VA_FOURCC('R','G','B','A'), VA_LSB_FIRST, 32, ++ 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 }, ++ 0 }, + }; + + static const i965_subpic_format_map_t * +@@ -467,6 +475,7 @@ i965_CreateSubpicture(VADriverContextP ctx, + obj_subpic->format = m->format; + obj_subpic->width = obj_image->image.width; + obj_subpic->height = obj_image->image.height; ++ obj_subpic->pitch = obj_image->image.pitches[0]; + obj_subpic->bo = obj_image->bo; + return VA_STATUS_SUCCESS; + } +@@ -1218,6 +1227,15 @@ i965_CreateImage(VADriverContextP ctx, + image->component_order[1] = 'G'; + image->component_order[2] = 'B'; + break; ++ case VA_FOURCC('A','R','G','B'): ++ case VA_FOURCC('A','B','G','R'): ++ case VA_FOURCC('B','G','R','A'): ++ case VA_FOURCC('R','G','B','A'): ++ image->num_planes = 1; ++ image->pitches[0] = width * 4; ++ image->offsets[0] = 0; ++ image->data_size = image->offsets[0] + image->pitches[0] * height; ++ break; + default: + goto error; + } +diff --git a/i965_drv_video/i965_drv_video.h b/i965_drv_video/i965_drv_video.h +index c95c799..4d775da 100644 +--- a/i965_drv_video/i965_drv_video.h ++++ b/i965_drv_video/i965_drv_video.h +@@ -42,7 +42,7 @@ + #define I965_MAX_ENTRYPOINTS 5 + #define I965_MAX_CONFIG_ATTRIBUTES 10 + #define I965_MAX_IMAGE_FORMATS 10 +-#define I965_MAX_SUBPIC_FORMATS 2 ++#define I965_MAX_SUBPIC_FORMATS 4 + #define I965_MAX_DISPLAY_ATTRIBUTES 4 + #define I965_STR_VENDOR "i965 Driver 0.1" + +@@ -124,6 +124,7 @@ struct object_subpic + unsigned int format; + int width; + int height; ++ int pitch; + dri_bo *bo; + }; + +diff --git a/i965_drv_video/i965_render.c b/i965_drv_video/i965_render.c +index f105e90..0476087 100644 +--- a/i965_drv_video/i965_render.c ++++ b/i965_drv_video/i965_render.c +@@ -586,7 +586,7 @@ i965_subpic_render_src_surface_state(VADriverContextP ctx, + int index, + dri_bo *region, + unsigned long offset, +- int w, int h, int format) ++ int w, int h, int p, int format) + { + struct i965_driver_data *i965 = i965_driver_data(ctx); + struct i965_render_state *render_state = &i965->render_state; +@@ -620,7 +620,7 @@ i965_subpic_render_src_surface_state(VADriverContextP ctx, + ss->ss2.mip_count = 0; + ss->ss2.render_target_rotation = 0; + +- ss->ss3.pitch = w - 1; ++ ss->ss3.pitch = p - 1; + + dri_bo_emit_reloc(ss_bo, + I915_GEM_DOMAIN_SAMPLER, 0, +@@ -678,8 +678,8 @@ i965_subpic_render_src_surfaces_state(VADriverContextP ctx, + region = obj_surface->bo; + subpic_region = obj_image->bo; + /*subpicture surface*/ +- i965_subpic_render_src_surface_state(ctx, 1, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->format); +- i965_subpic_render_src_surface_state(ctx, 2, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->format); ++ i965_subpic_render_src_surface_state(ctx, 1, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->pitch, obj_subpic->format); ++ i965_subpic_render_src_surface_state(ctx, 2, subpic_region, 0, obj_subpic->width, obj_subpic->height, obj_subpic->pitch, obj_subpic->format); + } + + static void +-- +1.5.4.3 + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/034_g45_fix_return_for_unimpl.patch b/meta-emenlow/packages/libva/libva-0.31.0/034_g45_fix_return_for_unimpl.patch new file mode 100644 index 0000000000..a4612133bb --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/034_g45_fix_return_for_unimpl.patch @@ -0,0 +1,83 @@ +From 3935c6a836b8f90947f0af658a76b97a08a03c67 Mon Sep 17 00:00:00 2001 +From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed, 4 Nov 2009 13:23:40 +0000 +Subject: [PATCH] [G45] Don't return VA_STATUS_SUCCESS for unimplemented functions. + +--- + i965_drv_video/i965_drv_video.c | 18 +++++++++++------- + 1 files changed, 11 insertions(+), 7 deletions(-) + +diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c +index 10baffb..d8a7bd1 100644 +--- a/i965_drv_video/i965_drv_video.c ++++ b/i965_drv_video/i965_drv_video.c +@@ -534,7 +534,8 @@ i965_SetSubpictureImage(VADriverContextP ctx, + VASubpictureID subpicture, + VAImageID image) + { +- return VA_STATUS_SUCCESS; ++ /* TODO */ ++ return VA_STATUS_ERROR_UNIMPLEMENTED; + } + + VAStatus +@@ -544,7 +545,8 @@ i965_SetSubpictureChromakey(VADriverContextP ctx, + unsigned int chromakey_max, + unsigned int chromakey_mask) + { +- return VA_STATUS_SUCCESS; ++ /* TODO */ ++ return VA_STATUS_ERROR_UNIMPLEMENTED; + } + + VAStatus +@@ -552,7 +554,8 @@ i965_SetSubpictureGlobalAlpha(VADriverContextP ctx, + VASubpictureID subpicture, + float global_alpha) + { +- return VA_STATUS_SUCCESS; ++ /* TODO */ ++ return VA_STATUS_ERROR_UNIMPLEMENTED; + } + + VAStatus +@@ -1141,7 +1144,7 @@ i965_GetDisplayAttributes(VADriverContextP ctx, + int num_attributes) + { + /* TODO */ +- return VA_STATUS_ERROR_UNKNOWN; ++ return VA_STATUS_ERROR_UNIMPLEMENTED; + } + + /* +@@ -1156,7 +1159,7 @@ i965_SetDisplayAttributes(VADriverContextP ctx, + int num_attributes) + { + /* TODO */ +- return VA_STATUS_ERROR_UNKNOWN; ++ return VA_STATUS_ERROR_UNIMPLEMENTED; + } + + VAStatus +@@ -1166,7 +1169,7 @@ i965_DbgCopySurfaceToBuffer(VADriverContextP ctx, + unsigned int *stride) /* out */ + { + /* TODO */ +- return VA_STATUS_ERROR_UNKNOWN; ++ return VA_STATUS_ERROR_UNIMPLEMENTED; + } + + static VAStatus +@@ -1318,7 +1321,8 @@ VAStatus i965_DeriveImage(VADriverContextP ctx, + VASurfaceID surface, + VAImage *image) /* out */ + { +- return VA_STATUS_SUCCESS; ++ /* TODO */ ++ return VA_STATUS_ERROR_OPERATION_FAILED; + } + + static void +-- +1.5.4.3 + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/035_g45_add_yv12_image_format.patch b/meta-emenlow/packages/libva/libva-0.31.0/035_g45_add_yv12_image_format.patch new file mode 100644 index 0000000000..92d814c1a8 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/035_g45_add_yv12_image_format.patch @@ -0,0 +1,102 @@ +From 23b23e8d65551779f10aedddee7882c2e71ac162 Mon Sep 17 00:00:00 2001 +From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed, 4 Nov 2009 13:01:44 +0000 +Subject: [PATCH] [G45] Add YV12 image format. + +--- + i965_drv_video/i965_drv_video.c | 50 ++++++++++++++++++++++++++++++++++++++- + i965_drv_video/i965_drv_video.h | 2 +- + 2 files changed, 50 insertions(+), 2 deletions(-) + +diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c +index 1f026bc..8558d0e 100644 +--- a/i965_drv_video/i965_drv_video.c ++++ b/i965_drv_video/i965_drv_video.c +@@ -54,6 +54,36 @@ enum { + I965_SURFACETYPE_INDEXED + }; + ++/* List of supported image formats */ ++typedef struct { ++ unsigned int type; ++ VAImageFormat va_format; ++} i965_image_format_map_t; ++ ++static const i965_image_format_map_t ++i965_image_formats_map[I965_MAX_IMAGE_FORMATS + 1] = { ++ { I965_SURFACETYPE_YUV, ++ { VA_FOURCC('Y','V','1','2'), VA_LSB_FIRST, 12, } }, ++}; ++ ++static const i965_image_format_map_t * ++get_image_format(const VAImageFormat *va_format) ++{ ++ unsigned int i; ++ for (i = 0; i965_image_formats_map[i].type != 0; i++) { ++ const i965_image_format_map_t * const m = &i965_image_formats_map[i]; ++ if (m->va_format.fourcc == va_format->fourcc && ++ (m->type == I965_SURFACETYPE_RGBA ? ++ (m->va_format.byte_order == va_format->byte_order && ++ m->va_format.red_mask == va_format->red_mask && ++ m->va_format.green_mask == va_format->green_mask && ++ m->va_format.blue_mask == va_format->blue_mask && ++ m->va_format.alpha_mask == va_format->alpha_mask) : 1)) ++ return m; ++ } ++ return NULL; ++} ++ + /* List of supported subpicture formats */ + typedef struct { + unsigned int type; +@@ -398,8 +428,16 @@ i965_QueryImageFormats(VADriverContextP ctx, + VAImageFormat *format_list, /* out */ + int *num_formats) /* out */ + { ++ int n; ++ ++ for (n = 0; i965_image_formats_map[n].va_format.fourcc != 0; n++) { ++ const i965_image_format_map_t * const m = &i965_image_formats_map[n]; ++ if (format_list) ++ format_list[n] = m->va_format; ++ } ++ + if (num_formats) +- *num_formats = 0; ++ *num_formats = n; + + return VA_STATUS_SUCCESS; + } +@@ -1236,6 +1274,16 @@ i965_CreateImage(VADriverContextP ctx, + image->offsets[0] = 0; + image->data_size = image->offsets[0] + image->pitches[0] * height; + break; ++ case VA_FOURCC('Y','V','1','2'): ++ image->num_planes = 3; ++ image->pitches[0] = width; ++ image->offsets[0] = 0; ++ image->pitches[1] = width2; ++ image->offsets[1] = size; ++ image->pitches[2] = width2; ++ image->offsets[2] = size + size2; ++ image->data_size = size + 2 * size2; ++ break; + default: + goto error; + } +diff --git a/i965_drv_video/i965_drv_video.h b/i965_drv_video/i965_drv_video.h +index 4d775da..f512793 100644 +--- a/i965_drv_video/i965_drv_video.h ++++ b/i965_drv_video/i965_drv_video.h +@@ -41,7 +41,7 @@ + #define I965_MAX_PROFILES 11 + #define I965_MAX_ENTRYPOINTS 5 + #define I965_MAX_CONFIG_ATTRIBUTES 10 +-#define I965_MAX_IMAGE_FORMATS 10 ++#define I965_MAX_IMAGE_FORMATS 1 + #define I965_MAX_SUBPIC_FORMATS 4 + #define I965_MAX_DISPLAY_ATTRIBUTES 4 + #define I965_STR_VENDOR "i965 Driver 0.1" +-- +1.5.4.3 + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/036_g45_add_vaGetImage.patch b/meta-emenlow/packages/libva/libva-0.31.0/036_g45_add_vaGetImage.patch new file mode 100644 index 0000000000..dc25d9f9e9 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/036_g45_add_vaGetImage.patch @@ -0,0 +1,71 @@ +From 37f40c0cdc9667907dfb784874b42fb16c2c9bde Mon Sep 17 00:00:00 2001 +From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed, 4 Nov 2009 13:16:34 +0000 +Subject: [PATCH] =?utf-8?q?[G45]=C2=A0Implement=20vaGetImage()=20for=20full-sized=20surface=20readback.?= +MIME-Version: 1.0 +Content-Type: text/plain; charset=utf-8 +Content-Transfer-Encoding: 8bit + +--- + i965_drv_video/i965_drv_video.c | 45 ++++++++++++++++++++++++++++++++++++++- + 1 files changed, 44 insertions(+), 1 deletions(-) + +diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c +index 8558d0e..10baffb 100644 +--- a/i965_drv_video/i965_drv_video.c ++++ b/i965_drv_video/i965_drv_video.c +@@ -1388,7 +1388,50 @@ i965_GetImage(VADriverContextP ctx, + unsigned int height, + VAImageID image) + { +- return VA_STATUS_SUCCESS; ++ struct i965_driver_data *i965 = i965_driver_data(ctx); ++ ++ struct object_surface *obj_surface = SURFACE(surface); ++ if (!obj_surface) ++ return VA_STATUS_ERROR_INVALID_SURFACE; ++ ++ struct object_image *obj_image = IMAGE(image); ++ if (!obj_image) ++ return VA_STATUS_ERROR_INVALID_IMAGE; ++ ++ /* XXX: we only support full-size surface readback */ ++ if (x != 0 || ++ y != 0 || ++ width != obj_surface->width || ++ height != obj_surface->height) ++ return VA_STATUS_ERROR_INVALID_PARAMETER; ++ ++ /* XXX: we only support 1:1 image copies */ ++ if (width != obj_image->image.width || ++ height != obj_image->image.height) ++ return VA_STATUS_ERROR_INVALID_PARAMETER; ++ ++ VAStatus va_status; ++ void *image_data = NULL; ++ ++ va_status = i965_MapBuffer(ctx, obj_image->image.buf, &image_data); ++ if (va_status != VA_STATUS_SUCCESS) ++ return va_status; ++ ++ dri_bo_map(obj_surface->bo, 0); ++ ++ switch (obj_image->image.format.fourcc) { ++ case VA_FOURCC('Y','V','1','2'): /* YV12 is native format here */ ++ memcpy(image_data, obj_surface->bo->virtual, obj_surface->bo->size); ++ break; ++ default: ++ va_status = VA_STATUS_ERROR_OPERATION_FAILED; ++ break; ++ } ++ ++ dri_bo_unmap(obj_surface->bo); ++ ++ i965_UnmapBuffer(ctx, obj_image->image.buf); ++ return va_status; + } + + VAStatus +-- +1.5.4.3 + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/037_g45_add_vaPutImage.patch b/meta-emenlow/packages/libva/libva-0.31.0/037_g45_add_vaPutImage.patch new file mode 100644 index 0000000000..ce638cce52 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/037_g45_add_vaPutImage.patch @@ -0,0 +1,111 @@ +From 000807cfbd8bcbc9cd4bf28a066087fee43396b4 Mon Sep 17 00:00:00 2001 +From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed, 4 Nov 2009 13:36:39 +0000 +Subject: [PATCH] =?utf-8?q?[G45]=C2=A0Implement=20vaPutImage()=20for=20full-sized=20surface=20uploads.?= +MIME-Version: 1.0 +Content-Type: text/plain; charset=utf-8 +Content-Transfer-Encoding: 8bit + +--- + i965_drv_video/i965_drv_video.c | 78 +++++++++++++++++++++++++++++++-------- + 1 files changed, 62 insertions(+), 16 deletions(-) + +diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c +index d8a7bd1..e8f638c 100644 +--- a/i965_drv_video/i965_drv_video.c ++++ b/i965_drv_video/i965_drv_video.c +@@ -443,22 +443,6 @@ i965_QueryImageFormats(VADriverContextP ctx, + } + + VAStatus +-i965_PutImage(VADriverContextP ctx, +- VASurfaceID surface, +- VAImageID image, +- int src_x, +- int src_y, +- unsigned int src_width, +- unsigned int src_height, +- int dest_x, +- int dest_y, +- unsigned int dest_width, +- unsigned int dest_height) +-{ +- return VA_STATUS_SUCCESS; +-} +- +-VAStatus + i965_QuerySubpictureFormats(VADriverContextP ctx, + VAImageFormat *format_list, /* out */ + unsigned int *flags, /* out */ +@@ -1439,6 +1423,68 @@ i965_GetImage(VADriverContextP ctx, + } + + VAStatus ++i965_PutImage(VADriverContextP ctx, ++ VASurfaceID surface, ++ VAImageID image, ++ int src_x, ++ int src_y, ++ unsigned int src_width, ++ unsigned int src_height, ++ int dest_x, ++ int dest_y, ++ unsigned int dest_width, ++ unsigned int dest_height) ++{ ++ struct i965_driver_data *i965 = i965_driver_data(ctx); ++ ++ struct object_surface *obj_surface = SURFACE(surface); ++ if (!obj_surface) ++ return VA_STATUS_ERROR_INVALID_SURFACE; ++ ++ struct object_image *obj_image = IMAGE(image); ++ if (!obj_image) ++ return VA_STATUS_ERROR_INVALID_IMAGE; ++ ++ /* XXX: we don't support partial video surface updates */ ++ if (src_x != 0 || ++ src_y != 0 || ++ src_width != obj_image->image.width || ++ src_height != obj_image->image.height) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ if (dest_x != 0 || ++ dest_y != 0 || ++ dest_width != obj_surface->width || ++ dest_height != obj_surface->height) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ if (src_width != dest_width || ++ src_height != dest_height) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ ++ VAStatus va_status; ++ void *image_data = NULL; ++ ++ va_status = i965_MapBuffer(ctx, obj_image->image.buf, &image_data); ++ if (va_status != VA_STATUS_SUCCESS) ++ return va_status; ++ ++ dri_bo_map(obj_surface->bo, 1); ++ ++ switch (obj_image->image.format.fourcc) { ++ case VA_FOURCC('Y','V','1','2'): /* YV12 is native format here */ ++ memcpy(obj_surface->bo->virtual, image_data, obj_surface->bo->size); ++ break; ++ default: ++ va_status = VA_STATUS_ERROR_OPERATION_FAILED; ++ break; ++ } ++ ++ dri_bo_unmap(obj_surface->bo); ++ ++ i965_UnmapBuffer(ctx, obj_image->image.buf); ++ return va_status; ++} ++ ++VAStatus + i965_PutSurface(VADriverContextP ctx, + VASurfaceID surface, + Drawable draw, /* X Drawable */ +-- +1.5.4.3 + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/038_g45_vaPutSurface_cliprects.patch b/meta-emenlow/packages/libva/libva-0.31.0/038_g45_vaPutSurface_cliprects.patch new file mode 100644 index 0000000000..ca2e1bd471 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/038_g45_vaPutSurface_cliprects.patch @@ -0,0 +1,531 @@ +From 90de12a47e26ccc0b4cc8189c76991609481870d Mon Sep 17 00:00:00 2001 +From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed, 4 Nov 2009 17:34:53 +0000 +Subject: [PATCH] [G45] Handle cliprects in vaPutSurface(). + +--- + i965_drv_video/i965_drv_video.c | 39 ++++-- + i965_drv_video/i965_render.c | 284 +++++++++++++++++++-------------------- + i965_drv_video/i965_render.h | 30 ++--- + 3 files changed, 176 insertions(+), 177 deletions(-) + +diff --git a/i965_drv_video/i965_drv_video.c b/i965_drv_video/i965_drv_video.c +index e8f638c..20d6bab 100644 +--- a/i965_drv_video/i965_drv_video.c ++++ b/i965_drv_video/i965_drv_video.c +@@ -1507,13 +1507,23 @@ i965_PutSurface(VADriverContextP ctx, + union dri_buffer *buffer; + struct intel_region *dest_region; + struct object_surface *obj_surface; +- int ret; ++ int ret; + uint32_t name; ++ VARectangle src_rect, dst_rect; + Bool new_region = False; ++ + /* Currently don't support DRI1 */ + if (dri_state->driConnectedFlag != VA_DRI2) + return VA_STATUS_ERROR_UNKNOWN; + ++ /* XXX: we currently only support up to 64 cliprects */ ++ if (number_cliprects > MAX_CLIP_RECTS) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ ++ obj_surface = SURFACE(surface); ++ if (!obj_surface) ++ return VA_STATUS_ERROR_INVALID_SURFACE; ++ + dri_drawable = dri_get_drawable(ctx, draw); + assert(dri_drawable); + +@@ -1552,17 +1562,24 @@ i965_PutSurface(VADriverContextP ctx, + assert(ret == 0); + } + +- i965_render_put_surface(ctx, surface, +- srcx, srcy, srcw, srch, +- destx, desty, destw, desth); +- obj_surface = SURFACE(surface); +- if(obj_surface->subpic != VA_INVALID_ID) { +- i965_render_put_subpic(ctx, surface, +- srcx, srcy, srcw, srch, +- destx, desty, destw, desth); +- } +- dri_swap_buffer(ctx, dri_drawable); ++ src_rect.x = srcx; ++ src_rect.y = srcy; ++ src_rect.width = srcw; ++ src_rect.height = srch; ++ ++ dst_rect.x = destx; ++ dst_rect.y = desty; ++ dst_rect.width = destw; ++ dst_rect.height = desth; + ++ i965_render_put_surface(ctx, surface, &src_rect, &dst_rect, ++ cliprects, number_cliprects); ++ ++ if (obj_surface->subpic != VA_INVALID_ID) ++ i965_render_put_subpic(ctx, surface, &src_rect, &dst_rect, ++ cliprects, number_cliprects); ++ ++ dri_swap_buffer(ctx, dri_drawable); + return VA_STATUS_SUCCESS; + } + +diff --git a/i965_drv_video/i965_render.c b/i965_drv_video/i965_render.c +index 0476087..d7cd8fe 100644 +--- a/i965_drv_video/i965_render.c ++++ b/i965_drv_video/i965_render.c +@@ -787,13 +787,81 @@ i965_render_binding_table(VADriverContextP ctx) + dri_bo_unmap(render_state->wm.binding_table); + } + +-static void ++static unsigned int ++i965_render_do_upload_vertex(VADriverContextP ctx, ++ unsigned int width, ++ unsigned int height, ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects) ++{ ++ struct i965_driver_data *i965 = i965_driver_data(ctx); ++ struct i965_render_state *render_state = &i965->render_state; ++ struct intel_region *dest_region = render_state->draw_region; ++ float *vb, tx1, tx2, ty1, ty2; ++ int x1, x2, y1, y2; ++ unsigned int i, n; ++ ++ if (!cliprects || num_cliprects == 0) { ++ cliprects = dst_rect; ++ num_cliprects = 1; ++ } ++ ++ dri_bo_map(render_state->vb.vertex_buffer, 1); ++ assert(render_state->vb.vertex_buffer->virtual); ++ vb = render_state->vb.vertex_buffer->virtual; ++ ++ for (n = 0, i = 0; i < num_cliprects; i++) { ++ x1 = dest_region->x + cliprects[i].x; ++ y1 = dest_region->y + cliprects[i].y; ++ x2 = x1 + cliprects[i].width; ++ y2 = y1 + cliprects[i].height; ++ x1 = MAX(x1, dst_rect->x); ++ y1 = MAX(y1, dst_rect->y); ++ x2 = MIN(x2, dst_rect->x + dst_rect->width); ++ y2 = MIN(y2, dst_rect->y + dst_rect->height); ++ ++ if (x2 <= x1 || y2 <= y1) ++ continue; ++ ++ const float sx1 = (float)(x1 - dst_rect->x) / (float)dst_rect->width; ++ const float sy1 = (float)(y1 - dst_rect->y) / (float)dst_rect->height; ++ const float sx2 = (float)(x2 - dst_rect->x) / (float)dst_rect->width; ++ const float sy2 = (float)(y2 - dst_rect->y) / (float)dst_rect->height; ++ tx1 = ((float)src_rect->x + sx1 * (float)src_rect->width) / width; ++ ty1 = ((float)src_rect->y + sy1 * (float)src_rect->height) / height; ++ tx2 = ((float)src_rect->x + sx2 * (float)src_rect->width) / width; ++ ty2 = ((float)src_rect->y + sy2 * (float)src_rect->height) / height; ++ ++ vb[n++] = tx2; ++ vb[n++] = ty2; ++ vb[n++] = x2; ++ vb[n++] = y2; ++ ++ vb[n++] = tx1; ++ vb[n++] = ty2; ++ vb[n++] = x1; ++ vb[n++] = y2; ++ ++ vb[n++] = tx1; ++ vb[n++] = ty1; ++ vb[n++] = x1; ++ vb[n++] = y1; ++ } ++ ++ dri_bo_unmap(render_state->vb.vertex_buffer); ++ return n / 12; ++} ++ ++static unsigned int + i965_subpic_render_upload_vertex(VADriverContextP ctx, + VASurfaceID surface, +- const VARectangle *output_rect) +-{ ++ const VARectangle *output_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects) ++{ + struct i965_driver_data *i965 = i965_driver_data(ctx); +- struct i965_render_state *render_state = &i965->render_state; + struct object_surface *obj_surface = SURFACE(surface); + struct object_subpic *obj_subpic = SUBPIC(obj_surface->subpic); + +@@ -803,8 +871,6 @@ i965_subpic_render_upload_vertex(VADriverContextP ctx, + const float ssy = (float)output_rect->height / (float)obj_surface->height; + const float sx = psx * ssx; + const float sy = psy * ssy; +- float *vb, tx1, tx2, ty1, ty2, x1, x2, y1, y2; +- int i = 0; + + VARectangle dst_rect; + dst_rect.x = output_rect->x + sx * (float)obj_subpic->dst_rect.x; +@@ -812,106 +878,38 @@ i965_subpic_render_upload_vertex(VADriverContextP ctx, + dst_rect.width = sx * (float)obj_subpic->dst_rect.width; + dst_rect.height = sy * (float)obj_subpic->dst_rect.height; + +- dri_bo_map(render_state->vb.vertex_buffer, 1); +- assert(render_state->vb.vertex_buffer->virtual); +- vb = render_state->vb.vertex_buffer->virtual; +- +- tx1 = (float)obj_subpic->src_rect.x / (float)obj_subpic->width; +- ty1 = (float)obj_subpic->src_rect.y / (float)obj_subpic->height; +- tx2 = (float)(obj_subpic->src_rect.x + obj_subpic->src_rect.width) / (float)obj_subpic->width; +- ty2 = (float)(obj_subpic->src_rect.y + obj_subpic->src_rect.height) / (float)obj_subpic->height; +- +- x1 = (float)dst_rect.x; +- y1 = (float)dst_rect.y; +- x2 = (float)(dst_rect.x + dst_rect.width); +- y2 = (float)(dst_rect.y + dst_rect.height); +- +- vb[i++] = tx2; +- vb[i++] = ty2; +- vb[i++] = x2; +- vb[i++] = y2; +- +- vb[i++] = tx1; +- vb[i++] = ty2; +- vb[i++] = x1; +- vb[i++] = y2; +- +- vb[i++] = tx1; +- vb[i++] = ty1; +- vb[i++] = x1; +- vb[i++] = y1; +- dri_bo_unmap(render_state->vb.vertex_buffer); ++ return i965_render_do_upload_vertex(ctx, ++ obj_subpic->width, obj_subpic->height, ++ &obj_subpic->src_rect, &dst_rect, ++ cliprects, num_cliprects); + } + +-static void ++static unsigned int + i965_render_upload_vertex(VADriverContextP ctx, + VASurfaceID surface, +- short srcx, +- short srcy, +- unsigned short srcw, +- unsigned short srch, +- short destx, +- short desty, +- unsigned short destw, +- unsigned short desth) ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects) + { + struct i965_driver_data *i965 = i965_driver_data(ctx); +- struct i965_render_state *render_state = &i965->render_state; +- struct intel_region *dest_region = render_state->draw_region; +- struct object_surface *obj_surface; +- float *vb; +- +- float u1, v1, u2, v2; +- int i, width, height; +- int box_x1 = dest_region->x + destx; +- int box_y1 = dest_region->y + desty; +- int box_x2 = box_x1 + destw; +- int box_y2 = box_y1 + desth; +- +- obj_surface = SURFACE(surface); +- assert(surface); +- width = obj_surface->width; +- height = obj_surface->height; +- +- u1 = (float)srcx / width; +- v1 = (float)srcy / height; +- u2 = (float)(srcx + srcw) / width; +- v2 = (float)(srcy + srch) / height; +- +- dri_bo_map(render_state->vb.vertex_buffer, 1); +- assert(render_state->vb.vertex_buffer->virtual); +- vb = render_state->vb.vertex_buffer->virtual; +- +- i = 0; +- vb[i++] = u2; +- vb[i++] = v2; +- vb[i++] = (float)box_x2; +- vb[i++] = (float)box_y2; +- +- vb[i++] = u1; +- vb[i++] = v2; +- vb[i++] = (float)box_x1; +- vb[i++] = (float)box_y2; +- +- vb[i++] = u1; +- vb[i++] = v1; +- vb[i++] = (float)box_x1; +- vb[i++] = (float)box_y1; ++ struct object_surface *obj_surface = SURFACE(surface); ++ assert(obj_surface); + +- dri_bo_unmap(render_state->vb.vertex_buffer); ++ return i965_render_do_upload_vertex(ctx, ++ obj_surface->width, obj_surface->height, ++ src_rect, ++ dst_rect, ++ cliprects, num_cliprects); + } + +-static void ++static unsigned int + i965_surface_render_state_setup(VADriverContextP ctx, +- VASurfaceID surface, +- short srcx, +- short srcy, +- unsigned short srcw, +- unsigned short srch, +- short destx, +- short desty, +- unsigned short destw, +- unsigned short desth) ++ VASurfaceID surface, ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects) + { + i965_render_vs_unit(ctx); + i965_render_sf_unit(ctx); +@@ -922,21 +920,17 @@ i965_surface_render_state_setup(VADriverContextP ctx, + i965_render_cc_viewport(ctx); + i965_render_cc_unit(ctx); + i965_render_binding_table(ctx); +- i965_render_upload_vertex(ctx, surface, +- srcx, srcy, srcw, srch, +- destx, desty, destw, desth); ++ return i965_render_upload_vertex(ctx, surface, src_rect, dst_rect, ++ cliprects, num_cliprects); + } +-static void ++ ++static unsigned int + i965_subpic_render_state_setup(VADriverContextP ctx, +- VASurfaceID surface, +- short srcx, +- short srcy, +- unsigned short srcw, +- unsigned short srch, +- short destx, +- short desty, +- unsigned short destw, +- unsigned short desth) ++ VASurfaceID surface, ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects) + { + i965_render_vs_unit(ctx); + i965_render_sf_unit(ctx); +@@ -947,16 +941,10 @@ i965_subpic_render_state_setup(VADriverContextP ctx, + i965_render_cc_viewport(ctx); + i965_subpic_render_cc_unit(ctx); + i965_render_binding_table(ctx); +- +- VARectangle output_rect; +- output_rect.x = destx; +- output_rect.y = desty; +- output_rect.width = destw; +- output_rect.height = desth; +- i965_subpic_render_upload_vertex(ctx, surface, &output_rect); ++ return i965_subpic_render_upload_vertex(ctx, surface, dst_rect, ++ cliprects, num_cliprects); + } + +- + static void + i965_render_pipeline_select(VADriverContextP ctx) + { +@@ -1192,7 +1180,7 @@ i965_render_upload_image_palette( + } + + static void +-i965_render_startup(VADriverContextP ctx) ++i965_render_startup(VADriverContextP ctx, unsigned int vb_offset) + { + struct i965_driver_data *i965 = i965_driver_data(ctx); + struct i965_render_state *render_state = &i965->render_state; +@@ -1203,7 +1191,7 @@ i965_render_startup(VADriverContextP ctx) + (0 << VB0_BUFFER_INDEX_SHIFT) | + VB0_VERTEXDATA | + ((4 * 4) << VB0_BUFFER_PITCH_SHIFT)); +- OUT_RELOC(ctx, render_state->vb.vertex_buffer, I915_GEM_DOMAIN_VERTEX, 0, 0); ++ OUT_RELOC(ctx, render_state->vb.vertex_buffer, I915_GEM_DOMAIN_VERTEX, 0, vb_offset); + + if (IS_IGDNG(i965->intel.device_id)) + OUT_RELOC(ctx, render_state->vb.vertex_buffer, I915_GEM_DOMAIN_VERTEX, 0, 12 * 4); +@@ -1268,8 +1256,10 @@ i965_clear_dest_region(VADriverContextP ctx) + } + + static void +-i965_surface_render_pipeline_setup(VADriverContextP ctx) ++i965_surface_render_pipeline_setup(VADriverContextP ctx, unsigned int n_rects) + { ++ unsigned int i; ++ + intel_batchbuffer_start_atomic(ctx, 0x1000); + intel_batchbuffer_emit_mi_flush(ctx); + i965_clear_dest_region(ctx); +@@ -1283,13 +1273,16 @@ i965_surface_render_pipeline_setup(VADriverContextP ctx) + i965_render_cs_urb_layout(ctx); + i965_render_drawing_rectangle(ctx); + i965_render_vertex_elements(ctx); +- i965_render_startup(ctx); ++ for (i = 0; i < n_rects; i++) ++ i965_render_startup(ctx, 48 * i); + intel_batchbuffer_end_atomic(ctx); + } + + static void +-i965_subpic_render_pipeline_setup(VADriverContextP ctx) ++i965_subpic_render_pipeline_setup(VADriverContextP ctx, unsigned int n_rects) + { ++ unsigned int i; ++ + intel_batchbuffer_start_atomic(ctx, 0x1000); + intel_batchbuffer_emit_mi_flush(ctx); + i965_render_pipeline_select(ctx); +@@ -1302,7 +1295,8 @@ i965_subpic_render_pipeline_setup(VADriverContextP ctx) + i965_render_cs_urb_layout(ctx); + i965_render_drawing_rectangle(ctx); + i965_render_vertex_elements(ctx); +- i965_render_startup(ctx); ++ for (i = 0; i < n_rects; i++) ++ i965_render_startup(ctx, 48 * i); + intel_batchbuffer_end_atomic(ctx); + } + +@@ -1396,45 +1390,39 @@ i965_render_initialize(VADriverContextP ctx) + void + i965_render_put_surface(VADriverContextP ctx, + VASurfaceID surface, +- short srcx, +- short srcy, +- unsigned short srcw, +- unsigned short srch, +- short destx, +- short desty, +- unsigned short destw, +- unsigned short desth) ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects) + { ++ unsigned int n_rects; ++ + i965_render_initialize(ctx); +- i965_surface_render_state_setup(ctx, surface, +- srcx, srcy, srcw, srch, +- destx, desty, destw, desth); +- i965_surface_render_pipeline_setup(ctx); ++ n_rects = i965_surface_render_state_setup(ctx, surface, ++ src_rect, dst_rect, ++ cliprects, num_cliprects); ++ i965_surface_render_pipeline_setup(ctx, n_rects); + intel_batchbuffer_flush(ctx); + } + + void + i965_render_put_subpic(VADriverContextP ctx, +- VASurfaceID surface, +- short srcx, +- short srcy, +- unsigned short srcw, +- unsigned short srch, +- short destx, +- short desty, +- unsigned short destw, +- unsigned short desth) ++ VASurfaceID surface, ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects) + { + struct i965_driver_data *i965 = i965_driver_data(ctx); + struct object_surface *obj_surface = SURFACE(surface); + struct object_subpic *obj_subpic = SUBPIC(obj_surface->subpic); ++ unsigned int n_rects; + assert(obj_subpic); + + i965_render_initialize(ctx); +- i965_subpic_render_state_setup(ctx, surface, +- srcx, srcy, srcw, srch, +- destx, desty, destw, desth); +- i965_subpic_render_pipeline_setup(ctx); ++ n_rects = i965_subpic_render_state_setup(ctx, surface, src_rect, dst_rect, ++ cliprects, num_cliprects); ++ i965_subpic_render_pipeline_setup(ctx, n_rects); + i965_render_upload_image_palette(ctx, obj_subpic->image, 0xff); + intel_batchbuffer_flush(ctx); + } +diff --git a/i965_drv_video/i965_render.h b/i965_drv_video/i965_render.h +index e3dce02..d2e23f1 100644 +--- a/i965_drv_video/i965_render.h ++++ b/i965_drv_video/i965_render.h +@@ -28,6 +28,7 @@ + #ifndef _I965_RENDER_H_ + #define _I965_RENDER_H_ + ++#define MAX_CLIP_RECTS 80 /* vb_bo:4096 / vb:(3*4*4) */ + #define MAX_RENDER_SURFACES 16 + #define MAX_SAMPLERS 16 + +@@ -65,27 +66,20 @@ struct i965_render_state + + Bool i965_render_init(VADriverContextP ctx); + Bool i965_render_terminate(VADriverContextP ctx); ++ + void i965_render_put_surface(VADriverContextP ctx, + VASurfaceID surface, +- short srcx, +- short srcy, +- unsigned short srcw, +- unsigned short srch, +- short destx, +- short desty, +- unsigned short destw, +- unsigned short desth); +- ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects); + + void + i965_render_put_subpic(VADriverContextP ctx, +- VASurfaceID surface, +- short srcx, +- short srcy, +- unsigned short srcw, +- unsigned short srch, +- short destx, +- short desty, +- unsigned short destw, +- unsigned short desth); ++ VASurfaceID surface, ++ const VARectangle *src_rect, ++ const VARectangle *dst_rect, ++ const VARectangle *cliprects, ++ unsigned int num_cliprects); ++ + #endif /* _I965_RENDER_H_ */ +-- +1.5.4.3 + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/102_attribute_visibility.patch b/meta-emenlow/packages/libva/libva-0.31.0/102_attribute_visibility.patch new file mode 100644 index 0000000000..2885ab7b5b --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/102_attribute_visibility.patch @@ -0,0 +1,47 @@ +commit 8d0004cbd40305114bbe8019122319b43d25a772 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 8 12:34:39 2009 +0000 + + Fix ATTRIBUTE_HIDDEN definition if __attribute__((visibility("hidden"))) is not supported. + +commit 7a8bf489ffd436d853364dd0d3c9a6734b8cc7eb +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Sep 3 15:46:37 2009 +0000 + + Check for __attribute__((visibility("hidden"))). + +diff --git a/configure.ac b/configure.ac +index da96872..abef435 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -132,6 +132,30 @@ if test x$enable_i965_driver = xyes && ! $PKG_CONFIG --atleast-version=2.4 libdr + fi + AM_CONDITIONAL(BUILD_I965_DRIVER, test x$enable_i965_driver = xyes) + ++dnl Check for __attribute__((visibility())) ++AC_CACHE_CHECK([whether __attribute__((visibility())) is supported], ++ libva_cv_visibility_attribute, ++ [cat > conftest.c <<EOF ++int foo __attribute__ ((visibility ("hidden"))) = 1; ++int bar __attribute__ ((visibility ("protected"))) = 1; ++EOF ++ libva_cv_visibility_attribute=no ++ if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then ++ if grep '\.hidden.*foo' conftest.s >/dev/null; then ++ if grep '\.protected.*bar' conftest.s >/dev/null; then ++ libva_cv_visibility_attribute=yes ++ fi ++ fi ++ fi ++ rm -f conftest.[cs] ++]) ++ATTRIBUTE_HIDDEN="" ++if test $libva_cv_visibility_attribute = yes; then ++ ATTRIBUTE_HIDDEN="__attribute__((visibility(\"hidden\")))" ++fi ++AC_DEFINE_UNQUOTED([ATTRIBUTE_HIDDEN], [$ATTRIBUTE_HIDDEN], ++ [Defined to __attribute__((visibility("hidden"))) when available]) ++ + # We only need the headers, we don't link against the DRM libraries + LIBVA_CFLAGS="$DRM_CFLAGS" + AC_SUBST(LIBVA_CFLAGS) diff --git a/meta-emenlow/packages/libva/libva-0.31.0/103_fix_vainfo_deps.patch b/meta-emenlow/packages/libva/libva-0.31.0/103_fix_vainfo_deps.patch new file mode 100644 index 0000000000..942c26d1bd --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/103_fix_vainfo_deps.patch @@ -0,0 +1,24 @@ +commit 11e626a3610daf0fce253ef48ab8736bce6178f9 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 22 12:29:56 2009 +0000 + + Fix vainfo dependencies (Konstantin Pavlov). + +diff --git a/test/Makefile.am b/test/Makefile.am +index 58e1677..ee78d34 100644 +--- a/test/Makefile.am ++++ b/test/Makefile.am +@@ -31,10 +31,10 @@ AM_CFLAGS = -I$(top_srcdir)/../../include/external/ -I$(top_srcdir)/src -I$(top_ + + TESTS = $(check_PROGRAMS) + +-TEST_LIBS = $(top_srcdir)/src/$(libvabackendlib) ++TEST_LIBS = $(top_srcdir)/src/libva.la $(top_srcdir)/src/$(libvabackendlib) + +-vainfo_LDADD = $(top_srcdir)/src/$(libvabackendlib) +-vainfo_DEPENDENCIES = $(top_srcdir)/src/$(libvabackendlib) ++vainfo_LDADD = $(top_srcdir)/src/libva.la $(top_srcdir)/src/$(libvabackendlib) ++vainfo_DEPENDENCIES = $(top_srcdir)/src/libva.la $(top_srcdir)/src/$(libvabackendlib) + vainfo_SOURCES = vainfo.c + + test_01_LDADD = $(TEST_LIBS) diff --git a/meta-emenlow/packages/libva/libva-0.31.0/104_fix_libva_pkgconfig_deps.patch b/meta-emenlow/packages/libva/libva-0.31.0/104_fix_libva_pkgconfig_deps.patch new file mode 100644 index 0000000000..bd212bf39c --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/104_fix_libva_pkgconfig_deps.patch @@ -0,0 +1,18 @@ +commit f0b352251894becfcec50de1430bda12c314a464 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 22 13:00:34 2009 +0000 + + Fix libva-x11 pkgconfig dependencies. + +diff --git a/libva-x11.pc.in b/libva-x11.pc.in +index 75e4f0b..6dde07f 100644 +--- a/libva-x11.pc.in ++++ b/libva-x11.pc.in +@@ -6,6 +6,7 @@ display=x11 + + Name: libva-${display} + Description: Userspace Video Acceleration (VA) ${display} interface ++Requires: libva + Version: @PACKAGE_VERSION@ + Libs: -L${libdir} -lva-${display} + Cflags: -I${includedir} diff --git a/meta-emenlow/packages/libva/libva-0.31.0/105_dont_search_LIBGL_DRIVERS_PATH.patch b/meta-emenlow/packages/libva/libva-0.31.0/105_dont_search_LIBGL_DRIVERS_PATH.patch new file mode 100644 index 0000000000..de873d6014 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/105_dont_search_LIBGL_DRIVERS_PATH.patch @@ -0,0 +1,21 @@ +commit 035374378644216fb3a7d3974a8c46b1bd425918 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 22 13:03:23 2009 +0000 + + Don't search LIBGL_DRIVERS_PATH, stick to LIBVA_DRIVERS_PATH only or the default path. + +diff --git a/src/va.c b/src/va.c +index 12662cd..723235e 100644 +--- a/src/va.c ++++ b/src/va.c +@@ -134,10 +134,6 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name) + { + /* don't allow setuid apps to use LIBVA_DRIVERS_PATH */ + search_path = getenv("LIBVA_DRIVERS_PATH"); +- if (!search_path) +- { +- search_path = getenv("LIBGL_DRIVERS_PATH"); +- } + } + if (!search_path) + { diff --git a/meta-emenlow/packages/libva/libva-0.31.0/108_drivers_path.patch b/meta-emenlow/packages/libva/libva-0.31.0/108_drivers_path.patch new file mode 100644 index 0000000000..073c987054 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/108_drivers_path.patch @@ -0,0 +1,25 @@ +From 332bfec6020b5cfcef5d655f4bf525dab67c0b92 Mon Sep 17 00:00:00 2001 +From: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed, 24 Jun 2009 08:12:13 +0000 +Subject: [PATCH] Install drivers into pkglibdir/va/. + +--- + configure.ac | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/configure.ac b/configure.ac +index 4be2b56..d595ac9 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -73,7 +73,7 @@ AC_ARG_ENABLE(i965-driver, + + AC_ARG_WITH(drivers-path, + [AC_HELP_STRING([--with-drivers-path=[[path]]], [drivers path])],, +- [with_drivers_path="$libdir/dri"]) ++ [with_drivers_path="$libdir/va/drivers"]) + + LIBVA_DRIVERS_PATH="$with_drivers_path" + AC_SUBST(LIBVA_DRIVERS_PATH) +-- +1.5.4.3 + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/203_fix_fglrx_detection.patch b/meta-emenlow/packages/libva/libva-0.31.0/203_fix_fglrx_detection.patch new file mode 100644 index 0000000000..ce7f10653c --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/203_fix_fglrx_detection.patch @@ -0,0 +1,542 @@ +commit fb6ccda5984eda96bcb394b23255143dcbc21f18 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Sep 10 12:22:17 2009 +0000 + + Don't link against libdrm to workaround XvBA / fglrx >= 8.66-RC1 bugs. + +commit ab3c0f65182462b54729d2d82d4d645c8be5b2d1 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed Sep 9 13:24:46 2009 +0000 + + Fix DRM device opening with fglrx >= 8.66-RC1. + +diff --git a/src/x11/Makefile.am b/src/x11/Makefile.am +index c70380d..b6916f2 100644 +--- a/src/x11/Makefile.am ++++ b/src/x11/Makefile.am +@@ -25,6 +25,6 @@ noinst_LTLIBRARIES = libva_x11.la + libva_x11includedir = ${includedir}/va + libva_x11include_HEADERS = va_x11.h va_dri.h va_dri2.h va_dricommon.h + +-libva_x11_la_SOURCES = va_x11.c va_dri.c va_dri2.c va_dricommon.c dri2_util.c dri1_util.c va_nvctrl.c ++libva_x11_la_SOURCES = va_x11.c va_dri.c va_dri2.c va_dricommon.c dri2_util.c dri1_util.c va_nvctrl.c libdrm_glue.c + +-EXTRA_DIST = va_dristr.h va_dri2str.h va_dri2tokens.h va_nvctrl.h ++EXTRA_DIST = va_dristr.h va_dri2str.h va_dri2tokens.h va_nvctrl.h libdrm_glue.h +diff --git a/src/x11/dri1_util.c b/src/x11/dri1_util.c +index b3db5b4..3bd490f 100644 +--- a/src/x11/dri1_util.c ++++ b/src/x11/dri1_util.c +@@ -1,10 +1,12 @@ ++#include "config.h" ++#include <stdio.h> + #include <stdlib.h> + #include <fcntl.h> + #include <unistd.h> + #include <sys/mman.h> + #include <assert.h> + +-#include <xf86drm.h> ++#include "libdrm_glue.h" + + #include "X11/Xlib.h" + #include "va.h" +@@ -21,6 +23,75 @@ struct dri1_drawable + int height; + }; + ++static int ++firegl_drmOpenMinor(int minor) ++{ ++ char buf[64]; ++ int fd; ++ ++ sprintf(buf, "/dev/ati/card%d", minor); ++ if ((fd = open(buf, O_RDWR, 0)) >= 0) ++ return fd; ++ return -1; ++} ++ ++static int ++firegl_drmOpenByBusID(const char *busid) ++{ ++ int i, fd; ++ drmSetVersion sv; ++ const char *buf; ++ ++ for (i = 0; i < DRM_MAX_MINOR; i++) { ++ if ((fd = firegl_drmOpenMinor(i)) < 0) ++ continue; ++ sv.drm_di_major = 1; ++ sv.drm_di_minor = 1; ++ sv.drm_dd_major = -1; ++ sv.drm_dd_minor = -1; ++ libdrm_drmSetInterfaceVersion(fd, &sv); ++ buf = libdrm_drmGetBusid(fd); ++ if (buf && strcasecmp(buf, busid) == 0) { /* XXX: drmMatchBusID() */ ++ libdrm_drmFreeBusid(buf); ++ return fd; ++ } ++ if (buf) ++ libdrm_drmFreeBusid(buf); ++ close(fd); ++ } ++ return -1; ++} ++ ++static int ++drm_open_once(struct dri_state *dri_state, const char *BusID, int *newlyopened) ++{ ++ dri_state->driConnectedFlag = VA_NONE; ++ dri_state->fd = libdrm_drmOpenOnce(NULL, BusID, newlyopened); ++ if (dri_state->fd < 0) { ++ dri_state->fd = firegl_drmOpenByBusID(BusID); ++ if (dri_state->fd >= 0) { ++ *newlyopened = 1; ++ dri_state->driConnectedFlag |= VA_DRI_AMD; ++ } ++ } ++ return dri_state->fd; ++} ++ ++static void ++drm_close_once(struct dri_state *dri_state) ++{ ++ /* XXX: dri_state->close() doesn't seem to be called, thus this ++ function is never called either */ ++ if (dri_state->fd < 0) ++ return; ++ if (dri_state->driConnectedFlag & VA_DRI_AMD) ++ close(dri_state->fd); ++ else ++ libdrm_drmCloseOnce(dri_state->fd); ++ dri_state->fd = -1; ++ dri_state->driConnectedFlag = VA_NONE; ++} ++ + static struct dri_drawable * + dri1CreateDrawable(VADriverContextP ctx, XID x_drawable) + { +@@ -64,9 +135,9 @@ dri1Close(VADriverContextP ctx) + free_drawable_hashtable(ctx); + VA_DRIDestroyContext(ctx->x11_dpy, ctx->x11_screen, dri_state->hwContextID); + assert(dri_state->pSAREA != MAP_FAILED); +- drmUnmap(dri_state->pSAREA, SAREA_MAX); ++ libdrm_drmUnmap(dri_state->pSAREA, SAREA_MAX); + assert(dri_state->fd >= 0); +- drmCloseOnce(dri_state->fd); ++ drm_close_once(dri_state); + VA_DRICloseConnection(ctx->x11_dpy, ctx->x11_screen); + } + +@@ -104,21 +175,20 @@ isDRI1Connected(VADriverContextP ctx, char **driver_name) + &dri_state->hSAREA, &BusID)) + goto err_out0; + +- +- dri_state->fd = drmOpenOnce(NULL, BusID, &newlyopened); ++ drm_open_once(dri_state, BusID, &newlyopened); + XFree(BusID); + + if (dri_state->fd < 0) + goto err_out1; + + +- if (drmGetMagic(dri_state->fd, &magic)) ++ if (libdrm_drmGetMagic(dri_state->fd, &magic)) + goto err_out1; + + if (newlyopened && !VA_DRIAuthConnection(ctx->x11_dpy, ctx->x11_screen, magic)) + goto err_out1; + +- if (drmMap(dri_state->fd, dri_state->hSAREA, SAREA_MAX, &dri_state->pSAREA)) ++ if (libdrm_drmMap(dri_state->fd, dri_state->hSAREA, SAREA_MAX, &dri_state->pSAREA)) + goto err_out1; + + if (!VA_DRICreateContext(ctx->x11_dpy, ctx->x11_screen, +@@ -127,7 +196,8 @@ isDRI1Connected(VADriverContextP ctx, char **driver_name) + &dri_state->hwContextID, &dri_state->hwContext)) + goto err_out1; + +- dri_state->driConnectedFlag = VA_DRI1; ++ dri_state->driConnectedFlag &= VA_DRI_AMD; /* clear flags but AMD bit */ ++ dri_state->driConnectedFlag |= VA_DRI1; + dri_state->createDrawable = dri1CreateDrawable; + dri_state->destroyDrawable = dri1DestroyDrawable; + dri_state->swapBuffer = dri1SwapBuffer; +@@ -138,10 +208,10 @@ isDRI1Connected(VADriverContextP ctx, char **driver_name) + + err_out1: + if (dri_state->pSAREA != MAP_FAILED) +- drmUnmap(dri_state->pSAREA, SAREA_MAX); ++ libdrm_drmUnmap(dri_state->pSAREA, SAREA_MAX); + + if (dri_state->fd >= 0) +- drmCloseOnce(dri_state->fd); ++ drm_close_once(dri_state); + + VA_DRICloseConnection(ctx->x11_dpy, ctx->x11_screen); + +diff --git a/src/x11/dri2_util.c b/src/x11/dri2_util.c +index ebe7a2c..b727e97 100644 +--- a/src/x11/dri2_util.c ++++ b/src/x11/dri2_util.c +@@ -3,7 +3,7 @@ + #include <unistd.h> + #include <assert.h> + +-#include <xf86drm.h> ++#include "libdrm_glue.h" + + #include <X11/Xlibint.h> + #include <X11/Xlib.h> +@@ -166,7 +166,7 @@ isDRI2Connected(VADriverContextP ctx, char **driver_name) + if (dri_state->fd < 0) + goto err_out; + +- if (drmGetMagic(dri_state->fd, &magic)) ++ if (libdrm_drmGetMagic(dri_state->fd, &magic)) + goto err_out; + + if (!VA_DRI2Authenticate(ctx->x11_dpy, RootWindow(ctx->x11_dpy, ctx->x11_screen), +diff --git a/src/x11/libdrm_glue.c b/src/x11/libdrm_glue.c +new file mode 100644 +index 0000000..b72a2d1 +--- /dev/null ++++ b/src/x11/libdrm_glue.c +@@ -0,0 +1,208 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#define _GNU_SOURCE 1 ++#include "libdrm_glue.h" ++#include <stdio.h> ++#include <string.h> ++#include <dlfcn.h> ++#include <assert.h> ++ ++#define LOAD_FUNC_(NAME, RET, ARGS, FALLBACK) \ ++ static RET (*lib_##NAME) ARGS; \ ++ if (lib_##NAME == NULL) { \ ++ lib_##NAME = libdrm_symbol(#NAME); \ ++ if (!lib_##NAME) \ ++ lib_##NAME = FALLBACK; \ ++ } \ ++ assert(lib_##NAME != NULL) ++ ++#define LOAD_FUNC(NAME, RET, ARGS) \ ++ LOAD_FUNC_(NAME, RET, ARGS, NULL) ++ ++static void *libdrm_handle; ++static int libdrm_handle_ok = -1; ++ ++static inline void *libdrm_symbol(const char *name) ++{ ++ if (!libdrm_open()) ++ return NULL; ++ return dlsym(libdrm_handle, name); ++} ++ ++int libdrm_open(void) ++{ ++ if (libdrm_handle_ok < 0) { ++ libdrm_handle = dlopen("libdrm.so.2", RTLD_LOCAL|RTLD_LAZY); ++ libdrm_handle_ok = libdrm_handle != NULL; ++ } ++ assert(libdrm_handle); ++ return libdrm_handle_ok; ++} ++ ++void libdrm_close(void) ++{ ++ if (libdrm_handle) ++ dlclose(libdrm_handle); ++} ++ ++// Default drmOpenOnce() and drmCloseOnce() implementations based on current GIT ++#define DRM_MAX_FDS 16 ++static struct { ++ char *BusID; ++ int fd; ++ int refcount; ++} connection[DRM_MAX_FDS]; ++ ++static int nr_fds = 0; ++ ++// Default implementation for drmOpenOnce() if none exists in the library ++static int ++libdrm_default_drmOpenOnce(void *unused, const char *BusID, int *newlyopened) ++{ ++ int i; ++ int fd; ++ ++ for (i = 0; i < nr_fds; i++) ++ if (strcmp(BusID, connection[i].BusID) == 0) { ++ connection[i].refcount++; ++ *newlyopened = 0; ++ return connection[i].fd; ++ } ++ ++ fd = libdrm_drmOpen(unused, BusID); ++ if (fd <= 0 || nr_fds == DRM_MAX_FDS) ++ return fd; ++ ++ connection[nr_fds].BusID = strdup(BusID); ++ connection[nr_fds].fd = fd; ++ connection[nr_fds].refcount = 1; ++ *newlyopened = 1; ++ ++ if (0) ++ fprintf(stderr, "saved connection %d for %s %d\n", ++ nr_fds, connection[nr_fds].BusID, ++ strcmp(BusID, connection[nr_fds].BusID)); ++ nr_fds++; ++ return fd; ++} ++ ++// Default implementation for drmCloseOnce() if none exists in the library ++static void libdrm_default_drmCloseOnce(int fd) ++{ ++ int i; ++ ++ for (i = 0; i < nr_fds; i++) { ++ if (fd == connection[i].fd) { ++ if (--connection[i].refcount == 0) { ++ libdrm_drmClose(connection[i].fd); ++ free(connection[i].BusID); ++ if (i < --nr_fds) ++ connection[i] = connection[nr_fds]; ++ return; ++ } ++ } ++ } ++} ++ ++// Determine whether the DRM kernel driver has been loaded ++int libdrm_drmAvailable(void) ++{ ++ LOAD_FUNC(drmAvailable, int, (void)); ++ return lib_drmAvailable(); ++} ++ ++// Open the DRM device ++int libdrm_drmOpen(const char *name, const char *busid) ++{ ++ LOAD_FUNC(drmOpen, int, (const char *, const char *)); ++ return lib_drmOpen(name, busid); ++} ++ ++// Close the device ++int libdrm_drmClose(int fd) ++{ ++ LOAD_FUNC(drmClose, int, (int)); ++ return lib_drmClose(fd); ++} ++ ++// Open the DRM device (re-use an existing connection) ++int libdrm_drmOpenOnce(void *unused, const char *BusID, int *newlyopened) ++{ ++ LOAD_FUNC_(drmOpenOnce, int, (void *, const char *, int *), ++ libdrm_default_drmOpenOnce); ++ return lib_drmOpenOnce(unused, BusID, newlyopened); ++} ++ ++// Close the device (unref an existing connection prior to actually closing it) ++void libdrm_drmCloseOnce(int fd) ++{ ++ LOAD_FUNC_(drmCloseOnce, void, (int), libdrm_default_drmCloseOnce); ++ lib_drmCloseOnce(fd); ++} ++ ++// DRM connection cookie ++int libdrm_drmGetMagic(int fd, drm_magic_t * magic) ++{ ++ LOAD_FUNC(drmGetMagic, int, (int, drm_magic_t *)); ++ return lib_drmGetMagic(fd, magic); ++} ++ ++// Issue a set-version ioctl ++int libdrm_drmSetInterfaceVersion(int fd, drmSetVersion *version) ++{ ++ LOAD_FUNC(drmSetInterfaceVersion, int, (int, drmSetVersion *)); ++ return lib_drmSetInterfaceVersion(fd, version); ++} ++ ++// Get the bus ID of the device ++char *libdrm_drmGetBusid(int fd) ++{ ++ LOAD_FUNC(drmGetBusid, char *, (int)); ++ return lib_drmGetBusid(fd); ++} ++ ++// Free the bus ID information ++void libdrm_drmFreeBusid(const char *busid) ++{ ++ LOAD_FUNC(drmFreeBusid, void, (const char *)); ++ lib_drmFreeBusid(busid); ++} ++ ++// Map a region of memory ++int libdrm_drmMap(int fd, ++ drm_handle_t handle, ++ drmSize size, ++ drmAddressPtr address) ++{ ++ LOAD_FUNC(drmMap, int, (int, drm_handle_t, drmSize, drmAddressPtr)); ++ return lib_drmMap(fd, handle, size, address); ++} ++ ++// Unmap mappings obtained with drmMap() ++int libdrm_drmUnmap(drmAddress address, drmSize size) ++{ ++ LOAD_FUNC(drmUnmap, int, (drmAddress, drmSize)); ++ return lib_drmUnmap(address, size); ++} +diff --git a/src/x11/libdrm_glue.h b/src/x11/libdrm_glue.h +new file mode 100644 +index 0000000..878470b +--- /dev/null ++++ b/src/x11/libdrm_glue.h +@@ -0,0 +1,73 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#ifndef LIBDRM_GLUE_H ++#define LIBDRM_GLUE_H ++ ++#include "config.h" ++#include <xf86drm.h> ++ ++int libdrm_open(void) ++ ATTRIBUTE_HIDDEN; ++ ++void libdrm_close(void) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmAvailable(void) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmOpen(const char *name, const char *busid) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmClose(int fd) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmOpenOnce(void *unused, const char *BusID, int *newlyopened) ++ ATTRIBUTE_HIDDEN; ++ ++void libdrm_drmCloseOnce(int fd) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmGetMagic(int fd, drm_magic_t * magic) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmSetInterfaceVersion(int fd, drmSetVersion *version) ++ ATTRIBUTE_HIDDEN; ++ ++char *libdrm_drmGetBusid(int fd) ++ ATTRIBUTE_HIDDEN; ++ ++void libdrm_drmFreeBusid(const char *busid) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmMap(int fd, ++ drm_handle_t handle, ++ drmSize size, ++ drmAddressPtr address) ++ ATTRIBUTE_HIDDEN; ++ ++int libdrm_drmUnmap(drmAddress address, drmSize size) ++ ATTRIBUTE_HIDDEN; ++ ++#endif /* LIBDRM_GLUE_H */ +diff --git a/src/x11/va_dricommon.h b/src/x11/va_dricommon.h +index a2a51a6..0da35fe 100644 +--- a/src/x11/va_dricommon.h ++++ b/src/x11/va_dricommon.h +@@ -13,7 +13,8 @@ enum + { + VA_NONE = 0, + VA_DRI1 = 1, +- VA_DRI2 = 2 ++ VA_DRI2 = 2, ++ VA_DRI_AMD = 4 /* AMD DRI implementation */ + }; + + union dri_buffer +diff --git a/src/x11/va_x11.c b/src/x11/va_x11.c +index b8c60fa..414c261 100644 +--- a/src/x11/va_x11.c ++++ b/src/x11/va_x11.c +@@ -31,6 +31,7 @@ + #include "va_dri2.h" + #include "va_dricommon.h" + #include "va_nvctrl.h" ++#include "libdrm_glue.h" + #include <stdio.h> + #include <stdarg.h> + #include <string.h> +@@ -94,6 +75,8 @@ static void va_DisplayContextDestroy ( + } + ctx = &((*ctx)->pNext); + } ++ ++ libdrm_close(); + free(pDisplayContext->pDriverContext->dri_state); + free(pDisplayContext->pDriverContext); + free(pDisplayContext); +diff --git a/src/Makefile.am b/src/Makefile.am +index e50a15f..d1f8f70 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -45,7 +45,7 @@ libva_la_LDFLAGS = $(LDADD) -no-undefined + libva_la_LIBADD = $(LIBVA_LIBS) -ldl + + libva_x11_la_SOURCES = +-libva_x11_la_LIBADD = $(libvacorelib) x11/libva_x11.la $(LIBVA_LIBS) $(X11_LIBS) $(XEXT_LIBS) $(DRM_LIBS) $(XFIXES_LIBS) ++libva_x11_la_LIBADD = $(libvacorelib) x11/libva_x11.la $(LIBVA_LIBS) $(X11_LIBS) $(XEXT_LIBS) $(XFIXES_LIBS) -ldl + libva_x11_la_LDFLAGS = $(LDADD) + libva_x11_la_DEPENDENCIES = $(libvacorelib) x11/libva_x11.la + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/204_check_ATIFGLEXTENSION.patch b/meta-emenlow/packages/libva/libva-0.31.0/204_check_ATIFGLEXTENSION.patch new file mode 100644 index 0000000000..02920a8944 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/204_check_ATIFGLEXTENSION.patch @@ -0,0 +1,312 @@ +commit d91645f8b37aa43bafa76da3146dcdc9c17963ff +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Fri Nov 20 15:51:22 2009 +0000 + + Fix detection of fglrx. + +diff --git a/src/x11/Makefile.am b/src/x11/Makefile.am +index b6916f2..0b61c33 100644 +--- a/src/x11/Makefile.am ++++ b/src/x11/Makefile.am +@@ -25,6 +25,23 @@ noinst_LTLIBRARIES = libva_x11.la + libva_x11includedir = ${includedir}/va + libva_x11include_HEADERS = va_x11.h va_dri.h va_dri2.h va_dricommon.h + +-libva_x11_la_SOURCES = va_x11.c va_dri.c va_dri2.c va_dricommon.c dri2_util.c dri1_util.c va_nvctrl.c libdrm_glue.c ++libva_x11_la_SOURCES = \ ++ dri1_util.c \ ++ dri2_util.c \ ++ libdrm_glue.c \ ++ va_dri.c \ ++ va_dri2.c \ ++ va_dricommon.c \ ++ va_fglext.c \ ++ va_nvctrl.c \ ++ va_x11.c \ ++ $(NULL) + +-EXTRA_DIST = va_dristr.h va_dri2str.h va_dri2tokens.h va_nvctrl.h libdrm_glue.h ++EXTRA_DIST = \ ++ libdrm_glue.h \ ++ va_dri2str.h \ ++ va_dri2tokens.h \ ++ va_dristr.h \ ++ va_fglext.h \ ++ va_nvctrl.h \ ++ $(NULL) +diff --git a/src/x11/va_fglext.c b/src/x11/va_fglext.c +new file mode 100644 +index 0000000..bc58e8b +--- /dev/null ++++ b/src/x11/va_fglext.c +@@ -0,0 +1,175 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#define _GNU_SOURCE 1 ++#include <string.h> ++ ++#define NEED_REPLIES ++#include <stdlib.h> ++#include <X11/Xlibint.h> ++#include <X11/Xutil.h> ++#include <X11/extensions/Xext.h> ++#include <X11/extensions/extutil.h> ++#include "va_fglext.h" ++ ++#define ATIFGL_EXTENSION_NAME "ATIFGLEXTENSION" ++#define ATIFGL_EXTENSION_EVENTS 0 ++ ++typedef struct _FGLGetDriverData { ++ CARD8 reqType; ++ CARD8 fireglReqType; ++ CARD16 length B16; ++ CARD32 screen B32; ++ CARD16 size B16; ++ CARD16 pad1; ++} xFGLGetDriverDataReq; ++#define sz_xFGLGetDriverDataReq sizeof(xFGLGetDriverDataReq) ++ ++typedef struct { ++ BYTE type; ++ BYTE pad1; ++ CARD16 sequenceNumber B16; ++ CARD32 length B32; ++ CARD8 majorVersion; ++ CARD8 minorVersion; ++ CARD8 patchlevel B16; ++ CARD8 BIOSVersionMajor; ++ CARD8 BIOSVersionMinor; ++ CARD8 HasSecondary; ++ CARD16 pad3 B16; ++ CARD32 pad4 B32; ++ CARD32 pad5 B32; ++ CARD32 pad6 B32; ++ CARD32 pad7 B32; ++ // ... there are more fields ++} xFGLGetDriverDataReply; ++#define sz_xFGLGetDriverDataReply sizeof(xFGLGetDriverDataReply) ++ ++#define X_FGLGetDriverData 0 ++ ++static XExtensionInfo _fglext_ext_info_data; ++static XExtensionInfo *fglext_ext_info = &_fglext_ext_info_data; ++static /* const */ char *fglext_extension_name = ATIFGL_EXTENSION_NAME; ++ ++#define xFGLCheckExtension(dpy,i,val) \ ++ XextCheckExtension (dpy, i, fglext_extension_name, val) ++ ++static int close_display(); ++static /* const */ XExtensionHooks fglext_extension_hooks = { ++ NULL, /* create_gc */ ++ NULL, /* copy_gc */ ++ NULL, /* flush_gc */ ++ NULL, /* free_gc */ ++ NULL, /* create_font */ ++ NULL, /* free_font */ ++ close_display, /* close_display */ ++ NULL, /* wire_to_event */ ++ NULL, /* event_to_wire */ ++ NULL, /* error */ ++ NULL, /* error_string */ ++}; ++ ++static XEXT_GENERATE_FIND_DISPLAY (find_display, fglext_ext_info, ++ fglext_extension_name, ++ &fglext_extension_hooks, ++ ATIFGL_EXTENSION_EVENTS, NULL) ++ ++static XEXT_GENERATE_CLOSE_DISPLAY (close_display, fglext_ext_info) ++ ++Bool VA_FGLEXTQueryDirectRenderingCapable( Display *dpy, int screen, ++ Bool *isCapable ) ++{ ++ char **extensions; ++ int i, n_extensions, has_fglext = 0, has_fglrxdri = 0; ++ ++ if (isCapable) ++ *isCapable = False; ++ ++ extensions = XListExtensions(dpy, &n_extensions); ++ if (!extensions) ++ return False; ++ ++ for (i = 0; i < n_extensions; i++) { ++ if (strcmp(extensions[i], ATIFGL_EXTENSION_NAME) == 0) ++ has_fglext = 1; ++ if (strcmp(extensions[i], "ATIFGLRXDRI") == 0) ++ has_fglrxdri = 1; ++ } ++ XFreeExtensionList(extensions); ++ ++ if (!has_fglext) ++ return False; ++ ++ if (isCapable) ++ *isCapable = has_fglrxdri; ++ ++ return True; ++} ++ ++Bool VA_FGLEXTGetClientDriverName( Display *dpy, int screen, ++ int *ddxDriverMajorVersion, int *ddxDriverMinorVersion, ++ int *ddxDriverPatchVersion, char **clientDriverName ) ++{ ++ XExtDisplayInfo *info = find_display (dpy); ++ xFGLGetDriverDataReply rep; ++ xFGLGetDriverDataReq *req; ++ ++ if (ddxDriverMajorVersion) ++ *ddxDriverMajorVersion = 0; ++ if (ddxDriverMinorVersion) ++ *ddxDriverMinorVersion = 0; ++ if (ddxDriverPatchVersion) ++ *ddxDriverPatchVersion = 0; ++ if (clientDriverName) ++ *clientDriverName = NULL; ++ ++ if(!XextHasExtension(info)) ++ return False; ++ ++ xFGLCheckExtension (dpy, info, False); ++ ++ LockDisplay (dpy); ++ GetReq (FGLGetDriverData, req); ++ req->reqType = info->codes->major_opcode; ++ req->fireglReqType = X_FGLGetDriverData; ++ req->screen = screen; ++ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { ++ UnlockDisplay (dpy); ++ SyncHandle (); ++ return False; ++ } ++ UnlockDisplay (dpy); ++ SyncHandle (); ++ ++ if (ddxDriverMajorVersion) ++ *ddxDriverMajorVersion = rep.majorVersion; ++ if (ddxDriverMinorVersion) ++ *ddxDriverMinorVersion = rep.minorVersion; ++ if (ddxDriverPatchVersion) ++ *ddxDriverPatchVersion = rep.patchlevel; ++ if (clientDriverName) ++ *clientDriverName = strdup("fglrx"); ++ ++ return True; ++} +diff --git a/src/x11/va_fglext.h b/src/x11/va_fglext.h +new file mode 100644 +index 0000000..f2d87c3 +--- /dev/null ++++ b/src/x11/va_fglext.h +@@ -0,0 +1,37 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#ifndef VA_FGLEXTLIB_H ++#define VA_FGLEXTLIB_H ++ ++#include <X11/Xlib.h> ++ ++Bool VA_FGLEXTQueryDirectRenderingCapable( Display *dpy, int screen, ++ Bool *isCapable ); ++ ++Bool VA_FGLEXTGetClientDriverName( Display *dpy, int screen, ++ int *ddxDriverMajorVersion, int *ddxDriverMinorVersion, ++ int *ddxDriverPatchVersion, char **clientDriverName ); ++ ++#endif /* VA_FGLEXTLIB_H */ +diff --git a/src/x11/va_x11.c b/src/x11/va_x11.c +index 414c261..0510e00 100644 +--- a/src/x11/va_x11.c ++++ b/src/x11/va_x11.c +@@ -31,6 +31,7 @@ + #include "va_dri2.h" + #include "va_dricommon.h" + #include "va_nvctrl.h" ++#include "va_fglext.h" + #include "libdrm_glue.h" + #include <stdio.h> + #include <stdarg.h> +@@ -132,6 +133,29 @@ static VAStatus va_NVCTRL_GetDriverName ( + return VA_STATUS_SUCCESS; + } + ++static VAStatus va_FGLEXT_GetDriverName( ++ VADisplayContextP pDisplayContext, ++ char **driver_name ++) ++{ ++ VADriverContextP ctx = pDisplayContext->pDriverContext; ++ int direct_capable, driver_major, driver_minor, driver_patch; ++ Bool result; ++ ++ result = VA_FGLEXTQueryDirectRenderingCapable(ctx->x11_dpy, ctx->x11_screen, ++ &direct_capable); ++ if (!result || !direct_capable) ++ return VA_STATUS_ERROR_UNKNOWN; ++ ++ result = VA_FGLEXTGetClientDriverName(ctx->x11_dpy, ctx->x11_screen, ++ &driver_major, &driver_minor, ++ &driver_patch, driver_name); ++ if (!result) ++ return VA_STATUS_ERROR_UNKNOWN; ++ ++ return VA_STATUS_SUCCESS; ++} ++ + static VAStatus va_DisplayContextGetDriverName ( + VADisplayContextP pDisplayContext, + char **driver_name +@@ -156,7 +180,8 @@ static VAStatus va_DisplayContextGetDriverName ( + vaStatus = va_DRIGetDriverName(pDisplayContext, driver_name); + if (vaStatus != VA_STATUS_SUCCESS) + vaStatus = va_NVCTRL_GetDriverName(pDisplayContext, driver_name); +- ++ if (vaStatus != VA_STATUS_SUCCESS) ++ vaStatus = va_FGLEXT_GetDriverName(pDisplayContext, driver_name); + return vaStatus; + } + diff --git a/meta-emenlow/packages/libva/libva-0.31.0/300_sds_version.patch b/meta-emenlow/packages/libva/libva-0.31.0/300_sds_version.patch new file mode 100644 index 0000000000..07531c90cb --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/300_sds_version.patch @@ -0,0 +1,87 @@ +commit 890acc1975ed9f6b7173ff6fbf9d689943590913 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed Jun 24 11:32:40 2009 +0000 + + Explicit API extensions from SDS. + +diff --git a/configure.ac b/configure.ac +index 3999dc4..17b0403 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -28,6 +28,9 @@ m4_define([libva_micro_version], [0]) + m4_define([libva_version], + [libva_major_version.libva_minor_version.libva_micro_version]) + ++# increase this number for each API change ++m4_define([libva_sds_version], [4]) ++ + # if the library source code has changed, increment revision + m4_define([libva_lt_revision], [0]) + # if any interface was added/removed/changed, then inc current, reset revision +@@ -52,11 +55,14 @@ AC_SUBST(LIBVA_MINOR_VERSION) + AC_SUBST(LIBVA_MICRO_VERSION) + AC_SUBST(LIBVA_VERSION) + ++LIBVA_SDS_VERSION=libva_sds_version ++AC_SUBST(LIBVA_SDS_VERSION) ++ + LIBVA_LT_CURRENT=libva_lt_current + LIBVA_LT_REV=libva_lt_revision + LIBVA_LT_AGE=libva_lt_age + LIBVA_LT_VERSION="$LIBVA_LT_CURRENT:$LIBVA_LT_REV:$LIBVA_LT_AGE" +-LIBVA_LT_LDFLAGS="-version-info $LIBVA_LT_VERSION" ++LIBVA_LT_LDFLAGS="-version-info $LIBVA_LT_VERSION -release $LIBVA_VERSION.$LIBVA_SDS_VERSION" + AC_SUBST(LIBVA_LT_VERSION) + AC_SUBST(LIBVA_LT_LDFLAGS) + +diff --git a/src/va.c b/src/va.c +index f9791f8..b60ac12 100644 +--- a/src/va.c ++++ b/src/va.c +@@ -35,6 +35,7 @@ + #include <linux/videodev2.h> + + #define DRIVER_INIT_FUNC "__vaDriverInit_0_31" ++#define DRIVER_INIT_FUNC_SDS "__vaDriverInit_0_31_sds" + + #define DRIVER_EXTENSION "_drv_video.so" + +@@ -160,6 +161,11 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name) + init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC); + if (!init_func) + { ++ /* Then try SDS extensions (VDPAU and XvBA backends) */ ++ init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_SDS); ++ } ++ if (!init_func) ++ { + va_errorMessage("%s has no function %s\n", driver_path, DRIVER_INIT_FUNC); + dlclose(handle); + } +diff --git a/src/va_version.h.in b/src/va_version.h.in +index c9ea97a..197c482 100644 +--- a/src/va_version.h.in ++++ b/src/va_version.h.in +@@ -47,6 +47,13 @@ + #define VA_MICRO_VERSION (@LIBVA_MICRO_VERSION@) + + /** ++ * VA_SDS_VERSION: ++ * ++ * The version of the SDS API extensions to the VA library ++ */ ++#define VA_SDS_VERSION (@LIBVA_SDS_VERSION@) ++ ++/** + * VA_VERSION: + * + * The full version of the VA library, like 1.2.3 +@@ -59,7 +66,7 @@ + * The full version of the VA library, in string form (suited for + * string concatenation) + */ +-#define VA_VERSION_S "@LIBVA_VERSION@" ++#define VA_VERSION_S "@LIBVA_VERSION@-sds@LIBVA_SDS_VERSION@" + + /** + * VA_VERSION_HEX: diff --git a/meta-emenlow/packages/libva/libva-0.31.0/301_vdpau_mpeg4.patch b/meta-emenlow/packages/libva/libva-0.31.0/301_vdpau_mpeg4.patch new file mode 100644 index 0000000000..86188902ab --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/301_vdpau_mpeg4.patch @@ -0,0 +1,26 @@ +commit 3c2d45290e1369083a27d53a5f94276c82512974 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Mon Nov 23 12:21:24 2009 +0000 + + Add extra picture info fields for VDPAU/MPEG-4. + +diff --git a/src/va.h b/src/va.h +index fa34850..f89a5cb 100755 +--- a/src/va.h ++++ b/src/va.h +@@ -672,6 +672,7 @@ typedef struct _VAPictureParameterBufferMPEG4 + unsigned int quarter_sample : 1; + unsigned int data_partitioned : 1; + unsigned int reversible_vlc : 1; ++ unsigned int resync_marker_disable : 1; + } bits; + unsigned int value; + } vol_fields; +@@ -692,6 +693,7 @@ typedef struct _VAPictureParameterBufferMPEG4 + } vop_fields; + unsigned char vop_fcode_forward; + unsigned char vop_fcode_backward; ++ unsigned short vop_time_increment_resolution; + /* short header related */ + unsigned char num_gobs_in_vop; + unsigned char num_macroblocks_in_gob; diff --git a/meta-emenlow/packages/libva/libva-0.31.0/320_move_vaPutSurface_flags_def.patch b/meta-emenlow/packages/libva/libva-0.31.0/320_move_vaPutSurface_flags_def.patch new file mode 100644 index 0000000000..f00c52ca47 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/320_move_vaPutSurface_flags_def.patch @@ -0,0 +1,60 @@ +commit c682fb5ebd1964638f90590f66edf49629e7481d +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Fri Aug 21 11:34:50 2009 +0000 + + Move vaPutSurface() flags to <va/va.h> header. + +diff --git a/src/va.h b/src/va.h +index 0519f6f..6b4bbd4 100755 +--- a/src/va.h ++++ b/src/va.h +@@ -127,6 +127,22 @@ typedef int VAStatus; /* Return status type from functions */ + #define VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED 0x00000013 + #define VA_STATUS_ERROR_UNKNOWN 0xFFFFFFFF + ++/* De-interlacing flags for vaPutSurface() */ ++#define VA_FRAME_PICTURE 0x00000000 ++#define VA_TOP_FIELD 0x00000001 ++#define VA_BOTTOM_FIELD 0x00000002 ++ ++/* ++ * Clears the drawable with background color. ++ * for hardware overlay based implementation this flag ++ * can be used to turn off the overlay ++ */ ++#define VA_CLEAR_DRAWABLE 0x00000008 ++ ++/* Color space conversion flags for vaPutSurface() */ ++#define VA_SRC_BT601 0x00000010 ++#define VA_SRC_BT709 0x00000020 ++ + /* + * Returns a short english description of error_status + */ +diff --git a/src/x11/va_x11.h b/src/x11/va_x11.h +index 2171ac6..5ab5200 100644 +--- a/src/x11/va_x11.h ++++ b/src/x11/va_x11.h +@@ -27,22 +27,6 @@ VADisplay vaGetDisplay ( + * color space conversion and scaling to the destination + * rectangle + */ +-/* de-interlacing flags for vaPutSurface */ +-#define VA_FRAME_PICTURE 0x00000000 +-#define VA_TOP_FIELD 0x00000001 +-#define VA_BOTTOM_FIELD 0x00000002 +- +-/* +- * clears the drawable with background color. +- * for hardware overlay based implementation this flag +- * can be used to turn off the overlay +- */ +-#define VA_CLEAR_DRAWABLE 0x00000008 +- +-/* color space conversion flags for vaPutSurface */ +-#define VA_SRC_BT601 0x00000010 +-#define VA_SRC_BT709 0x00000020 +- + VAStatus vaPutSurface ( + VADisplay dpy, + VASurfaceID surface, diff --git a/meta-emenlow/packages/libva/libva-0.31.0/321_libva_glx.base.patch b/meta-emenlow/packages/libva/libva-0.31.0/321_libva_glx.base.patch new file mode 100644 index 0000000000..43af6f40cc --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/321_libva_glx.base.patch @@ -0,0 +1,212 @@ +commit f0b352251894becfcec50de1430bda12c314a464 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 22 13:00:34 2009 +0000 + + Fix libva-glx pkgconfig dependencies. + +commit df0953a951d8a2e5e4b0a28a95ae0f1ac735726e +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 8 12:25:14 2009 +0000 + + Add generic VA/GLX implementation with TFP and FBO. + +commit f640b1cf9eab4e5d478239b608ed0d8b68f6c5f6 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 8 12:15:35 2009 +0000 + + Move GLX VTable to a new file. + +commit 70d9cb6d1aa2fc2dde6646f3b692433e0d93d431 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Fri Aug 28 11:15:51 2009 +0000 + + Add OpenGL extensions (v3). + +diff --git a/Makefile.am b/Makefile.am +index 07385e6..6fb4cae 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -32,10 +32,13 @@ endif + + pcfiles = libva.pc + pcfiles += libva-x11.pc ++if USE_GLX ++pcfiles += libva-glx.pc ++endif + + pkgconfigdir = @pkgconfigdir@ + pkgconfig_DATA = $(pcfiles) + +-EXTRA_DIST = libva.pc.in libva-x11.pc.in ++EXTRA_DIST = libva.pc.in libva-x11.pc.in libva-glx.pc.in + + CLEANFILES = $(pcfiles) +diff --git a/configure.ac b/configure.ac +index c3aba90..abef435 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -52,6 +55,11 @@ AC_SUBST(LIBVA_MINOR_VERSION) + AC_SUBST(LIBVA_LT_VERSION) + AC_SUBST(LIBVA_LT_LDFLAGS) + ++AC_ARG_ENABLE(glx, ++ [AC_HELP_STRING([--enable-glx], ++ [build with OpenGL for X11 support])], ++ [], [enable_glx=yes]) ++ + AC_ARG_ENABLE(dummy-driver, + [AC_HELP_STRING([--enable-dummy-driver], + [build dummy video driver])], +@@ -100,6 +132,23 @@ if test x$enable_i965_driver = xyes && ! $PKG_CONFIG --atleast-version=2.4 libdr + AC_DEFINE_UNQUOTED([ATTRIBUTE_HIDDEN], [$ATTRIBUTE_HIDDEN], + [Defined to __attribute__((visibility("hidden"))) when available]) + ++# Check for OpenGL (X11) ++USE_GLX="no" ++GL_DEPS_CFLAGS="" ++GL_DEPS_LIBS="" ++ ++if test x$enable_glx = xyes; then ++ AC_CHECK_HEADERS([GL/gl.h]) ++ AC_CHECK_HEADERS([GL/glx.h]) ++ AC_CHECK_LIB(GL, glXCreateContext, [ ++ USE_GLX="yes" ++ GL_DEPS_LIBS="-lX11 -lGL" ++ ]) ++fi ++AC_SUBST(GL_DEPS_CFLAGS) ++AC_SUBST(GL_DEPS_LIBS) ++AM_CONDITIONAL(USE_GLX, test "$USE_GLX" = "yes") ++ + # We only need the headers, we don't link against the DRM libraries + LIBVA_CFLAGS="$DRM_CFLAGS" + AC_SUBST(LIBVA_CFLAGS) +@@ -119,6 +192,7 @@ AC_OUTPUT([ + src/Makefile + src/va_version.h + src/x11/Makefile ++ src/glx/Makefile + dummy_drv_video/Makefile + i965_drv_video/Makefile + i965_drv_video/shaders/Makefile +@@ -128,5 +202,6 @@ AC_OUTPUT([ + test/Makefile + libva.pc + libva-x11.pc ++ libva-glx.pc + ]) + +diff --git a/libva-glx.pc.in b/libva-glx.pc.in +new file mode 100644 +index 0000000..20ba20a +--- /dev/null ++++ b/libva-glx.pc.in +@@ -0,0 +1,12 @@ ++prefix=@prefix@ ++exec_prefix=@exec_prefix@ ++libdir=@libdir@ ++includedir=@includedir@ ++display=glx ++ ++Name: libva-${display} ++Description: Userspace Video Acceleration (VA) ${display} interface ++Requires: libva ++Version: @PACKAGE_VERSION@ ++Libs: -L${libdir} -lva-${display} ++Cflags: -I${includedir} +diff --git a/src/Makefile.am b/src/Makefile.am +index 2f4210a..e50a15f 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -28,9 +28,17 @@ INCLUDES = \ + LDADD = \ + $(LIBVA_LT_LDFLAGS) + +-lib_LTLIBRARIES = \ +- libva.la \ +- libva-x11.la ++libva_x11_backend = libva-x11.la ++libva_x11_backenddir = x11 ++if USE_GLX ++libva_glx_backend = libva-glx.la ++libva_glx_backenddir = glx ++else ++libva_glx_backend = ++libva_glx_backenddir = ++endif ++ ++lib_LTLIBRARIES = libva.la $(libva_x11_backend) $(libva_glx_backend) + + libva_ladir = $(libdir) + libva_la_LDFLAGS = $(LDADD) -no-undefined +@@ -41,7 +49,14 @@ libva_x11_la_LIBADD = $(libvacorelib) x11/libva_x11.la $(LIBVA_LIBS) $(X11_LIBS + libva_x11_la_LDFLAGS = $(LDADD) + libva_x11_la_DEPENDENCIES = $(libvacorelib) x11/libva_x11.la + +-SUBDIRS = x11 ++libva_glx_la_SOURCES = ++libva_glx_la_LIBADD = $(libvacorelib) glx/libva_glx.la libva-x11.la $(GL_DEPS_LIBS) -ldl ++libva_glx_la_LDFLAGS = $(LDADD) ++libva_glx_la_DEPENDENCIES = $(libvacorelib) glx/libva_glx.la libva-x11.la ++ ++SUBDIRS = $(libva_x11_backenddir) $(libva_glx_backenddir) ++ ++DIST_SUBDIRS = x11 glx + + libva_la_SOURCES = va.c + +diff --git a/src/va_backend.h b/src/va_backend.h +index 6f858f5..8f722a3 100644 +--- a/src/va_backend.h ++++ b/src/va_backend.h +@@ -32,9 +32,11 @@ + #ifdef IN_LIBVA + #include "va.h" + #include "x11/va_x11.h" ++#include "glx/va_backend_glx.h" + #else + #include <va/va.h> + #include <va/va_x11.h> ++#include <va/va_backend_glx.h> + #endif + + #include <stdlib.h> +@@ -372,6 +374,9 @@ struct VADriverVTable + unsigned int *chroma_v_offset, + void **buffer + ); ++ ++ /* Optional: GLX support hooks */ ++ struct VADriverVTableGLX glx; + }; + + struct VADriverContext +@@ -394,6 +399,7 @@ struct VADriverContext + void *handle; /* dlopen handle */ + + void *dri_state; ++ void *glx; /* opaque for GLX code */ + }; + + struct VADisplayContext +@@ -413,6 +420,8 @@ struct VADisplayContext + VADisplayContextP ctx, + char **driver_name + ); ++ ++ void *opaque; /* opaque for display extensions (e.g. GLX) */ + }; + + typedef VAStatus (*VADriverInit) ( +diff --git a/src/x11/va_x11.c b/src/x11/va_x11.c +index 9de904e..b8c60fa 100644 +--- a/src/x11/va_x11.c ++++ b/src/x11/va_x11.c +@@ -243,6 +243,7 @@ VADisplay vaGetDisplay ( + pDisplayContext->vaIsValid = va_DisplayContextIsValid; + pDisplayContext->vaDestroy = va_DisplayContextDestroy; + pDisplayContext->vaGetDriverName = va_DisplayContextGetDriverName; ++ pDisplayContext->opaque = NULL; + pDisplayContexts = pDisplayContext; + pDriverContext->dri_state = dri_state; + dpy = (VADisplay)pDisplayContext; diff --git a/meta-emenlow/packages/libva/libva-0.31.0/322_libva_glx.patch b/meta-emenlow/packages/libva/libva-0.31.0/322_libva_glx.patch new file mode 100644 index 0000000000..ccd9ae090e --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/322_libva_glx.patch @@ -0,0 +1,2024 @@ +commit 8e76000abce070da5f1c902a6290f4ccaa3eccc8 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Fri Sep 18 15:51:08 2009 +0000 + + Add C++ guards. + +commit bf1ae22ef324fbb347f5369e1ba307e847553fe8 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Fri Sep 18 15:49:55 2009 +0000 + + Fix check for GL extensions. + +commit df0953a951d8a2e5e4b0a28a95ae0f1ac735726e +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 8 12:25:14 2009 +0000 + + Add generic VA/GLX implementation with TFP and FBO. + +commit f640b1cf9eab4e5d478239b608ed0d8b68f6c5f6 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Tue Sep 8 12:15:35 2009 +0000 + + Move GLX VTable to a new file. + +commit 70d9cb6d1aa2fc2dde6646f3b692433e0d93d431 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Fri Aug 28 11:15:51 2009 +0000 + + Add OpenGL extensions (v3). + +diff --git a/src/glx/Makefile.am b/src/glx/Makefile.am +new file mode 100644 +index 0000000..7783d8c +--- /dev/null ++++ b/src/glx/Makefile.am +@@ -0,0 +1,41 @@ ++# Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++# ++# Permission is hereby granted, free of charge, to any person obtaining a ++# copy of this software and associated documentation files (the ++# "Software"), to deal in the Software without restriction, including ++# without limitation the rights to use, copy, modify, merge, publish, ++# distribute, sub license, and/or sell copies of the Software, and to ++# permit persons to whom the Software is furnished to do so, subject to ++# the following conditions: ++# ++# The above copyright notice and this permission notice (including the ++# next paragraph) shall be included in all copies or substantial portions ++# of the Software. ++# ++# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++# IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++AM_CFLAGS = -DLINUX -DIN_LIBVA -I$(top_srcdir)/src -I$(top_srcdir)/src/x11 ++ ++source_c = \ ++ va_glx.c \ ++ va_glx_impl.c ++ ++source_h = \ ++ va_glx.h \ ++ va_backend_glx.h ++ ++source_h_priv = \ ++ va_glx_impl.h \ ++ va_glx_private.h ++ ++noinst_LTLIBRARIES = libva_glx.la ++libva_glxincludedir = ${includedir}/va ++libva_glxinclude_HEADERS = $(source_h) ++libva_glx_la_SOURCES = $(source_c) ++noinst_HEADERS = $(source_h_priv) +diff --git a/src/glx/va_backend_glx.h b/src/glx/va_backend_glx.h +new file mode 100644 +index 0000000..3885d30 +--- /dev/null ++++ b/src/glx/va_backend_glx.h +@@ -0,0 +1,87 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#ifndef VA_BACKEND_GLX_H ++#define VA_BACKEND_GLX_H ++ ++struct VADriverContext; ++ ++struct VADriverVTableGLX { ++ /* Optional: create a surface used for display to OpenGL */ ++ VAStatus (*vaCreateSurfaceGLX)( ++ struct VADriverContext *ctx, ++ unsigned int gl_target, ++ unsigned int gl_texture, ++ void **gl_surface ++ ); ++ ++ /* Optional: destroy a VA/GLX surface */ ++ VAStatus (*vaDestroySurfaceGLX)( ++ struct VADriverContext *ctx, ++ void *gl_surface ++ ); ++ ++ /* Optional: associate a VA surface to a VA/GLX surface */ ++ VAStatus (*vaAssociateSurfaceGLX)( ++ struct VADriverContext *ctx, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++ ); ++ ++ /* Optional: deassociate a VA surface from a VA/GLX surface */ ++ VAStatus (*vaDeassociateSurfaceGLX)( ++ struct VADriverContext *ctx, ++ void *gl_surface ++ ); ++ ++ /* Optional: synchronize a VA/GLX surface */ ++ VAStatus (*vaSyncSurfaceGLX)( ++ struct VADriverContext *ctx, ++ void *gl_surface ++ ); ++ ++ /* Optional: prepare VA/GLX surface for rendering */ ++ VAStatus (*vaBeginRenderSurfaceGLX)( ++ struct VADriverContext *ctx, ++ void *gl_surface ++ ); ++ ++ /* Optional: notify the server that the VA/GLX surface is no ++ longer used for rendering */ ++ VAStatus (*vaEndRenderSurfaceGLX)( ++ struct VADriverContext *ctx, ++ void *gl_surface ++ ); ++ ++ /* Optional: copy a VA surface to a VA/GLX surface */ ++ VAStatus (*vaCopySurfaceGLX)( ++ struct VADriverContext *ctx, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++ ); ++}; ++ ++#endif /* VA_BACKEND_GLX_H */ +diff --git a/src/glx/va_glx.c b/src/glx/va_glx.c +new file mode 100644 +index 0000000..f6ec2c3 +--- /dev/null ++++ b/src/glx/va_glx.c +@@ -0,0 +1,295 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#include "va_glx_private.h" ++#include "va_glx_impl.h" ++ ++#define INIT_CONTEXT(ctx, dpy) do { \ ++ if (!vaDisplayIsValid(dpy)) \ ++ return VA_STATUS_ERROR_INVALID_DISPLAY; \ ++ \ ++ ctx = ((VADisplayContextP)(dpy))->pDriverContext; \ ++ if (!(ctx)) \ ++ return VA_STATUS_ERROR_INVALID_DISPLAY; \ ++ \ ++ VAStatus status = va_glx_init_context(ctx); \ ++ if (status != VA_STATUS_SUCCESS) \ ++ return status; \ ++ } while (0) ++ ++#define INIT_SURFACE(surface, surface_arg) do { \ ++ surface = (VASurfaceGLXP)(surface_arg); \ ++ if (!vaSurfaceIsValid(surface)) \ ++ return VA_STATUS_ERROR_INVALID_SURFACE; \ ++ } while (0) ++ ++#define INVOKE(ctx, func, args) do { \ ++ VADriverVTableGLXP vtable; \ ++ vtable = &VA_DRIVER_CONTEXT_GLX(ctx)->vtable; \ ++ if (!vtable->va##func##GLX) \ ++ return VA_STATUS_ERROR_UNIMPLEMENTED; \ ++ status = vtable->va##func##GLX args; \ ++ } while (0) ++ ++// Check VADisplay is valid ++static inline int vaDisplayIsValid(VADisplay dpy) ++{ ++ VADisplayContextP pDisplayContext = (VADisplayContextP)dpy; ++ ++ return (pDisplayContext && ++ pDisplayContext->vaIsValid && ++ pDisplayContext->vaIsValid(pDisplayContext)); ++} ++ ++// Check VASurfaceGLX is valid ++static inline int vaSurfaceIsValid(VASurfaceGLXP pSurfaceGLX) ++{ ++ return pSurfaceGLX && pSurfaceGLX->magic == VA_SURFACE_GLX_MAGIC; ++} ++ ++// Destroy VA/GLX display context ++static void va_DisplayContextDestroy(VADisplayContextP pDisplayContext) ++{ ++ VADisplayContextGLXP pDisplayContextGLX; ++ VADriverContextP pDriverContext; ++ VADriverContextGLXP pDriverContextGLX; ++ ++ if (!pDisplayContext) ++ return; ++ ++ pDriverContext = pDisplayContext->pDriverContext; ++ pDriverContextGLX = pDriverContext->glx; ++ if (pDriverContextGLX) { ++ free(pDriverContextGLX); ++ pDriverContext->glx = NULL; ++ } ++ ++ pDisplayContextGLX = pDisplayContext->opaque; ++ if (pDisplayContextGLX) { ++ if (pDisplayContextGLX->vaDestroy) ++ pDisplayContextGLX->vaDestroy(pDisplayContext); ++ free(pDisplayContextGLX); ++ pDisplayContext->opaque = NULL; ++ } ++} ++ ++// Return a suitable VADisplay for VA API ++VADisplay vaGetDisplayGLX(Display *native_dpy) ++{ ++ VADisplay dpy = NULL; ++ VADisplayContextP pDisplayContext = NULL; ++ VADisplayContextGLXP pDisplayContextGLX = NULL; ++ VADriverContextP pDriverContext; ++ VADriverContextGLXP pDriverContextGLX = NULL; ++ ++ dpy = vaGetDisplay(native_dpy); ++ if (!dpy) ++ return NULL; ++ pDisplayContext = (VADisplayContextP)dpy; ++ pDriverContext = pDisplayContext->pDriverContext; ++ ++ pDisplayContextGLX = calloc(1, sizeof(*pDisplayContextGLX)); ++ if (!pDisplayContextGLX) ++ goto error; ++ ++ pDriverContextGLX = calloc(1, sizeof(*pDriverContextGLX)); ++ if (!pDriverContextGLX) ++ goto error; ++ ++ pDisplayContextGLX->vaDestroy = pDisplayContext->vaDestroy; ++ pDisplayContext->vaDestroy = va_DisplayContextDestroy; ++ pDisplayContext->opaque = pDisplayContextGLX; ++ pDriverContext->glx = pDriverContextGLX; ++ return dpy; ++ ++error: ++ free(pDriverContextGLX); ++ free(pDisplayContextGLX); ++ pDisplayContext->vaDestroy(pDisplayContext); ++ return NULL; ++} ++ ++// Create a surface used for display to OpenGL ++VAStatus vaCreateSurfaceGLX( ++ VADisplay dpy, ++ GLenum target, ++ GLuint texture, ++ void **gl_surface ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ /* Make sure it is a valid GL texture object */ ++ if (!glIsTexture(texture)) ++ return VA_STATUS_ERROR_INVALID_PARAMETER; ++ ++ INIT_CONTEXT(ctx, dpy); ++ ++ pSurfaceGLX = va_glx_create_surface(ctx, target, texture); ++ if (!pSurfaceGLX) ++ return VA_STATUS_ERROR_ALLOCATION_FAILED; ++ ++ INVOKE(ctx, CreateSurface, (ctx, target, texture, &pSurfaceGLX->priv)); ++ ++ if (status != VA_STATUS_SUCCESS) ++ va_glx_destroy_surface(ctx, &pSurfaceGLX); ++ ++ *gl_surface = pSurfaceGLX; ++ return status; ++} ++ ++// Destroy a VA/GLX surface ++VAStatus vaDestroySurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ INIT_CONTEXT(ctx, dpy); ++ INIT_SURFACE(pSurfaceGLX, gl_surface); ++ ++ INVOKE(ctx, DestroySurface, (ctx, pSurfaceGLX)); ++ ++ free(pSurfaceGLX); ++ return status; ++} ++ ++// Associate a VA surface to a VA/GLX surface ++VAStatus vaAssociateSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ INIT_CONTEXT(ctx, dpy); ++ INIT_SURFACE(pSurfaceGLX, gl_surface); ++ ++ INVOKE(ctx, AssociateSurface, (ctx, pSurfaceGLX, surface, flags)); ++ ++ if (status == VA_STATUS_SUCCESS) ++ pSurfaceGLX->surface = surface; ++ ++ return status; ++} ++ ++// Deassociate a VA surface from a VA/GLX surface ++VAStatus vaDeassociateSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ INIT_CONTEXT(ctx, dpy); ++ INIT_SURFACE(pSurfaceGLX, gl_surface); ++ ++ INVOKE(ctx, DeassociateSurface, (ctx, pSurfaceGLX)); ++ ++ if (status == VA_STATUS_SUCCESS) ++ pSurfaceGLX->surface = VA_INVALID_SURFACE; ++ ++ return status; ++} ++ ++// Synchronize a VA/GLX surface ++VAStatus vaSyncSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ INIT_CONTEXT(ctx, dpy); ++ INIT_SURFACE(pSurfaceGLX, gl_surface); ++ ++ INVOKE(ctx, SyncSurface, (ctx, pSurfaceGLX)); ++ return status; ++} ++ ++// Prepare VA/GLX surface for rendering ++VAStatus vaBeginRenderSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ INIT_CONTEXT(ctx, dpy); ++ INIT_SURFACE(pSurfaceGLX, gl_surface); ++ ++ INVOKE(ctx, BeginRenderSurface, (ctx, pSurfaceGLX)); ++ return status; ++} ++ ++// Notify the server that the VA/GLX surface is no longer used for rendering ++VAStatus vaEndRenderSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ INIT_CONTEXT(ctx, dpy); ++ INIT_SURFACE(pSurfaceGLX, gl_surface); ++ ++ INVOKE(ctx, EndRenderSurface, (ctx, pSurfaceGLX)); ++ return status; ++} ++ ++// Copy a VA surface to a VA/GLX surface ++VAStatus vaCopySurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++) ++{ ++ VADriverContextP ctx; ++ VASurfaceGLXP pSurfaceGLX; ++ VAStatus status; ++ ++ INIT_CONTEXT(ctx, dpy); ++ INIT_SURFACE(pSurfaceGLX, gl_surface); ++ ++ INVOKE(ctx, CopySurface, (ctx, pSurfaceGLX, surface, flags)); ++ return status; ++} +diff --git a/src/glx/va_glx.h b/src/glx/va_glx.h +new file mode 100644 +index 0000000..183ef3a +--- /dev/null ++++ b/src/glx/va_glx.h +@@ -0,0 +1,217 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#ifndef VA_GLX_H ++#define VA_GLX_H ++ ++#ifdef IN_LIBVA ++#include "va.h" ++#else ++#include <va/va.h> ++#endif ++#include <GL/glx.h> ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/** ++ * Return a suitable VADisplay for VA API ++ * ++ * @param[in] dpy the X11 display ++ * @return a VADisplay ++ */ ++VADisplay vaGetDisplayGLX( ++ Display *dpy ++); ++ ++/** ++ * Create a surface used for display to OpenGL ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] target the GL target to which the texture needs to be bound ++ * @param[in] texture the GL texture ++ * @param[out] gl_surface the VA/GLX surface ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaCreateSurfaceGLX( ++ VADisplay dpy, ++ GLenum target, ++ GLuint texture, ++ void **gl_surface ++); ++ ++/** ++ * Destroy a VA/GLX surface ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] gl_surface the VA surface ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaDestroySurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++); ++ ++/** ++ * Associate a VA surface to a VA/GLX surface ++ * ++ * The association is live until vaDeassociateSurfaceGLX(), ++ * vaCopySurfaceGLX() or the next call to vaBeginPicture() with the ++ * specificed VA surface. ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] gl_surface the VA/GLX surface ++ * @param[in] surface the VA surface ++ * @param[in] flags the PutSurface flags ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaAssociateSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++); ++ ++/** ++ * Deassociate a VA surface from a VA/GLX surface ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] gl_surface the VA surface ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaDeassociateSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++); ++ ++/** ++ * Synchronize a VA/GLX surface ++ * ++ * This function blocks until all pending operations on the VA/GLX ++ * surface have been completed. ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] gl_surface the VA surface ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaSyncSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++); ++ ++/** ++ * Prepare VA/GLX surface for rendering ++ * ++ * This function performs an implicit vaSyncSurfaceGLX(). ++ * ++ * Implementations using the GLX texture-from-pixmap extension will ++ * generally call glXBindTexImage() here. ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] gl_surface the VA surface ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaBeginRenderSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++); ++ ++/** ++ * Notify the server that the VA/GLX surface is no longer used for ++ * rendering ++ * ++ * Implementations using the GLX texture-from-pixmap extension will ++ * generally call glXReleaseTexImage() here. ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] gl_surface the VA surface ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaEndRenderSurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface ++); ++ ++/** ++ * Copy a VA surface to a VA/GLX surface ++ * ++ * This function kills any association that was previously made with ++ * vaAssociateSurfaceGLX() and will not return until the copy is ++ * completed. ++ * ++ * Upon successful return, the underlying GL texture will contain the ++ * complete pixels and no call to vaBeginRenderSurfaceGLX() or ++ * vaEndRenderSurfaceGLX() is required. ++ * ++ * The application shall maintain the live GLX context itself. ++ * Implementations are free to use glXGetCurrentContext() and ++ * glXGetCurrentDrawable() functions for internal purposes. ++ * ++ * @param[in] dpy the VA display ++ * @param[in] gl_surface the VA/GLX destination surface ++ * @param[in] surface the VA source surface ++ * @param[in] flags the PutSurface flags ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus vaCopySurfaceGLX( ++ VADisplay dpy, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* VA_GLX_H */ +diff --git a/src/glx/va_glx_impl.c b/src/glx/va_glx_impl.c +new file mode 100644 +index 0000000..d4f9c1d +--- /dev/null ++++ b/src/glx/va_glx_impl.c +@@ -0,0 +1,1168 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#define _GNU_SOURCE 1 ++#include "va_glx_private.h" ++#include "va_glx_impl.h" ++#include <stdio.h> ++#include <stdarg.h> ++#include <string.h> ++#include <assert.h> ++#include <dlfcn.h> ++ ++static void va_glx_error_message(const char *format, ...) ++{ ++ va_list args; ++ va_start(args, format); ++ fprintf(stderr, "[%s] ", PACKAGE_NAME); ++ vfprintf(stderr, format, args); ++ va_end(args); ++} ++ ++// X error trap ++static int x11_error_code = 0; ++static int (*old_error_handler)(Display *, XErrorEvent *); ++ ++static int error_handler(Display *dpy, XErrorEvent *error) ++{ ++ x11_error_code = error->error_code; ++ return 0; ++} ++ ++static void x11_trap_errors(void) ++{ ++ x11_error_code = 0; ++ old_error_handler = XSetErrorHandler(error_handler); ++} ++ ++static int x11_untrap_errors(void) ++{ ++ XSetErrorHandler(old_error_handler); ++ return x11_error_code; ++} ++ ++// Returns a string representation of an OpenGL error ++static const char *gl_get_error_string(GLenum error) ++{ ++ static const struct { ++ GLenum val; ++ const char *str; ++ } ++ gl_errors[] = { ++ { GL_NO_ERROR, "no error" }, ++ { GL_INVALID_ENUM, "invalid enumerant" }, ++ { GL_INVALID_VALUE, "invalid value" }, ++ { GL_INVALID_OPERATION, "invalid operation" }, ++ { GL_STACK_OVERFLOW, "stack overflow" }, ++ { GL_STACK_UNDERFLOW, "stack underflow" }, ++ { GL_OUT_OF_MEMORY, "out of memory" }, ++#ifdef GL_INVALID_FRAMEBUFFER_OPERATION_EXT ++ { GL_INVALID_FRAMEBUFFER_OPERATION_EXT, "invalid framebuffer operation" }, ++#endif ++ { ~0, NULL } ++ }; ++ ++ int i; ++ for (i = 0; gl_errors[i].str; i++) { ++ if (gl_errors[i].val == error) ++ return gl_errors[i].str; ++ } ++ return "unknown"; ++} ++ ++static inline int gl_do_check_error(int report) ++{ ++ GLenum error; ++ int is_error = 0; ++ while ((error = glGetError()) != GL_NO_ERROR) { ++ if (report) ++ va_glx_error_message("glError: %s caught\n", ++ gl_get_error_string(error)); ++ is_error = 1; ++ } ++ return is_error; ++} ++ ++static inline void gl_purge_errors(void) ++{ ++ gl_do_check_error(0); ++} ++ ++static inline int gl_check_error(void) ++{ ++ return gl_do_check_error(1); ++} ++ ++// glGetFloatv() wrapper ++static int gl_get_current_color(float color[4]) ++{ ++ gl_purge_errors(); ++ glGetFloatv(GL_CURRENT_COLOR, color); ++ if (gl_check_error()) ++ return -1; ++ return 0; ++} ++ ++// glGetIntegerv() wrapper ++static int gl_get_param(GLenum param, unsigned int *pval) ++{ ++ GLint val; ++ ++ gl_purge_errors(); ++ glGetIntegerv(param, &val); ++ if (gl_check_error()) ++ return -1; ++ if (pval) ++ *pval = val; ++ return 0; ++} ++ ++// glGetTexLevelParameteriv() wrapper ++static int gl_get_texture_param(GLenum param, unsigned int *pval) ++{ ++ GLint val; ++ ++ gl_purge_errors(); ++ glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, param, &val); ++ if (gl_check_error()) ++ return -1; ++ if (pval) ++ *pval = val; ++ return 0; ++} ++ ++// Returns the OpenGL VTable ++static inline VAOpenGLVTableP gl_get_vtable(VADriverContextP ctx) ++{ ++ return &VA_DRIVER_CONTEXT_GLX(ctx)->gl_vtable; ++} ++ ++// Lookup for a GLX function ++typedef void (*GLFuncPtr)(void); ++typedef GLFuncPtr (*GLXGetProcAddressProc)(const char *); ++ ++static GLFuncPtr get_proc_address_default(const char *name) ++{ ++ return NULL; ++} ++ ++static GLXGetProcAddressProc get_proc_address_func(void) ++{ ++ GLXGetProcAddressProc get_proc_func; ++ ++ dlerror(); ++ get_proc_func = (GLXGetProcAddressProc) ++ dlsym(RTLD_DEFAULT, "glXGetProcAddress"); ++ if (dlerror() == NULL) ++ return get_proc_func; ++ ++ get_proc_func = (GLXGetProcAddressProc) ++ dlsym(RTLD_DEFAULT, "glXGetProcAddressARB"); ++ if (dlerror() == NULL) ++ return get_proc_func; ++ ++ return get_proc_address_default; ++} ++ ++static inline GLFuncPtr get_proc_address(const char *name) ++{ ++ static GLXGetProcAddressProc get_proc_func = NULL; ++ if (get_proc_func == NULL) ++ get_proc_func = get_proc_address_func(); ++ return get_proc_func(name); ++} ++ ++// Check for GLX extensions (TFP, FBO) ++static int check_extension(const char *name, const char *ext) ++{ ++ const char *end; ++ int name_len, n; ++ ++ if (name == NULL || ext == NULL) ++ return 0; ++ ++ end = ext + strlen(ext); ++ name_len = strlen(name); ++ while (ext < end) { ++ n = strcspn(ext, " "); ++ if (n == name_len && strncmp(name, ext, n) == 0) ++ return 1; ++ ext += (n + 1); ++ } ++ return 0; ++} ++ ++static int check_tfp_extensions(VADriverContextP ctx) ++{ ++ const char *gl_extensions; ++ const char *glx_extensions; ++ ++ gl_extensions = (const char *)glGetString(GL_EXTENSIONS); ++ if (!check_extension("GL_ARB_texture_non_power_of_two", gl_extensions)) ++ return 0; ++ ++ glx_extensions = glXQueryExtensionsString(ctx->x11_dpy, ctx->x11_screen); ++ if (!check_extension("GLX_EXT_texture_from_pixmap", glx_extensions)) ++ return 0; ++ return 1; ++} ++ ++static int check_fbo_extensions(VADriverContextP ctx) ++{ ++ const char *gl_extensions; ++ ++ gl_extensions = (const char *)glGetString(GL_EXTENSIONS); ++ if (!check_extension("GL_ARB_framebuffer_object", gl_extensions)) ++ return 0; ++ if (!check_extension("GL_EXT_framebuffer_object", gl_extensions)) ++ return 0; ++ return 1; ++} ++ ++// Load GLX extensions ++static int load_tfp_extensions(VADriverContextP ctx) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ ++ pOpenGLVTable->glx_bind_tex_image = (PFNGLXBINDTEXIMAGEEXTPROC) ++ get_proc_address("glXBindTexImageEXT"); ++ if (pOpenGLVTable->glx_bind_tex_image == NULL) ++ return 0; ++ pOpenGLVTable->glx_release_tex_image = (PFNGLXRELEASETEXIMAGEEXTPROC) ++ get_proc_address("glXReleaseTexImageEXT"); ++ if (pOpenGLVTable->glx_release_tex_image == NULL) ++ return 0; ++ return 1; ++} ++ ++static int load_fbo_extensions(VADriverContextP ctx) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ ++ pOpenGLVTable->gl_gen_framebuffers = (PFNGLGENFRAMEBUFFERSEXTPROC) ++ get_proc_address("glGenFramebuffersEXT"); ++ if (pOpenGLVTable->gl_gen_framebuffers == NULL) ++ return 0; ++ pOpenGLVTable->gl_delete_framebuffers = (PFNGLDELETEFRAMEBUFFERSEXTPROC) ++ get_proc_address("glDeleteFramebuffersEXT"); ++ if (pOpenGLVTable->gl_delete_framebuffers == NULL) ++ return 0; ++ pOpenGLVTable->gl_bind_framebuffer = (PFNGLBINDFRAMEBUFFEREXTPROC) ++ get_proc_address("glBindFramebufferEXT"); ++ if (pOpenGLVTable->gl_bind_framebuffer == NULL) ++ return 0; ++ pOpenGLVTable->gl_gen_renderbuffers = (PFNGLGENRENDERBUFFERSEXTPROC) ++ get_proc_address("glGenRenderbuffersEXT"); ++ if (pOpenGLVTable->gl_gen_renderbuffers == NULL) ++ return 0; ++ pOpenGLVTable->gl_delete_renderbuffers = (PFNGLDELETERENDERBUFFERSEXTPROC) ++ get_proc_address("glDeleteRenderbuffersEXT"); ++ if (pOpenGLVTable->gl_delete_renderbuffers == NULL) ++ return 0; ++ pOpenGLVTable->gl_bind_renderbuffer = (PFNGLBINDRENDERBUFFEREXTPROC) ++ get_proc_address("glBindRenderbufferEXT"); ++ if (pOpenGLVTable->gl_bind_renderbuffer == NULL) ++ return 0; ++ pOpenGLVTable->gl_renderbuffer_storage = (PFNGLRENDERBUFFERSTORAGEEXTPROC) ++ get_proc_address("glRenderbufferStorageEXT"); ++ if (pOpenGLVTable->gl_renderbuffer_storage == NULL) ++ return 0; ++ pOpenGLVTable->gl_framebuffer_renderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) ++ get_proc_address("glFramebufferRenderbufferEXT"); ++ if (pOpenGLVTable->gl_framebuffer_renderbuffer == NULL) ++ return 0; ++ pOpenGLVTable->gl_framebuffer_texture_2d = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) ++ get_proc_address("glFramebufferTexture2DEXT"); ++ if (pOpenGLVTable->gl_framebuffer_texture_2d == NULL) ++ return 0; ++ pOpenGLVTable->gl_check_framebuffer_status = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) ++ get_proc_address("glCheckFramebufferStatusEXT"); ++ if (pOpenGLVTable->gl_check_framebuffer_status == NULL) ++ return 0; ++ return 1; ++} ++ ++ ++/* ========================================================================= */ ++/* === VA/GLX helpers === */ ++/* ========================================================================= */ ++ ++// OpenGL texture state ++typedef struct OpenGLTextureState *OpenGLTextureStateP; ++ ++struct OpenGLTextureState { ++ int was_enabled; ++ int was_bound; ++ GLenum target; ++ GLuint old_texture; ++}; ++ ++// Bind texture, preserve previous texture state ++static int bind_texture(OpenGLTextureStateP ts, GLenum target, GLuint texture) ++{ ++ ts->target = target; ++ ts->old_texture = 0; ++ ts->was_bound = 0; ++ ts->was_enabled = glIsEnabled(target); ++ if (!ts->was_enabled) ++ glEnable(target); ++ ++ GLenum texture_binding; ++ switch (target) { ++ case GL_TEXTURE_1D: ++ texture_binding = GL_TEXTURE_BINDING_1D; ++ break; ++ case GL_TEXTURE_2D: ++ texture_binding = GL_TEXTURE_BINDING_2D; ++ break; ++ case GL_TEXTURE_3D: ++ texture_binding = GL_TEXTURE_BINDING_3D; ++ break; ++ case GL_TEXTURE_RECTANGLE_ARB: ++ texture_binding = GL_TEXTURE_BINDING_RECTANGLE_ARB; ++ break; ++ default: ++ assert(!target); ++ return -1; ++ } ++ ++ if (ts->was_enabled && gl_get_param(texture_binding, &ts->old_texture) < 0) ++ return -1; ++ ++ ts->was_bound = texture == ts->old_texture; ++ if (!ts->was_bound) { ++ gl_purge_errors(); ++ glBindTexture(target, texture); ++ if (gl_check_error()) ++ return -1; ++ } ++ return 0; ++} ++ ++// Unbind texture, restore previous texture state ++static void unbind_texture(OpenGLTextureStateP ts) ++{ ++ if (!ts->was_bound && ts->old_texture) ++ glBindTexture(ts->target, ts->old_texture); ++ if (!ts->was_enabled) ++ glDisable(ts->target); ++} ++ ++// Create Pixmaps for GLX texture-from-pixmap extension ++static int create_tfp_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ const unsigned int width = pSurfaceGLX->width; ++ const unsigned int height = pSurfaceGLX->height; ++ Pixmap pixmap = None; ++ GLXFBConfig *fbconfig = NULL; ++ GLXPixmap glx_pixmap = None; ++ Window root_window; ++ XWindowAttributes wattr; ++ int *attrib; ++ int n_fbconfig_attribs, x, y, status; ++ unsigned int border_width, depth, dummy; ++ ++ root_window = RootWindow(ctx->x11_dpy, ctx->x11_screen); ++ XGetWindowAttributes(ctx->x11_dpy, root_window, &wattr); ++ pixmap = XCreatePixmap(ctx->x11_dpy, root_window, ++ width, height, wattr.depth); ++ if (!pixmap) ++ return -1; ++ pSurfaceGLX->pixmap = pixmap; ++ ++ x11_trap_errors(); ++ status = XGetGeometry(ctx->x11_dpy, ++ (Drawable)pixmap, ++ &root_window, ++ &x, ++ &y, ++ &dummy, ++ &dummy, ++ &border_width, ++ &depth); ++ if (x11_untrap_errors() != 0 || status == 0) ++ return -1; ++ if (depth != 24 && depth != 32) ++ return -1; ++ ++ int fbconfig_attribs[32] = { ++ GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT, ++ GLX_DOUBLEBUFFER, GL_TRUE, ++ GLX_RENDER_TYPE, GLX_RGBA_BIT, ++ GLX_X_RENDERABLE, GL_TRUE, ++ GLX_Y_INVERTED_EXT, GL_TRUE, ++ GLX_RED_SIZE, 8, ++ GLX_GREEN_SIZE, 8, ++ GLX_BLUE_SIZE, 8, ++ GL_NONE, ++ }; ++ for (attrib = fbconfig_attribs; *attrib != GL_NONE; attrib += 2) ++ ; ++ *attrib++ = GLX_DEPTH_SIZE; *attrib++ = depth; ++ if (depth == 32) { ++ *attrib++ = GLX_ALPHA_SIZE; *attrib++ = 8; ++ *attrib++ = GLX_BIND_TO_TEXTURE_RGBA_EXT; *attrib++ = GL_TRUE; ++ } ++ else { ++ *attrib++ = GLX_BIND_TO_TEXTURE_RGB_EXT; *attrib++ = GL_TRUE; ++ } ++ *attrib++ = GL_NONE; ++ ++ fbconfig = glXChooseFBConfig(ctx->x11_dpy, ctx->x11_screen, fbconfig_attribs, &n_fbconfig_attribs); ++ if (fbconfig == NULL) ++ return -1; ++ ++ int pixmap_attribs[10] = { ++ GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT, ++ GLX_MIPMAP_TEXTURE_EXT, GL_FALSE, ++ GL_NONE, ++ }; ++ for (attrib = pixmap_attribs; *attrib != GL_NONE; attrib += 2) ++ ; ++ *attrib++ = GLX_TEXTURE_FORMAT_EXT; ++ if (depth == 32) ++ *attrib++ = GLX_TEXTURE_FORMAT_RGBA_EXT; ++ else ++ *attrib++ = GLX_TEXTURE_FORMAT_RGB_EXT; ++ *attrib++ = GL_NONE; ++ ++ x11_trap_errors(); ++ glx_pixmap = glXCreatePixmap(ctx->x11_dpy, ++ fbconfig[0], ++ pixmap, ++ pixmap_attribs); ++ free(fbconfig); ++ if (x11_untrap_errors() != 0) ++ return -1; ++ pSurfaceGLX->glx_pixmap = glx_pixmap; ++ return 0; ++} ++ ++// Destroy Pixmaps used for TFP ++static void destroy_tfp_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ if (pSurfaceGLX->glx_pixmap) { ++ glXDestroyPixmap(ctx->x11_dpy, pSurfaceGLX->glx_pixmap); ++ pSurfaceGLX->glx_pixmap = None; ++ } ++ ++ if (pSurfaceGLX->pixmap) { ++ XFreePixmap(ctx->x11_dpy, pSurfaceGLX->pixmap); ++ pSurfaceGLX->pixmap = None; ++ } ++} ++ ++// Bind GLX Pixmap to texture ++static int bind_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ ++ if (pSurfaceGLX->is_bound) ++ return 0; ++ ++ x11_trap_errors(); ++ pOpenGLVTable->glx_bind_tex_image(ctx->x11_dpy, pSurfaceGLX->glx_pixmap, ++ GLX_FRONT_LEFT_EXT, NULL); ++ XSync(ctx->x11_dpy, False); ++ if (x11_untrap_errors() != 0) { ++ va_glx_error_message("failed to bind pixmap\n"); ++ return -1; ++ } ++ ++ pSurfaceGLX->is_bound = 1; ++ return 0; ++} ++ ++// Release GLX Pixmap from texture ++static int unbind_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ ++ if (!pSurfaceGLX->is_bound) ++ return 0; ++ ++ x11_trap_errors(); ++ pOpenGLVTable->glx_release_tex_image(ctx->x11_dpy, pSurfaceGLX->glx_pixmap, ++ GLX_FRONT_LEFT_EXT); ++ XSync(ctx->x11_dpy, False); ++ if (x11_untrap_errors() != 0) { ++ va_glx_error_message("failed to release pixmap\n"); ++ return -1; ++ } ++ ++ pSurfaceGLX->is_bound = 0; ++ return 0; ++} ++ ++// Render GLX Pixmap to texture ++static void render_pixmap(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ const unsigned int w = pSurfaceGLX->width; ++ const unsigned int h = pSurfaceGLX->height; ++ float old_color[4]; ++ ++ gl_get_current_color(old_color); ++ glColor4f(1.0f, 1.0f, 1.0f, 1.0f); ++ glBegin(GL_QUADS); ++ { ++ glTexCoord2f(0.0f, 0.0f); glVertex2i(0, 0); ++ glTexCoord2f(0.0f, 1.0f); glVertex2i(0, h); ++ glTexCoord2f(1.0f, 1.0f); glVertex2i(w, h); ++ glTexCoord2f(1.0f, 0.0f); glVertex2i(w, 0); ++ } ++ glEnd(); ++ glColor4fv(old_color); ++} ++ ++// Create offscreen surface ++static int create_fbo_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ const GLenum texture = pSurfaceGLX->texture; ++ const unsigned int texture_width = pSurfaceGLX->width; ++ const unsigned int texture_height = pSurfaceGLX->height; ++ GLuint fbo, fbo_buffer, fbo_texture; ++ GLenum status; ++ ++ glGenTextures(1, &fbo_texture); ++ glBindTexture(GL_TEXTURE_2D, fbo_texture); ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); ++ glPixelStorei(GL_UNPACK_ALIGNMENT, 4); ++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture_width, texture_height, 0, ++ GL_BGRA, GL_UNSIGNED_BYTE, NULL); ++ ++ pOpenGLVTable->gl_gen_framebuffers(1, &fbo); ++ pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, fbo); ++ pOpenGLVTable->gl_gen_renderbuffers(1, &fbo_buffer); ++ pOpenGLVTable->gl_bind_renderbuffer(GL_RENDERBUFFER_EXT, fbo_buffer); ++ ++ glBindTexture(GL_TEXTURE_2D, texture); ++ pOpenGLVTable->gl_framebuffer_texture_2d(GL_FRAMEBUFFER_EXT, ++ GL_COLOR_ATTACHMENT0_EXT, ++ GL_TEXTURE_2D, texture, 0); ++ ++ status = pOpenGLVTable->gl_check_framebuffer_status(GL_DRAW_FRAMEBUFFER_EXT); ++ pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, 0); ++ if (status != GL_FRAMEBUFFER_COMPLETE_EXT) ++ return -1; ++ ++ pSurfaceGLX->fbo = fbo; ++ pSurfaceGLX->fbo_buffer = fbo_buffer; ++ pSurfaceGLX->fbo_texture = fbo_texture; ++ return 0; ++} ++ ++// Destroy offscreen surface ++static void destroy_fbo_surface(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ ++ if (pSurfaceGLX->fbo_texture) { ++ glDeleteTextures(1, &pSurfaceGLX->fbo_texture); ++ pSurfaceGLX->fbo_texture = 0; ++ } ++ ++ if (pSurfaceGLX->fbo_buffer) { ++ pOpenGLVTable->gl_delete_renderbuffers(1, &pSurfaceGLX->fbo_buffer); ++ pSurfaceGLX->fbo_buffer = 0; ++ } ++ ++ if (pSurfaceGLX->fbo) { ++ pOpenGLVTable->gl_delete_framebuffers(1, &pSurfaceGLX->fbo); ++ pSurfaceGLX->fbo = 0; ++ } ++} ++ ++// Setup matrices to match the FBO texture dimensions ++static void fbo_enter(VADriverContextP ctx, VASurfaceGLXP pSurfaceGLX) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ const unsigned int width = pSurfaceGLX->width; ++ const unsigned int height = pSurfaceGLX->height; ++ ++ pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, pSurfaceGLX->fbo); ++ glPushAttrib(GL_VIEWPORT_BIT); ++ glMatrixMode(GL_PROJECTION); ++ glPushMatrix(); ++ glLoadIdentity(); ++ glMatrixMode(GL_MODELVIEW); ++ glPushMatrix(); ++ glLoadIdentity(); ++ glViewport(0, 0, width, height); ++ glTranslatef(-1.0f, -1.0f, 0.0f); ++ glScalef(2.0f / width, 2.0f / height, 1.0f); ++ ++ glBindTexture(GL_TEXTURE_2D, pSurfaceGLX->fbo_texture); ++} ++ ++// Restore original OpenGL matrices ++static void fbo_leave(VADriverContextP ctx) ++{ ++ VAOpenGLVTableP pOpenGLVTable = gl_get_vtable(ctx); ++ ++ glPopAttrib(); ++ glMatrixMode(GL_PROJECTION); ++ glPopMatrix(); ++ glMatrixMode(GL_MODELVIEW); ++ glPopMatrix(); ++ pOpenGLVTable->gl_bind_framebuffer(GL_FRAMEBUFFER_EXT, 0); ++} ++ ++// Create VA/GLX surface ++VASurfaceGLXP ++va_glx_create_surface(VADriverContextP ctx, GLenum target, GLuint texture) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VASurfaceGLXP pSurfaceGLX; ++ unsigned int internal_format, border_width, width, height; ++ int is_error = 1; ++ ++ /* Make sure binding succeeds, if texture was not already bound */ ++ struct OpenGLTextureState ts; ++ if (bind_texture(&ts, target, texture) < 0) ++ goto end; ++ ++ pSurfaceGLX = malloc(sizeof(*pSurfaceGLX)); ++ if (!pSurfaceGLX) ++ goto end; ++ ++ pSurfaceGLX->magic = VA_SURFACE_GLX_MAGIC; ++ pSurfaceGLX->target = target; ++ pSurfaceGLX->texture = texture; ++ pSurfaceGLX->surface = VA_INVALID_SURFACE; ++ pSurfaceGLX->is_bound = 0; ++ pSurfaceGLX->pixmap = None; ++ pSurfaceGLX->glx_pixmap = None; ++ pSurfaceGLX->fbo = 0; ++ pSurfaceGLX->fbo_buffer = 0; ++ pSurfaceGLX->fbo_texture = 0; ++ pSurfaceGLX->priv = NULL; ++ ++ /* XXX: we don't support other textures than RGBA */ ++ if (gl_get_texture_param(GL_TEXTURE_INTERNAL_FORMAT, &internal_format) < 0) ++ goto end; ++ if (internal_format != GL_RGBA) ++ goto end; ++ ++ /* Check texture dimensions */ ++ if (gl_get_texture_param(GL_TEXTURE_BORDER, &border_width) < 0) ++ goto end; ++ if (gl_get_texture_param(GL_TEXTURE_WIDTH, &width) < 0) ++ goto end; ++ if (gl_get_texture_param(GL_TEXTURE_HEIGHT, &height) < 0) ++ goto end; ++ ++ width -= 2 * border_width; ++ height -= 2 * border_width; ++ if (width == 0 || height == 0) ++ goto end; ++ ++ pSurfaceGLX->width = width; ++ pSurfaceGLX->height = height; ++ ++ /* Create Pixmaps for TFP */ ++ if (pDriverContextGLX->use_tfp) { ++ if (create_tfp_surface(ctx, pSurfaceGLX) < 0) ++ goto end; ++ } ++ ++ /* Create Pixmaps for FBO */ ++ if (pDriverContextGLX->use_fbo) { ++ if (create_fbo_surface(ctx, pSurfaceGLX) < 0) ++ goto end; ++ } ++ ++ is_error = 0; ++end: ++ if (is_error && pSurfaceGLX) ++ va_glx_destroy_surface(ctx, &pSurfaceGLX); ++ ++ unbind_texture(&ts); ++ return pSurfaceGLX; ++} ++ ++// Destroy VA/GLX surface ++void va_glx_destroy_surface(VADriverContextP ctx, VASurfaceGLXP *ppSurfaceGLX) ++{ ++ VASurfaceGLXP pSurfaceGLX = *ppSurfaceGLX; ++ ++ unbind_pixmap(ctx, pSurfaceGLX); ++ destroy_fbo_surface(ctx, pSurfaceGLX); ++ destroy_tfp_surface(ctx, pSurfaceGLX); ++ ++ free(pSurfaceGLX); ++ *ppSurfaceGLX = NULL; ++} ++ ++ ++/* ========================================================================= */ ++/* === VA/GLX implementation from the driver (fordward calls) === */ ++/* ========================================================================= */ ++ ++#define INVOKE(ctx, func, args) do { \ ++ VADriverVTableGLXP vtable = &(ctx)->vtable.glx; \ ++ if (!vtable->va##func##GLX) \ ++ return VA_STATUS_ERROR_UNIMPLEMENTED; \ ++ \ ++ VAStatus status = vtable->va##func##GLX args; \ ++ if (status != VA_STATUS_SUCCESS) \ ++ return status; \ ++ } while (0) ++ ++static VAStatus ++vaCreateSurfaceGLX_impl_driver( ++ VADriverContextP ctx, ++ GLenum target, ++ GLuint texture, ++ void **gl_surface ++) ++{ ++ INVOKE(ctx, CreateSurface, (ctx, target, texture, gl_surface)); ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaDestroySurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface) ++{ ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ INVOKE(ctx, DestroySurface, (ctx, pSurfaceGLX->priv)); ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaAssociateSurfaceGLX_impl_driver( ++ VADriverContextP ctx, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++) ++{ ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ INVOKE(ctx, AssociateSurface, (ctx, pSurfaceGLX->priv, surface, flags)); ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaDeassociateSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface) ++{ ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ INVOKE(ctx, DeassociateSurface, (ctx, pSurfaceGLX->priv)); ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaSyncSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface) ++{ ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ INVOKE(ctx, SyncSurface, (ctx, pSurfaceGLX->priv)); ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaBeginRenderSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface) ++{ ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ INVOKE(ctx, BeginRenderSurface, (ctx, pSurfaceGLX->priv)); ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaEndRenderSurfaceGLX_impl_driver(VADriverContextP ctx, void *gl_surface) ++{ ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ INVOKE(ctx, EndRenderSurface, (ctx, pSurfaceGLX->priv)); ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaCopySurfaceGLX_impl_driver( ++ VADriverContextP ctx, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++) ++{ ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ INVOKE(ctx, CopySurface, (ctx, pSurfaceGLX->priv, surface, flags)); ++ return VA_STATUS_SUCCESS; ++} ++ ++#undef INVOKE ++ ++ ++/* ========================================================================= */ ++/* === VA/GLX implementation from libVA (generic and suboptimal path) === */ ++/* ========================================================================= */ ++ ++static VAStatus ++vaCreateSurfaceGLX_impl_libva( ++ VADriverContextP ctx, ++ GLenum target, ++ GLuint texture, ++ void **gl_surface ++) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ ++ if (!pDriverContextGLX->use_tfp) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ *gl_surface = NULL; ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaDestroySurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ ++ if (!pDriverContextGLX->use_tfp) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaAssociateSurfaceGLX_impl_libva( ++ VADriverContextP ctx, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VADriverVTableGLXP vtable = &pDriverContextGLX->vtable; ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ VAStatus status; ++ ++ if (!pDriverContextGLX->use_tfp) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ /* XXX: only support VA_FRAME_PICTURE */ ++ if (flags != VA_FRAME_PICTURE) ++ return VA_STATUS_ERROR_FLAG_NOT_SUPPORTED; ++ ++ /* XXX: optimise case where we are associating the same VA surface ++ as before an no changed occurred to it */ ++ status = vtable->vaDeassociateSurfaceGLX(ctx, gl_surface); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ x11_trap_errors(); ++ status = ctx->vtable.vaPutSurface(ctx, ++ surface, ++ pSurfaceGLX->pixmap, ++ 0, 0, ++ pSurfaceGLX->width, ++ pSurfaceGLX->height, ++ 0, 0, ++ pSurfaceGLX->width, ++ pSurfaceGLX->height, ++ NULL, 0, ++ flags); ++ XSync(ctx->x11_dpy, False); ++ if (x11_untrap_errors() != 0) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ pSurfaceGLX->surface = surface; ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaDeassociateSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ if (!pDriverContextGLX->use_tfp) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ if (unbind_pixmap(ctx, pSurfaceGLX) < 0) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ ++ pSurfaceGLX->surface = VA_INVALID_SURFACE; ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaSyncSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ if (!pDriverContextGLX->use_tfp) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ if (pSurfaceGLX->surface == VA_INVALID_SURFACE) ++ return VA_STATUS_ERROR_INVALID_SURFACE; ++ ++ return ctx->vtable.vaSyncSurface(ctx, pSurfaceGLX->surface); ++} ++ ++static VAStatus ++vaBeginRenderSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ VAStatus status; ++ ++ if (!pDriverContextGLX->use_tfp) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ status = vaSyncSurfaceGLX_impl_libva(ctx, gl_surface); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ if (bind_pixmap(ctx, pSurfaceGLX) < 0) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaEndRenderSurfaceGLX_impl_libva(VADriverContextP ctx, void *gl_surface) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ VAStatus status; ++ ++ if (!pDriverContextGLX->use_tfp) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ if (unbind_pixmap(ctx, pSurfaceGLX) < 0) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaCopySurfaceGLX_impl_libva( ++ VADriverContextP ctx, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VADriverVTableGLXP vtable = &pDriverContextGLX->vtable; ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ VAStatus status; ++ ++ if (!pDriverContextGLX->use_fbo) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ /* XXX: only support VA_FRAME_PICTURE */ ++ if (flags != VA_FRAME_PICTURE) ++ return VA_STATUS_ERROR_FLAG_NOT_SUPPORTED; ++ ++ /* Associate VA surface */ ++ status = vtable->vaAssociateSurfaceGLX(ctx, gl_surface, surface, flags); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ /* Make sure binding succeeds, if texture was not already bound */ ++ struct OpenGLTextureState ts; ++ if (bind_texture(&ts, pSurfaceGLX->target, pSurfaceGLX->texture) < 0) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ ++ /* Render to FBO */ ++ fbo_enter(ctx, pSurfaceGLX); ++ status = vtable->vaBeginRenderSurfaceGLX(ctx, gl_surface); ++ if (status == VA_STATUS_SUCCESS) { ++ render_pixmap(ctx, pSurfaceGLX); ++ status = vtable->vaEndRenderSurfaceGLX(ctx, gl_surface); ++ } ++ fbo_leave(ctx); ++ unbind_texture(&ts); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ return vtable->vaDeassociateSurfaceGLX(ctx, gl_surface); ++} ++ ++ ++/* ========================================================================= */ ++/* === VA/GLX bind functions implementation with vaCopySurfaceGLX() === */ ++/* ========================================================================= */ ++ ++static VAStatus ++vaAssociateSurfaceGLX_impl_bind( ++ VADriverContextP ctx, ++ void *gl_surface, ++ VASurfaceID surface, ++ unsigned int flags ++) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VADriverVTableGLXP vtable = &pDriverContextGLX->vtable; ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ VAStatus status; ++ ++ if (!pDriverContextGLX->has_copy) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ status = vtable->vaCopySurfaceGLX(ctx, gl_surface, surface, flags); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ pSurfaceGLX->surface = surface; ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaDeassociateSurfaceGLX_impl_bind(VADriverContextP ctx, void *gl_surface) ++{ ++ VADriverContextGLXP pDriverContextGLX = VA_DRIVER_CONTEXT_GLX(ctx); ++ VASurfaceGLXP pSurfaceGLX = gl_surface; ++ ++ if (!pDriverContextGLX->has_copy) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ ++ pSurfaceGLX->surface = VA_INVALID_SURFACE; ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaBeginRenderSurfaceGLX_impl_bind(VADriverContextP ctx, void *gl_surface) ++{ ++ /* Surface is already copied into the texture, in vaAssociateSurfaceGLX() */ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus ++vaEndRenderSurfaceGLX_impl_bind(VADriverContextP ctx, void *gl_surface) ++{ ++ return VA_STATUS_SUCCESS; ++} ++ ++ ++/* ========================================================================= */ ++/* === Private VA/GLX vtable initialization === */ ++/* ========================================================================= */ ++ ++// Initialize GLX driver context ++VAStatus va_glx_init_context(VADriverContextP ctx) ++{ ++ VADriverContextGLXP glx_ctx = VA_DRIVER_CONTEXT_GLX(ctx); ++ VADriverVTableGLXP vtable = &glx_ctx->vtable; ++ int needs_tfp = 0, needs_fbo = 0; ++ ++ if (glx_ctx->is_initialized) ++ return VA_STATUS_SUCCESS; ++ ++ glx_ctx->has_copy = ctx->vtable.glx.vaCopySurfaceGLX != NULL; ++ glx_ctx->has_bind = (ctx->vtable.glx.vaAssociateSurfaceGLX != NULL && ++ ctx->vtable.glx.vaBeginRenderSurfaceGLX != NULL && ++ ctx->vtable.glx.vaEndRenderSurfaceGLX != NULL && ++ ctx->vtable.glx.vaDeassociateSurfaceGLX != NULL); ++ ++ switch ((((unsigned int)glx_ctx->has_bind) << 1) | glx_ctx->has_copy) { ++ case 0: ++ /* Full implementation in libVA */ ++ needs_tfp = 1; ++ needs_fbo = 1; ++ vtable->vaCreateSurfaceGLX = vaCreateSurfaceGLX_impl_libva; ++ vtable->vaDestroySurfaceGLX = vaDestroySurfaceGLX_impl_libva; ++ vtable->vaAssociateSurfaceGLX = vaAssociateSurfaceGLX_impl_libva; ++ vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_libva; ++ vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_libva; ++ vtable->vaEndRenderSurfaceGLX = vaEndRenderSurfaceGLX_impl_libva; ++ vtable->vaSyncSurfaceGLX = vaSyncSurfaceGLX_impl_libva; ++ vtable->vaCopySurfaceGLX = vaCopySurfaceGLX_impl_libva; ++ break; ++ case 1: ++ /* Add bind functions based on vaCopySurfaceGLX() */ ++ /* XXX: override vaSyncSurfaceGLX()? */ ++ vtable->vaCreateSurfaceGLX = vaCreateSurfaceGLX_impl_driver; ++ vtable->vaDestroySurfaceGLX = vaDestroySurfaceGLX_impl_driver; ++ vtable->vaAssociateSurfaceGLX = vaAssociateSurfaceGLX_impl_bind; ++ vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_bind; ++ vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_bind; ++ vtable->vaEndRenderSurfaceGLX = vaEndRenderSurfaceGLX_impl_bind; ++ vtable->vaSyncSurfaceGLX = vaSyncSurfaceGLX_impl_driver; ++ vtable->vaCopySurfaceGLX = vaCopySurfaceGLX_impl_driver; ++ break; ++ case 2: ++ /* Add copy function based on vaBeginRenderSurfaceGLX() et al. */ ++ needs_fbo = 1; ++ vtable->vaCreateSurfaceGLX = vaCreateSurfaceGLX_impl_driver; ++ vtable->vaDestroySurfaceGLX = vaDestroySurfaceGLX_impl_driver; ++ vtable->vaAssociateSurfaceGLX = vaAssociateSurfaceGLX_impl_driver; ++ vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_driver; ++ vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_driver; ++ vtable->vaEndRenderSurfaceGLX = vaEndRenderSurfaceGLX_impl_driver; ++ vtable->vaSyncSurfaceGLX = vaSyncSurfaceGLX_impl_driver; ++ vtable->vaCopySurfaceGLX = vaCopySurfaceGLX_impl_libva; ++ break; ++ case 3: ++ /* Keep driver bind & copy functions */ ++ vtable->vaCreateSurfaceGLX = vaCreateSurfaceGLX_impl_driver; ++ vtable->vaDestroySurfaceGLX = vaDestroySurfaceGLX_impl_driver; ++ vtable->vaAssociateSurfaceGLX = vaAssociateSurfaceGLX_impl_driver; ++ vtable->vaDeassociateSurfaceGLX = vaDeassociateSurfaceGLX_impl_driver; ++ vtable->vaBeginRenderSurfaceGLX = vaBeginRenderSurfaceGLX_impl_driver; ++ vtable->vaEndRenderSurfaceGLX = vaEndRenderSurfaceGLX_impl_driver; ++ vtable->vaSyncSurfaceGLX = vaSyncSurfaceGLX_impl_driver; ++ vtable->vaCopySurfaceGLX = vaCopySurfaceGLX_impl_driver; ++ break; ++ default: ++ /* Fatal error: this cannot happen */ ++ assert(0); ++ return VA_STATUS_ERROR_UNKNOWN; ++ } ++ ++ glx_ctx->has_tfp = 0; ++ glx_ctx->use_tfp = 0; ++ glx_ctx->has_fbo = 0; ++ glx_ctx->use_fbo = 0; ++ ++ if (needs_tfp) { ++ glx_ctx->has_tfp = check_tfp_extensions(ctx); ++ if (!glx_ctx->has_tfp || !load_tfp_extensions(ctx)) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ glx_ctx->use_tfp = 1; ++ } ++ ++ if (needs_fbo) { ++ glx_ctx->has_fbo = check_fbo_extensions(ctx); ++ if (!glx_ctx->has_fbo || !load_fbo_extensions(ctx)) ++ return VA_STATUS_ERROR_UNIMPLEMENTED; ++ glx_ctx->use_fbo = 1; ++ } ++ ++ glx_ctx->is_initialized = 1; ++ return VA_STATUS_SUCCESS; ++} +diff --git a/src/glx/va_glx_impl.h b/src/glx/va_glx_impl.h +new file mode 100644 +index 0000000..977bfcc +--- /dev/null ++++ b/src/glx/va_glx_impl.h +@@ -0,0 +1,46 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#ifndef VA_GLX_IMPL_H ++#define VA_GLX_IMPL_H ++ ++/** ++ * Initialize GLX driver context ++ * ++ * @param[in] ctx the VA driver context ++ * @return VA_STATUS_SUCCESS if successful ++ */ ++VAStatus va_glx_init_context(VADriverContextP ctx) ++ ATTRIBUTE_HIDDEN; ++ ++/** Create VA/GLX surface */ ++VASurfaceGLXP ++va_glx_create_surface(VADriverContextP ctx, GLenum target, GLuint texture) ++ ATTRIBUTE_HIDDEN; ++ ++/** Destroy VA/GLX surface */ ++void va_glx_destroy_surface(VADriverContextP ctx, VASurfaceGLXP *pSurfaceGLX) ++ ATTRIBUTE_HIDDEN; ++ ++#endif /* VA_GLX_IMPL_H */ +diff --git a/src/glx/va_glx_private.h b/src/glx/va_glx_private.h +new file mode 100644 +index 0000000..8658ad3 +--- /dev/null ++++ b/src/glx/va_glx_private.h +@@ -0,0 +1,98 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#ifndef VA_GLX_PRIVATE_H ++#define VA_GLX_PRIVATE_H ++ ++#include "config.h" ++#include "va.h" ++#include "va_backend.h" ++#include "va_x11.h" ++#include "va_glx.h" ++ ++#if GLX_GLXEXT_VERSION < 18 ++typedef void (*PFNGLXBINDTEXIMAGEEXTPROC)(Display *, GLXDrawable, int, const int *); ++typedef void (*PFNGLXRELEASETEXIMAGEEXTPROC)(Display *, GLXDrawable, int); ++#endif ++ ++typedef struct VAOpenGLVTable *VAOpenGLVTableP; ++ ++struct VAOpenGLVTable { ++ PFNGLXBINDTEXIMAGEEXTPROC glx_bind_tex_image; ++ PFNGLXRELEASETEXIMAGEEXTPROC glx_release_tex_image; ++ PFNGLGENFRAMEBUFFERSEXTPROC gl_gen_framebuffers; ++ PFNGLDELETEFRAMEBUFFERSEXTPROC gl_delete_framebuffers; ++ PFNGLBINDFRAMEBUFFEREXTPROC gl_bind_framebuffer; ++ PFNGLGENRENDERBUFFERSEXTPROC gl_gen_renderbuffers; ++ PFNGLDELETERENDERBUFFERSEXTPROC gl_delete_renderbuffers; ++ PFNGLBINDRENDERBUFFEREXTPROC gl_bind_renderbuffer; ++ PFNGLRENDERBUFFERSTORAGEEXTPROC gl_renderbuffer_storage; ++ PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC gl_framebuffer_renderbuffer; ++ PFNGLFRAMEBUFFERTEXTURE2DEXTPROC gl_framebuffer_texture_2d; ++ PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC gl_check_framebuffer_status; ++}; ++ ++typedef struct VADisplayContextGLX *VADisplayContextGLXP; ++typedef struct VADriverContextGLX *VADriverContextGLXP; ++typedef struct VASurfaceGLX *VASurfaceGLXP; ++typedef struct VADriverVTableGLX *VADriverVTableGLXP; ++ ++struct VADisplayContextGLX { ++ void (*vaDestroy)(VADisplayContextP ctx); ++}; ++ ++#define VA_DRIVER_CONTEXT_GLX(ctx) ((VADriverContextGLXP)((ctx)->glx)) ++ ++struct VADriverContextGLX { ++ struct VADriverVTableGLX vtable; ++ struct VAOpenGLVTable gl_vtable; ++ unsigned int is_initialized : 1; ++ unsigned int has_copy : 1; ++ unsigned int has_bind : 1; ++ unsigned int has_tfp : 1; ++ unsigned int has_fbo : 1; ++ unsigned int use_tfp : 1; ++ unsigned int use_fbo : 1; ++}; ++ ++/** Unique VASurfaceGLX identifier */ ++#define VA_SURFACE_GLX_MAGIC VA_FOURCC('V','A','G','L') ++ ++struct VASurfaceGLX { ++ uint32_t magic; ///< Magic number identifying a VASurfaceGLX ++ GLenum target; ///< GL target to which the texture is bound ++ GLuint texture; ///< GL texture ++ VASurfaceID surface; ///< Associated VA surface ++ unsigned int width; ++ unsigned int height; ++ int is_bound; ++ Pixmap pixmap; ++ GLXPixmap glx_pixmap; ++ GLuint fbo; ++ GLuint fbo_buffer; ++ GLuint fbo_texture; ++ void *priv; ///< Private VA/GLX surface data from driver ++}; ++ ++#endif /* VA_GLX_PRIVATE_H */ diff --git a/meta-emenlow/packages/libva/libva-0.31.0/390_compat.base.patch b/meta-emenlow/packages/libva/libva-0.31.0/390_compat.base.patch new file mode 100644 index 0000000000..f2e0d61b0d --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/390_compat.base.patch @@ -0,0 +1,135 @@ +commit 483bc9e67afa9bcd8f99f08a74a78e7dfad4651f +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jul 2 09:24:04 2009 +0000 + + Fix make dist (va_compat_template.h). + +commit 0e0da9ea861f14e8129767dbf6f11be5c051d85f +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed Jun 24 11:40:56 2009 +0000 + + Add compatibility layer with original libva 0.29. + +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -44,7 +44,7 @@ libva_x11_la_DEPENDENCIES = $(libvacorelib) + libva_x11_la_DEPENDENCIES = $(libvacorelib) + + +-libva_la_SOURCES = va.c ++libva_la_SOURCES = va.c va_compat.c + + libvaincludedir = ${includedir}/va + libvainclude_HEADERS = va.h va_backend.h va_version.h +@@ -53,4 +53,8 @@ DISTCLEANFILES = \ + va_version.h + + EXTRA_DIST = \ +- va_version.h.in ++ va_version.h.in \ ++ va_compat.h \ ++ va_compat_template.h ++ ++va_compat.c: va_compat_template.h +--- a/src/va.c ++++ b/src/va.c +@@ -25,6 +25,7 @@ + #define _GNU_SOURCE 1 + #include "va.h" + #include "va_backend.h" ++#include "va_compat.h" + + #include <assert.h> + #include <stdarg.h> +@@ -41,6 +42,8 @@ + + #define DRIVER_INIT_FUNC "__vaDriverInit_0_31" + #define DRIVER_INIT_FUNC_SDS "__vaDriverInit_0_31_sds" ++#define DRIVER_INIT_FUNC_0_29 "__vaDriverInit_0_29" ++#define DRIVER_INIT_FUNC_0_30 "__vaDriverInit_0_30" + + #define DRIVER_EXTENSION "_drv_video.so" + +@@ -168,11 +171,22 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name) + else + { + VADriverInit init_func; +- init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC); ++ int compat_version = 0; ++ /* First, try SDS extensions (VDPAU and XvBA backends) */ ++ init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_SDS); + if (!init_func) + { +- /* Then try SDS extensions (VDPAU and XvBA backends) */ +- init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_SDS); ++ /* Otherwise, we need the compatibility layer for some buffers */ ++ init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC); ++ compat_version = VA_MINOR_VERSION; ++ if (!init_func) { ++ init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_0_29); ++ compat_version = 29; ++ } ++ if (!init_func) { ++ init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC_0_30); ++ compat_version = 30; ++ } + } + if (!init_func) + { +@@ -181,7 +195,36 @@ static VAStatus va_openDriver(VADisplay dpy, char *driver_name) + } + else + { +- vaStatus = (*init_func)(ctx); ++ struct VADriverContext_0_29 ctx_0_29; ++ struct VADriverContext_0_30 ctx_0_30; ++ void *compat_ctx = NULL; ++ ++ switch (compat_version) { ++ case 29: ++ compat_ctx = &ctx_0_29; ++ ctx_0_29.pDriverData = NULL; ++ ctx_0_29.x11_dpy = ctx->x11_dpy; ++ ctx_0_29.x11_screen = ctx->x11_screen; ++ break; ++ case 30: ++ compat_ctx = &ctx_0_30; ++ ctx_0_30.pDriverData = NULL; ++ ctx_0_30.x11_dpy = ctx->x11_dpy; ++ ctx_0_30.x11_screen = ctx->x11_screen; ++ break; ++ case VA_MINOR_VERSION: ++ compat_ctx = ctx; ++ break; ++ default: ++ ASSERT(compat_version == 0); ++ vaStatus = VA_STATUS_ERROR_UNKNOWN; ++ break; ++ } ++ ++ vaStatus = (*init_func)(compat_ctx ? compat_ctx : ctx); ++ ++ if (VA_STATUS_SUCCESS == vaStatus) ++ vaStatus = va_compat_init(dpy, compat_version, compat_ctx); + + if (VA_STATUS_SUCCESS == vaStatus) + { +@@ -377,6 +422,8 @@ VAStatus vaTerminate ( + old_ctx->handle = NULL; + } + ++ va_compat_fini(dpy); ++ + if (VA_STATUS_SUCCESS == vaStatus) + pDisplayContext->vaDestroy(pDisplayContext); + return vaStatus; +--- a/src/va_backend.h ++++ b/src/va_backend.h +@@ -426,6 +426,7 @@ struct VADriverContext + + void *dri_state; + void *glx; /* opaque for GLX code */ ++ void *compat; /* opaque for compat code */ + }; + + struct VADisplayContext diff --git a/meta-emenlow/packages/libva/libva-0.31.0/391_compat.patch b/meta-emenlow/packages/libva/libva-0.31.0/391_compat.patch new file mode 100644 index 0000000000..5e09d22b82 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/391_compat.patch @@ -0,0 +1,3273 @@ +commit 2e7aa803a8547dfcde6e97ae2bb4a8bbdbb2634e +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Mon Nov 23 12:22:09 2009 +0000 + + Update compat code for VDPAU/MPEG-4 additions. + +commit 30808b39d82cbf0c185052a2d2d5ed8a5fc065d1 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Sep 10 14:01:57 2009 +0000 + + Update compatibility glue for VASliceParameterBufferMPEG2.slice_horizontal_position addition. + +commit 27faf49366602637da223f3dc5f30ce4d6d72070 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed Sep 2 15:06:20 2009 +0000 + + Fix vaSyncSurface() compat code for VA API < 0.31 drivers. + +commit dc33a3e28b38b7d579ab768899963cf9b0d38677 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed Sep 2 12:28:43 2009 +0000 + + Fix check for 0.30 modules. + +commit bd913971bd9e7460b454513b006e16c18136625e +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed Sep 2 11:58:08 2009 +0000 + + Update for VA API 0.31. + +commit 9cc7f89d3cc0238ab5b3a47c316e261e06a16634 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jul 2 15:55:48 2009 +0000 + + Fix VAEncSliceParameterBuffer thunk. + +commit 483bc9e67afa9bcd8f99f08a74a78e7dfad4651f +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jul 2 09:24:04 2009 +0000 + + Fix make dist (va_compat_template.h). + +commit 7f41b22366142c4e476fbae929ad343dc33af3a4 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jun 25 14:05:57 2009 +0000 + + Drop superfluous semi-colon. + +commit dcc75aae23fc8f653179b6a331f4021acd6775fd +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jun 25 13:53:26 2009 +0000 + + Fix check for 0.30 modules. + +commit b34512e74ac4150a3f8ee4abe4fa5b17907f8869 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jun 25 13:17:48 2009 +0000 + + Fix vaTerminate() thunk. + +commit 3b006d1ac66429f6b8ffff00ce60e1e47a32c02c +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jun 25 12:48:22 2009 +0000 + + Cosmetics. + +commit 452295d5ac34643f8a316491888c3900f12c5bff +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Thu Jun 25 12:18:48 2009 +0000 + + Fix compatibility with 0.29 modules. + +commit 0e0da9ea861f14e8129767dbf6f11be5c051d85f +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Wed Jun 24 11:40:56 2009 +0000 + + Add compatibility layer with original libva 0.29. + +diff --git a/src/va_compat.c b/src/va_compat.c +new file mode 100644 +index 0000000..0bd7385 +--- /dev/null ++++ b/src/va_compat.c +@@ -0,0 +1,1171 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#include "config.h" ++#include "va.h" ++#include "va_compat.h" ++#include "va_backend.h" ++#include <string.h> ++#include <alloca.h> ++#include <assert.h> ++ ++#define CTX(dpy) (((VADisplayContextP)dpy)->pDriverContext) ++#define COMPAT_CTX(ctx) ((VACompatContextP)(ctx)->compat) ++#define ASSERT assert ++ ++/* Invoke the normal VA API entry-point. This one can be replaced with ++ one of the va_compat_*() functions */ ++#define VA_INVOKE(FUNC, CTX, ...) \ ++ (CTX)->vtable.FUNC(CTX, __VA_ARGS__) ++ ++/* Invoke the real VA API entry-point. That is, the driver's function */ ++#define VA_INVOKE_COMPAT_ARGS(CTX, ...) \ ++ (COMPAT_CTX(CTX)->compat_ctx, __VA_ARGS__) ++#define VA_INVOKE_COMPAT(FUNC, CTX, ...) \ ++ COMPAT_CTX(CTX)->vtable.FUNC VA_INVOKE_COMPAT_ARGS(CTX, __VA_ARGS__) ++ ++typedef struct VACompatContext *VACompatContextP; ++ ++typedef VAStatus (*VABufferTranslateFunc)(VACompatContextP ctx, void *dest, const void *src); ++ ++typedef enum { ++ VA_DRIVER_ID_UNKNOWN, ++ VA_DRIVER_ID_POULSBO, ++ VA_DRIVER_ID_IEGD ++} VADriverID; ++ ++typedef struct { ++ VABufferID id; ++ VABufferType type; ++ unsigned int size; ++ unsigned int num_elements; ++ unsigned char *data; ++ VABufferTranslateFunc translate; ++ VABufferID compat_id; ++ unsigned int compat_size; ++ unsigned char *compat_data; ++ unsigned int map_count; ++} VABufferCompat; ++ ++typedef struct VAContextMap *VAContextMapP; ++typedef struct VAContextMap { ++ VASurfaceID surface; ++ VAContextID context; ++ VAContextMapP next; ++} VAContextMap; ++ ++typedef struct { ++ VAStatus (*vaTerminate)(void *); ++ VAStatus (*vaQueryConfigProfiles)(void *, VAProfile *, int *); ++ VAStatus (*vaQueryConfigEntrypoints)(void *, VAProfile, VAEntrypoint *, int *); ++ VAStatus (*vaGetConfigAttributes)(void *, VAProfile, VAEntrypoint, VAConfigAttrib *, int); ++ VAStatus (*vaCreateConfig)(void *, VAProfile, VAEntrypoint, VAConfigAttrib *, int, VAConfigID *); ++ VAStatus (*vaDestroyConfig)(void *, VAConfigID); ++ VAStatus (*vaQueryConfigAttributes)(void *, VAConfigID, VAProfile *, VAEntrypoint *, VAConfigAttrib *, int *); ++ VAStatus (*vaCreateSurfaces)(void *, int, int, int, int, VASurfaceID *); ++ VAStatus (*vaDestroySurfaces)(void *, VASurfaceID *, int); ++ VAStatus (*vaCreateContext)(void *, VAConfigID, int, int, int, VASurfaceID *, int, VAContextID *); ++ VAStatus (*vaDestroyContext)(void *, VAContextID); ++ VAStatus (*vaCreateBuffer)(void *, VAContextID, VABufferType, unsigned int, unsigned int, void *, VABufferID *); ++ VAStatus (*vaBufferSetNumElements)(void *, VABufferID, unsigned int); ++ VAStatus (*vaMapBuffer)(void *, VABufferID, void **); ++ VAStatus (*vaUnmapBuffer)(void *, VABufferID); ++ VAStatus (*vaDestroyBuffer)(void *, VABufferID); ++ VAStatus (*vaBeginPicture)(void *, VAContextID, VASurfaceID); ++ VAStatus (*vaRenderPicture)(void *, VAContextID, VABufferID *, int); ++ VAStatus (*vaEndPicture)(void *, VAContextID); ++ VAStatus (*vaSyncSurface_pre31)(void *, VAContextID, VASurfaceID); ++ VAStatus (*vaQuerySurfaceStatus)(void *, VASurfaceID, VASurfaceStatus *); ++ VAStatus (*vaPutSurface)(void *, VASurfaceID, unsigned long, short, short, unsigned short, unsigned short, short, short, unsigned short, unsigned short, VARectangle *, unsigned int, unsigned int); ++ VAStatus (*vaQueryImageFormats)(void *, VAImageFormat *, int *); ++ VAStatus (*vaCreateImage)(void *, VAImageFormat *, int, int, VAImage *); ++ VAStatus (*vaDeriveImage)(void *, VASurfaceID, VAImage *); ++ VAStatus (*vaDestroyImage)(void *, VAImageID); ++ VAStatus (*vaSetImagePalette)(void *, VAImageID, unsigned char *); ++ VAStatus (*vaGetImage)(void *, VASurfaceID, int, int, unsigned int, unsigned int, VAImageID); ++ VAStatus (*vaPutImage_pre31)(void *, VASurfaceID, VAImageID, int, int, unsigned int, unsigned int, int, int); ++ VAStatus (*vaPutImage2_pre31)(void *, VASurfaceID, VAImageID, int, int, unsigned int, unsigned int, int, int, unsigned int, unsigned int); ++ VAStatus (*vaQuerySubpictureFormats)(void *, VAImageFormat *, unsigned int *, unsigned int *); ++ VAStatus (*vaCreateSubpicture)(void *, VAImageID, VASubpictureID *); ++ VAStatus (*vaDestroySubpicture)(void *, VASubpictureID); ++ VAStatus (*vaSetSubpictureImage)(void *, VASubpictureID, VAImageID); ++ VAStatus (*vaSetSubpictureChromakey)(void *, VASubpictureID, unsigned int, unsigned int, unsigned int); ++ VAStatus (*vaSetSubpictureGlobalAlpha)(void *, VASubpictureID, float); ++ VAStatus (*vaAssociateSubpicture_pre31)(void *, VASubpictureID, VASurfaceID *, int, short, short, short, short, unsigned short, unsigned short, unsigned int); ++ VAStatus (*vaAssociateSubpicture2_pre31)(void *, VASubpictureID, VASurfaceID *, int, short, short, unsigned short, unsigned short, short, short, unsigned short, unsigned short, unsigned int); ++ VAStatus (*vaDeassociateSubpicture)(void *, VASubpictureID, VASurfaceID *, int); ++ VAStatus (*vaQueryDisplayAttributes)(void *, VADisplayAttribute *, int *); ++ VAStatus (*vaGetDisplayAttributes)(void *, VADisplayAttribute *, int); ++ VAStatus (*vaSetDisplayAttributes)(void *, VADisplayAttribute *, int); ++ ++ /* 0.29 hooks */ ++ VAStatus (*vaSetSubpicturePalette)(void *, VASubpictureID, unsigned char *); ++ VAStatus (*vaDbgCopySurfaceToBuffer)(void *, VASurfaceID, void **, unsigned int *); ++ ++ /* 0.30 hooks */ ++ VAStatus (*vaCreateSurfaceFromCIFrame)(void *, unsigned long, VASurfaceID *); ++ VAStatus (*vaCreateSurfaceFromV4L2Buf)(void *, int, struct v4l2_format *, struct v4l2_buffer *, VASurfaceID *); ++ VAStatus (*vaCopySurfaceToBuffer)(void *, VASurfaceID, unsigned int *, unsigned int *, unsigned int *, unsigned int *, unsigned int *, unsigned int *, unsigned int *, void **); ++ ++ /* 0.31 hooks */ ++ VAStatus (*vaPutImage)(void *, VASurfaceID, VAImageID, int, int, unsigned int, unsigned int, int, int, unsigned int, unsigned int); ++ VAStatus (*vaAssociateSubpicture)(void *, VASubpictureID, VASurfaceID *, int, short, short, unsigned short, unsigned short, short, short, unsigned short, unsigned short, unsigned int); ++ VAStatus (*vaSyncSurface)(void *, VASurfaceID); ++} VACompatDriverVTable; ++ ++typedef struct VACompatContext { ++ VABufferCompat *buffers; ++ unsigned int buffers_count_max; ++ unsigned int compat_version; ++ void *compat_ctx; ++ VACompatDriverVTable vtable; /* original vtable */ ++ VADriverID driver_id; ++ char *driver_name; ++ VAContextMapP context_map; ++ VAContextMapP last_context_map_match; ++ unsigned int skip_frame : 1; ++} VACompatContext; ++ ++#define COMPAT_MAJOR 0 ++#define COMPAT_MINOR 29 ++#include "va_compat_template.h" ++ ++#define COMPAT_MAJOR 0 ++#define COMPAT_MINOR 30 ++#include "va_compat_template.h" ++ ++#define COMPAT_MAJOR 0 ++#define COMPAT_MINOR 31 ++#include "va_compat_template.h" ++ ++static inline int va_IsIntelBuffer(VADriverContextP ctx, VABufferID id) ++{ ++ VACompatContextP compat = ctx->compat; ++ ++ if (compat->driver_id == VA_DRIVER_ID_POULSBO) { ++ /* There were only Intel implementations for VA API. Besides, the ++ returned buffer IDs had the following format [ 0 BASE ID ] where ++ BASE is the 7-bit value 0x04 and ID an index into the heap of ++ objects */ ++ return (id & 0x7f000000) == 0x04000000; ++ } ++ ++ if (compat->driver_id == VA_DRIVER_ID_IEGD) { ++ /* XXX: there is no means to differentiate the buffers, they ++ are linearly generated (IEGD 10.0 build 1335) */ ++ return 1; ++ } ++ ++ return 0; ++} ++ ++static VAContextMapP va_context_map_lookup_p( ++ VACompatContextP ctx, ++ VASurfaceID surface ++) ++{ ++ VAContextMapP m = ctx->context_map; ++ ++ while (m) { ++ if (m->surface == surface) ++ return m; ++ m = m->next; ++ } ++ return NULL; ++} ++ ++static VAContextID va_context_map_lookup( ++ VACompatContextP ctx, ++ VASurfaceID surface ++) ++{ ++ VAContextMapP m; ++ ++ /* Lookup in cached */ ++ m = ctx->last_context_map_match; ++ if (m && m->surface == surface) ++ return m->context; ++ ++ /* Full (slow) lookup */ ++ m = va_context_map_lookup_p(ctx, surface); ++ if (m) { ++ ctx->last_context_map_match = m; ++ return m->context; ++ } ++ return VA_INVALID_ID; ++} ++ ++static void va_context_map_add( ++ VACompatContextP ctx, ++ VAContextID context, ++ VASurfaceID surface ++) ++{ ++ VAContextMapP m; ++ ++ /* Update existing entry */ ++ m = va_context_map_lookup_p(ctx, surface); ++ if (m) { ++ m->context = context; ++ return; ++ } ++ ++ /* Create new mapping */ ++ m = malloc(sizeof(*m)); ++ ASSERT(m); ++ if (m) { ++ m->surface = surface; ++ m->context = context; ++ m->next = ctx->context_map; ++ ctx->context_map = m; ++ } ++} ++ ++static void va_context_map_remove( ++ VACompatContextP ctx, ++ VAContextID context ++) ++{ ++ VAContextMapP p = NULL; ++ VAContextMapP m = ctx->context_map; ++ VAContextMapP d; ++ ++ while (m) { ++ if (m->context == context) { ++ d = m; ++ ++ /* Unlink current node */ ++ if (p) ++ p->next = m->next; ++ else ++ ctx->context_map = m->next; ++ m = m->next; ++ ++ /* Reset cache */ ++ if (ctx->last_context_map_match == d) ++ ctx->last_context_map_match = NULL; ++ ++ free(d); ++ } ++ else { ++ p = m; ++ m = m->next; ++ } ++ } ++} ++ ++static VABufferCompat *va_GetBufferCompat ( ++ VADriverContextP ctx, ++ VABufferID id ++) ++{ ++ VACompatContextP compat = ctx->compat; ++ int index; ++ ++ if (!va_IsIntelBuffer(ctx, id)) ++ return NULL; ++ ++ index = id & 0x00ffffff; ++ if (index >= compat->buffers_count_max) ++ return NULL; ++ ++ if (compat->buffers[index].id != id) ++ return NULL; ++ ++ return &compat->buffers[index]; ++} ++ ++static VAStatus va_TranslateBufferCompat ( ++ VADriverContextP ctx, ++ VABufferCompat *compat_buffer ++) ++{ ++ VAStatus status; ++ unsigned char *src, *dest; ++ int i; ++ ++ status = VA_INVOKE(vaMapBuffer, ctx, compat_buffer->id, (void **)&src); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ ASSERT(compat_buffer->data); ++ ASSERT(src == compat_buffer->data); ++ ASSERT(compat_buffer->compat_data); ++ dest = compat_buffer->compat_data; ++ for (i = 0; i < compat_buffer->num_elements; i++) ++ { ++ /* XXX: check errors */ ++ status = compat_buffer->translate(ctx->compat, dest, src); ++ ++ src += compat_buffer->size; ++ dest += compat_buffer->compat_size; ++ } ++ ++ return VA_INVOKE(vaUnmapBuffer, ctx, compat_buffer->id); ++} ++ ++static VAStatus va_CreateBufferCompat ( ++ VADriverContextP ctx, ++ VAContextID context, ++ VABufferID id, ++ VABufferType type, ++ unsigned int size, ++ unsigned int num_elements, ++ unsigned int compat_size, ++ VABufferTranslateFunc translate_func ++) ++{ ++ VACompatContextP compat = ctx->compat; ++ VABufferCompat *compat_buffer; ++ int index; ++ ++ if (!va_IsIntelBuffer(ctx, id)) ++ return VA_STATUS_ERROR_INVALID_BUFFER; ++ index = id & 0x00ffffff; ++ ++ /* XXX: this allocation strategy is not really space efficient... */ ++ if (index >= compat->buffers_count_max) ++ { ++ compat->buffers_count_max = index + 1; ++ compat->buffers = realloc(compat->buffers, ++ (compat->buffers_count_max * ++ sizeof(VABufferCompat))); ++ if (compat->buffers == NULL) ++ return VA_STATUS_ERROR_ALLOCATION_FAILED; ++ } ++ ++ compat_buffer = &compat->buffers[index]; ++ compat_buffer->id = id; ++ compat_buffer->type = type; ++ compat_buffer->size = size; ++ compat_buffer->num_elements = num_elements; ++ compat_buffer->data = NULL; ++ compat_buffer->translate = translate_func; ++ compat_buffer->compat_size = compat_size; ++ compat_buffer->compat_data = NULL; ++ compat_buffer->map_count = 0; ++ ++ return VA_INVOKE_COMPAT(vaCreateBuffer, ++ ctx, ++ context, ++ type, ++ compat_size, ++ num_elements, ++ NULL, ++ &compat_buffer->compat_id); ++} ++ ++static VAStatus va_DestroyBufferCompat ( ++ VADriverContextP ctx, ++ VABufferID id ++) ++{ ++ VABufferCompat *compat_buffer; ++ VAStatus status; ++ ++ if ((compat_buffer = va_GetBufferCompat(ctx, id)) == NULL) ++ return VA_STATUS_SUCCESS; ++ ++ /* Force unmap if there were more maps than unmaps */ ++ if (compat_buffer->map_count > 1) ++ compat_buffer->map_count = 1; ++ if (compat_buffer->map_count > 1) ++ { ++ if ((status = VA_INVOKE(vaUnmapBuffer, ctx, id)) != VA_STATUS_SUCCESS) ++ return status; ++ } ++ ++ compat_buffer->id = 0; ++ return VA_INVOKE_COMPAT(vaDestroyBuffer, ctx, compat_buffer->compat_id); ++} ++ ++static VAStatus va_compat_CreateBuffer ( ++ VADriverContextP ctx, ++ VAContextID context, /* in */ ++ VABufferType type, /* in */ ++ unsigned int size, /* in */ ++ unsigned int num_elements, /* in */ ++ void *data, /* in */ ++ VABufferID *buf_id /* out */ ++) ++{ ++ VABufferTranslateFunc translate_func = NULL; ++ unsigned int compat_size = 0; ++ VAStatus status; ++ ++ status = VA_INVOKE_COMPAT(vaCreateBuffer, ++ ctx, ++ context, ++ type, ++ size, ++ num_elements, ++ data, ++ buf_id); ++ ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++#define INIT_TRANSLATE_FUNC_(STRUCT, MAJOR, MINOR) do { \ ++ translate_func = va_compat_translate_VA##STRUCT##_##MAJOR##_##MINOR; \ ++ compat_size = sizeof(VA##STRUCT##_##MAJOR##_##MINOR); \ ++} while (0) ++#define INIT_TRANSLATE_FUNC(BUFFER, CODEC, MAJOR, MINOR) \ ++ INIT_TRANSLATE_FUNC_(BUFFER##Buffer##CODEC, MAJOR, MINOR) ++ ++ /* XXX: this assumes all structures have different sizes from each other */ ++ switch (size) { ++ case sizeof(VAPictureParameterBufferH264): ++ if (type == VAPictureParameterBufferType && ctx->version_major == 0) ++ { ++ switch (ctx->version_minor) { ++ case 29: INIT_TRANSLATE_FUNC(PictureParameter,H264, 0,29); break; ++ case 30: INIT_TRANSLATE_FUNC(PictureParameter,H264, 0,30); break; ++ } ++ } ++ break; ++ case sizeof(VASliceParameterBufferH264): ++ if (type == VASliceParameterBufferType && ctx->version_major == 0) ++ { ++ switch (ctx->version_minor) { ++ case 29: INIT_TRANSLATE_FUNC(SliceParameter,H264, 0,29); break; ++ case 30: INIT_TRANSLATE_FUNC(SliceParameter,H264, 0,30); break; ++ } ++ } ++ break; ++ case sizeof(VAPictureParameterBufferVC1): ++ if (type == VAPictureParameterBufferType && ctx->version_major == 0) ++ { ++ switch (ctx->version_minor) { ++ case 29: INIT_TRANSLATE_FUNC(PictureParameter,VC1, 0,29); break; ++ case 30: INIT_TRANSLATE_FUNC(PictureParameter,VC1, 0,30); break; ++ } ++ } ++ break; ++ case sizeof(VAPictureParameterBufferMPEG2): ++ if (type == VAPictureParameterBufferType && ctx->version_major == 0) ++ { ++ switch (ctx->version_minor) { ++ case 29: INIT_TRANSLATE_FUNC(PictureParameter,MPEG2, 0,29); break; ++ case 30: INIT_TRANSLATE_FUNC(PictureParameter,MPEG2, 0,30); break; ++ } ++ } ++ break; ++ case sizeof(VASliceParameterBufferMPEG2): ++ if (type == VASliceParameterBufferType && ctx->version_major == 0) ++ { ++ switch (ctx->version_minor) { ++ case 29: INIT_TRANSLATE_FUNC(SliceParameter,MPEG2, 0,29); break; ++ case 30: INIT_TRANSLATE_FUNC(SliceParameter,MPEG2, 0,30); break; ++ } ++ } ++ break; ++ case sizeof(VAPictureParameterBufferMPEG4): ++ if (type == VAPictureParameterBufferType && ctx->version_major == 0) ++ { ++ switch (ctx->version_minor) { ++ case 29: INIT_TRANSLATE_FUNC(PictureParameter,MPEG4, 0,29); break; ++ case 30: INIT_TRANSLATE_FUNC(PictureParameter,MPEG4, 0,30); break; ++ case 31: INIT_TRANSLATE_FUNC(PictureParameter,MPEG4, 0,31); break; ++ } ++ } ++ break; ++ case sizeof(VAEncSliceParameterBuffer): ++ if (type == VAEncSliceParameterBufferType && ctx->version_major == 0) ++ { ++ switch (ctx->version_minor) { ++ case 30: INIT_TRANSLATE_FUNC_(EncSliceParameterBuffer, 0,30); break; ++ } ++ } ++ break; ++ } ++ ++#undef INIT_TRANSLATE_FUNC ++ ++ /* Create thunk */ ++ if (buf_id && translate_func) ++ { ++ ASSERT(compat_size > 0); ++ ++ status = va_CreateBufferCompat(ctx, ++ context, ++ *buf_id, ++ type, ++ size, ++ num_elements, ++ compat_size, ++ translate_func); ++ } ++ ++ return status; ++} ++ ++static VAStatus va_compat_BufferSetNumElements ( ++ VADriverContextP ctx, ++ VABufferID buf_id, /* in */ ++ unsigned int num_elements /* in */ ++) ++{ ++ VABufferCompat *compat_buffer; ++ VAStatus status; ++ ++ status = VA_INVOKE_COMPAT(vaBufferSetNumElements, ctx, buf_id, num_elements); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ if ((compat_buffer = va_GetBufferCompat(ctx, buf_id)) != NULL) ++ { ++ compat_buffer->num_elements = num_elements; ++ status = VA_INVOKE_COMPAT(vaBufferSetNumElements, ++ ctx, ++ compat_buffer->compat_id, ++ num_elements); ++ } ++ ++ return status; ++} ++ ++static VAStatus va_compat_DestroyBuffer ( ++ VADriverContextP ctx, ++ VABufferID buffer_id ++) ++{ ++ VAStatus status; ++ if ((status = va_DestroyBufferCompat(ctx, buffer_id)) != VA_STATUS_SUCCESS) ++ return status; ++ ++ return VA_INVOKE_COMPAT(vaDestroyBuffer, ctx, buffer_id); ++} ++ ++static VAStatus va_compat_MapBuffer ( ++ VADriverContextP ctx, ++ VABufferID buf_id, /* in */ ++ void **pbuf /* out */ ++) ++{ ++ VABufferCompat *compat_buffer; ++ VAStatus status; ++ ++ if ((compat_buffer = va_GetBufferCompat(ctx, buf_id)) == NULL) ++ return VA_INVOKE_COMPAT(vaMapBuffer, ctx, buf_id, pbuf); ++ ++ if (compat_buffer->map_count++ == 0) ++ { ++ status = VA_INVOKE_COMPAT(vaMapBuffer, ctx, buf_id, (void **)&compat_buffer->data); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ status = VA_INVOKE_COMPAT(vaMapBuffer, ctx, compat_buffer->compat_id, (void **)&compat_buffer->compat_data); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ } ++ ++ if (pbuf) ++ *pbuf = compat_buffer->data; ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus va_compat_UnmapBuffer ( ++ VADriverContextP ctx, ++ VABufferID buf_id /* in */ ++) ++{ ++ VABufferCompat *compat_buffer; ++ VAStatus status; ++ ++ if ((compat_buffer = va_GetBufferCompat(ctx, buf_id)) == NULL) ++ return VA_INVOKE_COMPAT(vaUnmapBuffer, ctx, buf_id); ++ ++ if (--compat_buffer->map_count == 0) ++ { ++ status = VA_INVOKE_COMPAT(vaUnmapBuffer, ctx, compat_buffer->compat_id); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ compat_buffer->compat_data = NULL; ++ ++ status = VA_INVOKE_COMPAT(vaUnmapBuffer, ctx, compat_buffer->id); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ compat_buffer->data = NULL; ++ } ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus va_compat_BeginPicture ( ++ VADriverContextP ctx, ++ VAContextID context, ++ VASurfaceID render_target ++) ++{ ++ VACompatContextP compat = ctx->compat; ++ compat->skip_frame = 0; ++ return VA_INVOKE_COMPAT(vaBeginPicture, ctx, context, render_target); ++} ++ ++static VAStatus va_compat_EndPicture ( ++ VADriverContextP ctx, ++ VAContextID context ++) ++{ ++ VACompatContextP compat = ctx->compat; ++ VAStatus status = VA_INVOKE_COMPAT(vaEndPicture, ctx, context); ++ ++ /* Ignore errors if the HW decoder did not handle VC-1 skipped P-frames */ ++ if (compat->skip_frame && status == VA_STATUS_ERROR_UNKNOWN) ++ status = VA_STATUS_SUCCESS; ++ ++ return status; ++} ++ ++static VAStatus va_compat_RenderPicture ( ++ VADriverContextP ctx, ++ VAContextID context, ++ VABufferID *buffers, ++ int num_buffers ++) ++{ ++ VACompatContextP compat = ctx->compat; ++ VABufferCompat *compat_buffer; ++ VABufferID *compat_buffer_ids; ++ VAStatus status; ++ int i, n; ++ ++ if ((n = num_buffers) < 1) ++ n = 1; ++ compat_buffer_ids = alloca(n * sizeof(compat_buffer_ids[0])); ++ ++ for (i = 0; i < num_buffers; i++) ++ { ++ if ((compat_buffer = va_GetBufferCompat(ctx, buffers[i])) == NULL) ++ compat_buffer_ids[i] = buffers[i]; ++ else ++ { ++ status = va_TranslateBufferCompat(ctx, compat_buffer); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ compat_buffer_ids[i] = compat_buffer->compat_id; ++ } ++ } ++ ++ if (!compat->skip_frame) ++ { ++ status = VA_INVOKE_COMPAT(vaRenderPicture, ctx, context, compat_buffer_ids, num_buffers); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ } ++ ++ /* Buffers are automatically destroyed afterwards */ ++ for (i = 0; i < num_buffers; i++) ++ { ++ if ((compat_buffer = va_GetBufferCompat(ctx, buffers[i])) != NULL) ++ { ++ status = VA_INVOKE_COMPAT(vaDestroyBuffer, ctx, compat_buffer->id); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ } ++ } ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++#define DEFINE_VTABLE_ENTRY_(RETVAL, PROC, ARGS, COMPAT_PROC, COMPAT_ARGS, COMPAT_PRE, COMPAT_POST) \ ++static RETVAL va_compat_##PROC ARGS \ ++{ \ ++ if (COMPAT_CTX(ctx)->vtable.va##COMPAT_PROC == NULL) \ ++ return VA_STATUS_ERROR_OPERATION_FAILED; \ ++ COMPAT_PRE; \ ++ RETVAL ret = COMPAT_CTX(ctx)->vtable.va##COMPAT_PROC VA_INVOKE_COMPAT_ARGS COMPAT_ARGS; \ ++ COMPAT_POST; \ ++ return ret; \ ++} ++ ++#define DEFINE_VTABLE_ENTRY(RETVAL, PROC, DECL_ARGS, CALL_ARGS) \ ++DEFINE_VTABLE_ENTRY_(RETVAL, PROC, DECL_ARGS, PROC, CALL_ARGS, {}, {}) ++ ++static VAStatus va_compat_Terminate(VADriverContextP ctx) ++{ ++ if (COMPAT_CTX(ctx)->vtable.vaTerminate == NULL) ++ return VA_STATUS_ERROR_OPERATION_FAILED; ++ return COMPAT_CTX(ctx)->vtable.vaTerminate(COMPAT_CTX(ctx)->compat_ctx); ++} ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, QueryConfigProfiles, ++ (VADriverContextP ctx, VAProfile *profile_list, int *num_profiles), ++ (ctx, profile_list, num_profiles)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, QueryConfigEntrypoints, ++ (VADriverContextP ctx, VAProfile profile, ++ VAEntrypoint *entrypoint_list, int *num_entrypoints), ++ (ctx, profile, entrypoint_list, num_entrypoints)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, GetConfigAttributes, ++ (VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint, ++ VAConfigAttrib *attrib_list, int num_attribs), ++ (ctx, profile, entrypoint, attrib_list, num_attribs)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CreateConfig, ++ (VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint, ++ VAConfigAttrib *attrib_list, int num_attribs, VAConfigID *config_id), ++ (ctx, profile, entrypoint, attrib_list, num_attribs, config_id)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, DestroyConfig, ++ (VADriverContextP ctx, VAConfigID config_id), ++ (ctx, config_id)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, QueryConfigAttributes, ++ (VADriverContextP ctx, VAConfigID config_id, VAProfile *profile, ++ VAEntrypoint *entrypoint, VAConfigAttrib *attrib_list, int *num_attribs), ++ (ctx, config_id, profile, entrypoint, attrib_list, num_attribs)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CreateSurfaces, ++ (VADriverContextP ctx, int width, int height, int format, ++ int num_surfaces, VASurfaceID *surfaces), ++ (ctx, width, height, format, num_surfaces, surfaces)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, DestroySurfaces, ++ (VADriverContextP ctx, VASurfaceID *surface_list, int num_surfaces), ++ (ctx, surface_list, num_surfaces)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CreateContext, ++ (VADriverContextP ctx, VAConfigID config_id, ++ int picture_width, int picture_height, int flag, ++ VASurfaceID *render_targets, int num_render_targets, VAContextID *context), ++ (ctx, config_id, picture_width, picture_height, flag, ++ render_targets, num_render_targets, context)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, DestroyContext, ++ (VADriverContextP ctx, VAContextID context), ++ (ctx, context)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, SyncSurface, ++ (VADriverContextP ctx, VASurfaceID render_target), ++ (ctx, render_target)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, QuerySurfaceStatus, ++ (VADriverContextP ctx, VASurfaceID render_target, VASurfaceStatus *status), ++ (ctx, render_target, status)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, PutSurface, ++ (VADriverContextP ctx, VASurfaceID surface, Drawable draw, ++ short srcx, short srcy, unsigned short srcw, unsigned short srch, ++ short destx, short desty, unsigned short destw, unsigned short desth, ++ VARectangle *cliprects, unsigned int number_cliprects, unsigned int flags), ++ (ctx, surface, draw, srcx, srcy, srcw, srch, destx, desty, destw, desth, ++ cliprects, number_cliprects, flags)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, QueryImageFormats, ++ (VADriverContextP ctx, VAImageFormat *format_list, int *num_formats), ++ (ctx, format_list, num_formats)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CreateImage, ++ (VADriverContextP ctx, VAImageFormat *format, ++ int width, int height, VAImage *image), ++ (ctx, format, width, height, image)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, DeriveImage, ++ (VADriverContextP ctx, VASurfaceID surface, VAImage *image), ++ (ctx, surface, image)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, DestroyImage, ++ (VADriverContextP ctx, VAImageID image), ++ (ctx, image)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, SetImagePalette, ++ (VADriverContextP ctx, VAImageID image, unsigned char *palette), ++ (ctx, image, palette)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, GetImage, ++ (VADriverContextP ctx, VASurfaceID surface, ++ int x, int y, unsigned int width, unsigned int height, VAImageID image), ++ (ctx, surface, x, y, width, height, image)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, PutImage, ++ (VADriverContextP ctx, VASurfaceID surface, VAImageID image, ++ int srcx, int srcy, unsigned int srcw, unsigned int srch, ++ int destx, int desty, unsigned int destw, unsigned int desth), ++ (ctx, surface, image, srcx, srcy, srcw, srch, destx, desty, destw, desth)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, QuerySubpictureFormats, ++ (VADriverContextP ctx, VAImageFormat *format_list, ++ unsigned int *flags, unsigned int *num_formats), ++ (ctx, format_list, flags, num_formats)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CreateSubpicture, ++ (VADriverContextP ctx, VAImageID image, VASubpictureID *subpicture), ++ (ctx, image, subpicture)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, DestroySubpicture, ++ (VADriverContextP ctx, VASubpictureID subpicture), ++ (ctx, subpicture)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, SetSubpictureImage, ++ (VADriverContextP ctx, VASubpictureID subpicture, VAImageID image), ++ (ctx, subpicture, image)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, SetSubpictureChromakey, ++ (VADriverContextP ctx, VASubpictureID subpicture, ++ unsigned int chromakey_min, ++ unsigned int chromakey_max, ++ unsigned int chromakey_mask), ++ (ctx, subpicture, chromakey_min, chromakey_max, chromakey_mask)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, SetSubpictureGlobalAlpha, ++ (VADriverContextP ctx, VASubpictureID subpicture, float global_alpha), ++ (ctx, subpicture, global_alpha)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, AssociateSubpicture, ++ (VADriverContextP ctx, VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, int num_surfaces, ++ short srcx, short srcy, unsigned short srcw, unsigned short srch, ++ short destx, short desty, unsigned short destw, unsigned short desth, ++ unsigned int flags), ++ (ctx, subpicture, target_surfaces, num_surfaces, ++ srcx, srcy, srcw, srch, destx, desty, destw, desth, flags)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, DeassociateSubpicture, ++ (VADriverContextP ctx, VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, int num_surfaces), ++ (ctx, subpicture, target_surfaces, num_surfaces)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, QueryDisplayAttributes, ++ (VADriverContextP ctx, VADisplayAttribute *attr_list, int *num_attributes), ++ (ctx, attr_list, num_attributes)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, GetDisplayAttributes, ++ (VADriverContextP ctx, VADisplayAttribute *attr_list, int num_attributes), ++ (ctx, attr_list, num_attributes)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, SetDisplayAttributes, ++ (VADriverContextP ctx, VADisplayAttribute *attr_list, int num_attributes), ++ (ctx, attr_list, num_attributes)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CreateSurfaceFromCIFrame, ++ (VADriverContextP ctx, unsigned long frame_id, VASurfaceID *surface), ++ (ctx, frame_id, surface)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CreateSurfaceFromV4L2Buf, ++ (VADriverContextP ctx, int v4l2_fd, ++ struct v4l2_format *v4l2_fmt, struct v4l2_buffer *v4l2_buf, ++ VASurfaceID *surface), ++ (ctx, v4l2_fd, v4l2_fmt, v4l2_buf, surface)) ++ ++DEFINE_VTABLE_ENTRY( ++ VAStatus, CopySurfaceToBuffer, ++ (VADriverContextP ctx, VASurfaceID surface, unsigned int *fourcc, ++ unsigned int *luma_stride, ++ unsigned int *chroma_u_stride, unsigned int *chroma_v_stride, ++ unsigned int *luma_offset, ++ unsigned int *chroma_u_offset, unsigned int *chroma_v_offset, ++ void **buffer), ++ (ctx, surface, fourcc, ++ luma_stride, chroma_u_stride, chroma_v_stride, ++ luma_offset, chroma_u_offset, chroma_v_offset, ++ buffer)) ++ ++DEFINE_VTABLE_ENTRY_( ++ VAStatus, SyncSurface_pre31, ++ (VADriverContextP ctx, VASurfaceID render_target), ++ SyncSurface_pre31, ++ (ctx, va_context_map_lookup(COMPAT_CTX(ctx), render_target), render_target), ++ {}, {}) ++ ++DEFINE_VTABLE_ENTRY_( ++ VAStatus, PutImage_pre31, ++ (VADriverContextP ctx, VASurfaceID surface, VAImageID image, ++ int srcx, int srcy, unsigned int srcw, unsigned int srch, ++ int destx, int desty, unsigned int destw, unsigned int desth), ++ PutImage2_pre31, ++ (ctx, surface, image, srcx, srcy, srcw, srch, destx, desty, destw, desth), ++ {}, {}) ++ ++DEFINE_VTABLE_ENTRY_( ++ VAStatus, AssociateSubpicture_pre31, ++ (VADriverContextP ctx, VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, int num_surfaces, ++ short srcx, short srcy, unsigned short srcw, unsigned short srch, ++ short destx, short desty, unsigned short destw, unsigned short desth, ++ unsigned int flags), ++ AssociateSubpicture2_pre31, ++ (ctx, subpicture, target_surfaces, num_surfaces, ++ srcx, srcy, srcw, srch, destx, desty, destw, desth, flags), ++ {}, {}) ++ ++DEFINE_VTABLE_ENTRY_( ++ VAStatus, CreateContext_pre31, ++ (VADriverContextP ctx, VAConfigID config_id, ++ int picture_width, int picture_height, int flag, ++ VASurfaceID *render_targets, int num_render_targets, VAContextID *context), ++ CreateContext, ++ (ctx, config_id, picture_width, picture_height, flag, ++ render_targets, num_render_targets, context), ++ {}, { ++ VACompatContextP const compat_ctx = COMPAT_CTX(ctx); ++ int i; ++ for (i = 0; i < num_render_targets; i++) ++ va_context_map_add(compat_ctx, *context, render_targets[i]); ++ }) ++ ++DEFINE_VTABLE_ENTRY_( ++ VAStatus, DestroyContext_pre31, ++ (VADriverContextP ctx, VAContextID context), ++ DestroyContext, ++ (ctx, context), ++ {}, { va_context_map_remove(COMPAT_CTX(ctx), context); }) ++ ++#undef DEFINE_VTABLE_ENTRY ++#undef DEFINE_VTABLE_ENTRY_ ++ ++static void va_compat_init_VADriverVTable(VADriverContextP ctx, int compat_version) ++{ ++#define INIT_VTABLE_(CTX, DST_PROC, SRC_PROC) \ ++ (CTX)->vtable.va##DST_PROC = va_compat_##SRC_PROC ++#define INIT_VTABLE(CTX, PROC) \ ++ INIT_VTABLE_(CTX, PROC, PROC) ++ ++ INIT_VTABLE(ctx, Terminate); ++ INIT_VTABLE(ctx, QueryConfigProfiles); ++ INIT_VTABLE(ctx, QueryConfigEntrypoints); ++ INIT_VTABLE(ctx, GetConfigAttributes); ++ INIT_VTABLE(ctx, CreateConfig); ++ INIT_VTABLE(ctx, DestroyConfig); ++ INIT_VTABLE(ctx, QueryConfigAttributes); ++ INIT_VTABLE(ctx, CreateSurfaces); ++ INIT_VTABLE(ctx, DestroySurfaces); ++ INIT_VTABLE(ctx, CreateContext); ++ INIT_VTABLE(ctx, DestroyContext); ++ INIT_VTABLE(ctx, CreateBuffer); ++ INIT_VTABLE(ctx, BufferSetNumElements); ++ INIT_VTABLE(ctx, MapBuffer); ++ INIT_VTABLE(ctx, UnmapBuffer); ++ INIT_VTABLE(ctx, DestroyBuffer); ++ INIT_VTABLE(ctx, BeginPicture); ++ INIT_VTABLE(ctx, RenderPicture); ++ INIT_VTABLE(ctx, EndPicture); ++ INIT_VTABLE(ctx, SyncSurface); ++ INIT_VTABLE(ctx, QuerySurfaceStatus); ++ INIT_VTABLE(ctx, PutSurface); ++ INIT_VTABLE(ctx, QueryImageFormats); ++ INIT_VTABLE(ctx, CreateImage); ++ INIT_VTABLE(ctx, DeriveImage); ++ INIT_VTABLE(ctx, DestroyImage); ++ INIT_VTABLE(ctx, SetImagePalette); ++ INIT_VTABLE(ctx, GetImage); ++ INIT_VTABLE(ctx, PutImage); ++ INIT_VTABLE(ctx, QuerySubpictureFormats); ++ INIT_VTABLE(ctx, CreateSubpicture); ++ INIT_VTABLE(ctx, DestroySubpicture); ++ INIT_VTABLE(ctx, SetSubpictureImage); ++ INIT_VTABLE(ctx, SetSubpictureChromakey); ++ INIT_VTABLE(ctx, SetSubpictureGlobalAlpha); ++ INIT_VTABLE(ctx, AssociateSubpicture); ++ INIT_VTABLE(ctx, DeassociateSubpicture); ++ INIT_VTABLE(ctx, QueryDisplayAttributes); ++ INIT_VTABLE(ctx, GetDisplayAttributes); ++ INIT_VTABLE(ctx, SetDisplayAttributes); ++ INIT_VTABLE(ctx, CreateSurfaceFromCIFrame); ++ INIT_VTABLE(ctx, CreateSurfaceFromV4L2Buf); ++ INIT_VTABLE(ctx, CopySurfaceToBuffer); ++ ++ if (compat_version && compat_version < 31) { ++ INIT_VTABLE_(ctx, CreateContext, CreateContext_pre31); ++ INIT_VTABLE_(ctx, DestroyContext, DestroyContext_pre31); ++ INIT_VTABLE_(ctx, SyncSurface, SyncSurface_pre31); ++ INIT_VTABLE_(ctx, PutImage, PutImage_pre31); ++ INIT_VTABLE_(ctx, AssociateSubpicture, AssociateSubpicture_pre31); ++ } ++ ++#undef INIT_VTABLE ++#undef INIT_VTABLE__ ++} ++ ++VAStatus va_compat_init(VADisplay dpy, int compat_version, void *compat_ctx) ++{ ++ VADisplayContextP pDisplayContext = (VADisplayContextP)dpy; ++ VADriverContextP ctx = CTX(dpy); ++ VADriverContextP_0_29 ctx_0_29; ++ VADriverContextP_0_30 ctx_0_30; ++ VACompatContextP compat; ++ VAStatus status; ++ char *driver_name; ++ ++ ctx->compat = NULL; ++ ++ if (compat_version == 0) ++ return VA_STATUS_SUCCESS; ++ ++ ASSERT(compat_ctx); ++ if (compat_ctx == NULL) ++ return VA_STATUS_ERROR_UNKNOWN; ++ ++ driver_name = NULL; ++ status = pDisplayContext->vaGetDriverName(pDisplayContext, &driver_name); ++ ASSERT(status == VA_STATUS_SUCCESS); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ if ((compat = malloc(sizeof(*compat))) == NULL) ++ return VA_STATUS_ERROR_ALLOCATION_FAILED; ++ compat->buffers = NULL; ++ compat->buffers_count_max = 0; ++ compat->compat_version = compat_version; ++ compat->compat_ctx = NULL; ++ compat->driver_name = driver_name; ++ compat->context_map = NULL; ++ compat->last_context_map_match = NULL; ++ ctx->compat = compat; ++ ++ if (strcmp(driver_name, "psb") == 0) ++ compat->driver_id = VA_DRIVER_ID_POULSBO; ++ else if (strcmp(driver_name, "iegd") == 0) ++ compat->driver_id = VA_DRIVER_ID_IEGD; ++ else ++ compat->driver_id = VA_DRIVER_ID_UNKNOWN; ++ ++ switch (compat_version) { ++ case 29: ++ if ((ctx_0_29 = malloc(sizeof(*ctx_0_29))) == NULL) ++ return VA_STATUS_ERROR_ALLOCATION_FAILED; ++ memcpy(ctx_0_29, compat_ctx, sizeof(*ctx_0_29)); ++ va_compat_translate_VADriverContext_0_29(compat, ctx_0_29); ++ compat->compat_ctx = ctx_0_29; ++ COPY_FIELD(ctx, ctx_0_29, version_major); ++ COPY_FIELD(ctx, ctx_0_29, version_minor); ++ COPY_FIELD(ctx, ctx_0_29, max_profiles); ++ COPY_FIELD(ctx, ctx_0_29, max_entrypoints); ++ COPY_FIELD(ctx, ctx_0_29, max_attributes); ++ COPY_FIELD(ctx, ctx_0_29, max_image_formats); ++ COPY_FIELD(ctx, ctx_0_29, max_subpic_formats); ++ COPY_FIELD(ctx, ctx_0_29, max_display_attributes); ++ COPY_FIELD(ctx, ctx_0_29, str_vendor); ++ break; ++ case 30: ++ if ((ctx_0_30 = malloc(sizeof(*ctx_0_30))) == NULL) ++ return VA_STATUS_ERROR_ALLOCATION_FAILED; ++ memcpy(ctx_0_30, compat_ctx, sizeof(*ctx_0_30)); ++ va_compat_translate_VADriverContext_0_30(compat, ctx_0_30); ++ compat->compat_ctx = ctx_0_30; ++ COPY_FIELD(ctx, ctx_0_30, version_major); ++ COPY_FIELD(ctx, ctx_0_30, version_minor); ++ COPY_FIELD(ctx, ctx_0_30, max_profiles); ++ COPY_FIELD(ctx, ctx_0_30, max_entrypoints); ++ COPY_FIELD(ctx, ctx_0_30, max_attributes); ++ COPY_FIELD(ctx, ctx_0_30, max_image_formats); ++ COPY_FIELD(ctx, ctx_0_30, max_subpic_formats); ++ COPY_FIELD(ctx, ctx_0_30, max_display_attributes); ++ COPY_FIELD(ctx, ctx_0_30, str_vendor); ++ break; ++ case VA_MINOR_VERSION: ++ va_compat_translate_VADriverContext(compat, compat_ctx); ++ compat->compat_ctx = compat_ctx; ++ break; ++ default: ++ ASSERT(compat_version == 0); ++ return VA_STATUS_ERROR_UNKNOWN; ++ } ++ ++ va_compat_init_VADriverVTable(ctx, compat_version); ++ return VA_STATUS_SUCCESS; ++} ++ ++VAStatus va_compat_fini(VADisplay dpy) ++{ ++ VADriverContextP ctx = CTX(dpy); ++ VACompatContextP compat = ctx->compat; ++ int i; ++ ++ if (compat == NULL) ++ return VA_STATUS_SUCCESS; ++ ++ if (compat->driver_name) ++ { ++ free(compat->driver_name); ++ compat->driver_name = NULL; ++ } ++ ++ if (compat->buffers) ++ { ++ for (i = 0; i < compat->buffers_count_max; i++) ++ { ++ if (compat->buffers[i].id) ++ va_DestroyBufferCompat(ctx, compat->buffers[i].id); ++ } ++ free(compat->buffers); ++ compat->buffers = NULL; ++ } ++ ++ if (compat->compat_ctx && compat->compat_version != VA_MINOR_VERSION) ++ { ++ free(compat->compat_ctx); ++ compat->compat_ctx = NULL; ++ } ++ ++ if (compat->context_map) ++ { ++ VAContextMapP d, m = compat->context_map; ++ while (m) { ++ d = m; ++ m = m->next; ++ free(d); ++ } ++ } ++ compat->last_context_map_match = NULL; ++ ++ free(compat); ++ ctx->compat = NULL; ++ return VA_STATUS_SUCCESS; ++} +diff --git a/src/va_compat.h b/src/va_compat.h +new file mode 100644 +index 0000000..2c9d801 +--- /dev/null ++++ b/src/va_compat.h +@@ -0,0 +1,1467 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#ifndef VA_COMPAT_H ++#define VA_COMPAT_H ++ ++VAStatus va_compat_init(VADisplay dpy, int compat_version, void *compat_ctx); ++VAStatus va_compat_fini(VADisplay dpy); ++ ++/* H.264 Picture (0.29) */ ++typedef struct _VAPictureH264_0_29 ++{ ++ VASurfaceID picture_id; ++ unsigned int flags; ++ unsigned int TopFieldOrderCnt; ++ unsigned int BottomFieldOrderCnt; ++} VAPictureH264_0_29; ++ ++/* H.264 Picture Parameter Buffer (0.29) */ ++typedef struct _VAPictureParameterBufferH264_0_29 ++{ ++ VAPictureH264_0_29 CurrPic; ++ VAPictureH264_0_29 ReferenceFrames[16]; /* in DPB */ ++ unsigned short picture_width_in_mbs_minus1; ++ unsigned short picture_height_in_mbs_minus1; ++ unsigned char bit_depth_luma_minus8; ++ unsigned char bit_depth_chroma_minus8; ++ unsigned char num_ref_frames; ++ union { ++ struct { ++ unsigned char chroma_format_idc : 2; ++ unsigned char residual_colour_transform_flag : 1; ++ unsigned char frame_mbs_only_flag : 1; ++ unsigned char mb_adaptive_frame_field_flag : 1; ++ unsigned char direct_8x8_inference_flag : 1; ++ unsigned char MinLumaBiPredSize8x8 : 1; /* see A.3.3.2 */ ++ }; ++ unsigned char seq_fields; ++ }; ++ unsigned char num_slice_groups_minus1; ++ unsigned char slice_group_map_type; ++ signed char pic_init_qp_minus26; ++ signed char chroma_qp_index_offset; ++ signed char second_chroma_qp_index_offset; ++ union { ++ struct { ++ unsigned char entropy_coding_mode_flag : 1; ++ unsigned char weighted_pred_flag : 1; ++ unsigned char weighted_bipred_idc : 2; ++ unsigned char transform_8x8_mode_flag : 1; ++ unsigned char field_pic_flag : 1; ++ unsigned char constrained_intra_pred_flag : 1; ++ }; ++ unsigned char pic_fields; ++ }; ++ unsigned short frame_num; ++} VAPictureParameterBufferH264_0_29; ++ ++/* H.264 Slice Parameter Buffer (0.29) */ ++typedef struct _VASliceParameterBufferH264_0_29 ++{ ++ unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */ ++ unsigned int slice_data_offset;/* the offset to the NAL start code for this slice */ ++ unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */ ++ unsigned short slice_data_bit_offset; /* bit offset from NAL start code to the beginning of slice data */ ++ unsigned short first_mb_in_slice; ++ unsigned char slice_type; ++ unsigned char direct_spatial_mv_pred_flag; ++ unsigned char num_ref_idx_l0_active_minus1; ++ unsigned char num_ref_idx_l1_active_minus1; ++ unsigned char cabac_init_idc; ++ char slice_qp_delta; ++ unsigned char disable_deblocking_filter_idc; ++ char slice_alpha_c0_offset_div2; ++ char slice_beta_offset_div2; ++ VAPictureH264_0_29 RefPicList0[32]; /* See 8.2.4.2 */ ++ VAPictureH264_0_29 RefPicList1[32]; /* See 8.2.4.2 */ ++ unsigned char luma_log2_weight_denom; ++ unsigned char chroma_log2_weight_denom; ++ unsigned char luma_weight_l0_flag; ++ short luma_weight_l0[32]; ++ short luma_offset_l0[32]; ++ unsigned char chroma_weight_l0_flag; ++ short chroma_weight_l0[32][2]; ++ short chroma_offset_l0[32][2]; ++ unsigned char luma_weight_l1_flag; ++ short luma_weight_l1[32]; ++ short luma_offset_l1[32]; ++ unsigned char chroma_weight_l1_flag; ++ short chroma_weight_l1[32][2]; ++ short chroma_offset_l1[32][2]; ++} VASliceParameterBufferH264_0_29; ++ ++/* VC-1 Picture Parameter Buffer (0.29) */ ++typedef struct _VAPictureParameterBufferVC1_0_29 ++{ ++ VASurfaceID forward_reference_picture; ++ VASurfaceID backward_reference_picture; ++ /* if out-of-loop post-processing is done on the render ++ target, then we need to keep the in-loop decoded ++ picture as a reference picture */ ++ VASurfaceID inloop_decoded_picture; ++ ++ /* sequence layer for AP or meta data for SP and MP */ ++ union { ++ struct { ++ unsigned char interlace : 1; /* SEQUENCE_LAYER::INTERLACE */ ++ unsigned char syncmarker : 1;/* METADATA::SYNCMARKER */ ++ unsigned char overlap : 1;/* METADATA::OVERLAP */ ++ }; ++ unsigned char sequence_fields; ++ }; ++ ++ unsigned short coded_width; /* ENTRY_POINT_LAYER::CODED_WIDTH */ ++ unsigned short coded_height; /* ENTRY_POINT_LAYER::CODED_HEIGHT */ ++ unsigned char closed_entry; /* ENTRY_POINT_LAYER::CLOSED_ENTRY */ ++ unsigned char broken_link; /* ENTRY_POINT_LAYER::BROKEN_LINK */ ++ unsigned char loopfilter; /* ENTRY_POINT_LAYER::LOOPFILTER */ ++ unsigned char conditional_overlap_flag; /* ENTRY_POINT_LAYER::CONDOVER */ ++ unsigned char fast_uvmc_flag; /* ENTRY_POINT_LAYER::FASTUVMC */ ++ union { ++ struct { ++ unsigned char range_mapping_luma_flag: 1; /* ENTRY_POINT_LAYER::RANGE_MAPY_FLAG */ ++ unsigned char range_mapping_luma: 3; /* ENTRY_POINT_LAYER::RANGE_MAPY */ ++ unsigned char range_mapping_chroma_flag: 1; /* ENTRY_POINT_LAYER::RANGE_MAPUV_FLAG */ ++ unsigned char range_mapping_chroma: 3; /* ENTRY_POINT_LAYER::RANGE_MAPUV */ ++ }; ++ unsigned char range_mapping_fields; ++ }; ++ ++ unsigned char b_picture_fraction; /* PICTURE_LAYER::BFRACTION */ ++ unsigned char cbp_table; /* PICTURE_LAYER::CBPTAB/ICBPTAB */ ++ unsigned char mb_mode_table; /* PICTURE_LAYER::MBMODETAB */ ++ unsigned char range_reduction_frame;/* PICTURE_LAYER::RANGEREDFRM */ ++ unsigned char rounding_control; /* PICTURE_LAYER::RNDCTRL */ ++ unsigned char post_processing; /* PICTURE_LAYER::POSTPROC */ ++ unsigned char picture_resolution_index; /* PICTURE_LAYER::RESPIC */ ++ unsigned char luma_scale; /* PICTURE_LAYER::LUMSCALE */ ++ unsigned char luma_shift; /* PICTURE_LAYER::LUMSHIFT */ ++ union { ++ struct { ++ unsigned char picture_type : 2; /* PICTURE_LAYER::PTYPE */ ++ unsigned char frame_coding_mode : 3;/* PICTURE_LAYER::FCM */ ++ unsigned char top_field_first : 1;/* PICTURE_LAYER::TFF */ ++ unsigned char is_first_field : 1; /* set to 1 if it is the first field */ ++ unsigned char intensity_compensation: 1;/* PICTURE_LAYER::INTCOMP */ ++ }; ++ unsigned char picture_fields; ++ }; ++ union { ++ struct { ++ unsigned char mv_type_mb : 1; /* PICTURE::MVTYPEMB */ ++ unsigned char direct_mb : 1; /* PICTURE::DIRECTMB */ ++ unsigned char skip_mb : 1; /* PICTURE::SKIPMB */ ++ unsigned char field_tx : 1; /* PICTURE::FIELDTX */ ++ unsigned char forward_mb : 1; /* PICTURE::FORWARDMB */ ++ unsigned char ac_pred : 1; /* PICTURE::ACPRED */ ++ unsigned char overflags : 1; /* PICTURE::OVERFLAGS */ ++ }; ++ unsigned char raw_coding_flag; ++ }; ++ union { ++ struct { ++ unsigned char bp_mv_type_mb : 1; /* PICTURE::MVTYPEMB */ ++ unsigned char bp_direct_mb : 1; /* PICTURE::DIRECTMB */ ++ unsigned char bp_skip_mb : 1; /* PICTURE::SKIPMB */ ++ unsigned char bp_field_tx : 1; /* PICTURE::FIELDTX */ ++ unsigned char bp_forward_mb : 1; /* PICTURE::FORWARDMB */ ++ unsigned char bp_ac_pred : 1; /* PICTURE::ACPRED */ ++ unsigned char bp_overflags : 1; /* PICTURE::OVERFLAGS */ ++ }; ++ unsigned char bitplane_present_flag; /* signal what bitplane is being passed via the bitplane buffer */ ++ }; ++ union { ++ struct { ++ unsigned char reference_distance_flag : 1;/* PICTURE_LAYER::REFDIST_FLAG */ ++ unsigned char reference_distance : 5;/* PICTURE_LAYER::REFDIST */ ++ unsigned char num_reference_pictures: 1;/* PICTURE_LAYER::NUMREF */ ++ unsigned char reference_field_pic_indicator : 1;/* PICTURE_LAYER::REFFIELD */ ++ }; ++ unsigned short reference_fields; ++ }; ++ union { ++ struct { ++ VAMvModeVC1 mv_mode : 3; /* PICTURE_LAYER::MVMODE */ ++ VAMvModeVC1 mv_mode2 : 3; /* PICTURE_LAYER::MVMODE2 */ ++ unsigned char mv_table : 3; /* PICTURE_LAYER::MVTAB/IMVTAB */ ++ unsigned char two_mv_block_pattern_table: 2; /* PICTURE_LAYER::2MVBPTAB */ ++ unsigned char four_mv_switch : 1; /* PICTURE_LAYER::4MVSWITCH */ ++ unsigned char four_mv_block_pattern_table : 2; /* PICTURE_LAYER::4MVBPTAB */ ++ unsigned char extended_mv_flag : 1; /* ENTRY_POINT_LAYER::EXTENDED_MV */ ++ unsigned char extended_mv_range : 2; /* PICTURE_LAYER::MVRANGE */ ++ unsigned char extended_dmv_flag : 1; /* ENTRY_POINT_LAYER::EXTENDED_DMV */ ++ unsigned char extended_dmv_range : 2; /* PICTURE_LAYER::DMVRANGE */ ++ }; ++ unsigned int mv_fields; ++ }; ++ union { ++ struct { ++ unsigned char dquant : 2; /* ENTRY_POINT_LAYER::DQUANT */ ++ unsigned char quantizer : 2; /* ENTRY_POINT_LAYER::QUANTIZER */ ++ unsigned char half_qp : 1; /* PICTURE_LAYER::HALFQP */ ++ unsigned char pic_quantizer_scale : 5;/* PICTURE_LAYER::PQUANT */ ++ unsigned char pic_quantizer_type : 1;/* PICTURE_LAYER::PQUANTIZER */ ++ unsigned char dq_frame : 1; /* VOPDQUANT::DQUANTFRM */ ++ unsigned char dq_profile : 2; /* VOPDQUANT::DQPROFILE */ ++ unsigned char dq_sb_edge : 2; /* VOPDQUANT::DQSBEDGE */ ++ unsigned char dq_db_edge : 2; /* VOPDQUANT::DQDBEDGE */ ++ unsigned char dq_binary_level : 1; /* VOPDQUANT::DQBILEVEL */ ++ unsigned char alt_pic_quantizer : 5;/* VOPDQUANT::ALTPQUANT */ ++ }; ++ unsigned long pic_quantizer_fields; ++ }; ++ union { ++ struct { ++ unsigned char variable_sized_transform_flag : 1;/* ENTRY_POINT_LAYER::VSTRANSFORM */ ++ unsigned char mb_level_transform_type_flag : 1;/* PICTURE_LAYER::TTMBF */ ++ unsigned char frame_level_transform_type : 2;/* PICTURE_LAYER::TTFRM */ ++ unsigned char transform_ac_codingset_idx1 : 2;/* PICTURE_LAYER::TRANSACFRM */ ++ unsigned char transform_ac_codingset_idx2 : 2;/* PICTURE_LAYER::TRANSACFRM2 */ ++ unsigned char intra_transform_dc_table : 1;/* PICTURE_LAYER::TRANSDCTAB */ ++ }; ++ unsigned short transform_fields; ++ }; ++} VAPictureParameterBufferVC1_0_29; ++ ++/* MPEG-2 Picture Parameter Buffer (0.29) */ ++typedef struct _VAPictureParameterBufferMPEG2_0_29 ++{ ++ unsigned short horizontal_size; ++ unsigned short vertical_size; ++ VASurfaceID forward_reference_picture; ++ VASurfaceID backward_reference_picture; ++ /* meanings of the following fields are the same as in the standard */ ++ int picture_coding_type; ++ int f_code; /* pack all four fcode into this */ ++ union { ++ struct { ++ unsigned char intra_dc_precision : 2; ++ unsigned char picture_structure : 2; ++ unsigned char top_field_first : 1; ++ unsigned char frame_pred_frame_dct : 1; ++ unsigned char concealment_motion_vectors : 1; ++ unsigned char q_scale_type : 1; ++ unsigned char intra_vlc_format : 1; ++ unsigned char alternate_scan : 1; ++ unsigned char repeat_first_field : 1; ++ unsigned char progressive_frame : 1; ++ unsigned char is_first_field : 1; /* indicate whether the current field ++ * is the first field for field picture ++ */ ++ }; ++ unsigned int picture_coding_extension; ++ }; ++} VAPictureParameterBufferMPEG2_0_29; ++ ++/* MPEG-2 Slice Parameter Buffer (0.29) */ ++typedef struct _VASliceParameterBufferMPEG2_0_29 ++{ ++ unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */ ++ unsigned int slice_data_offset;/* the offset to the first byte of slice data */ ++ unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */ ++ unsigned int macroblock_offset;/* the offset to the first bit of MB from the first byte of slice data */ ++ unsigned int slice_vertical_position; ++ int quantiser_scale_code; ++ int intra_slice_flag; ++} VASliceParameterBufferMPEG2_0_29; ++ ++/* MPEG-4 Picture Parameter Buffer (0.29) */ ++typedef struct _VAPictureParameterBufferMPEG4_0_29 ++{ ++ unsigned short vop_width; ++ unsigned short vop_height; ++ VASurfaceID forward_reference_picture; ++ VASurfaceID backward_reference_picture; ++ union { ++ struct { ++ unsigned char short_video_header : 1; ++ unsigned char chroma_format : 2; ++ unsigned char interlaced : 1; ++ unsigned char obmc_disable : 1; ++ unsigned char sprite_enable : 2; ++ unsigned char sprite_warping_accuracy : 2; ++ unsigned char quant_type : 1; ++ unsigned char quarter_sample : 1; ++ unsigned char data_partitioned : 1; ++ unsigned char reversible_vlc : 1; ++ }; ++ unsigned short vol_fields; ++ }; ++ unsigned char no_of_sprite_warping_points; ++ short sprite_trajectory_du[3]; ++ short sprite_trajectory_dv[3]; ++ unsigned char quant_precision; ++ union { ++ struct { ++ unsigned char vop_coding_type : 2; ++ unsigned char backward_reference_vop_coding_type : 2; ++ unsigned char vop_rounding_type : 1; ++ unsigned char intra_dc_vlc_thr : 3; ++ unsigned char top_field_first : 1; ++ unsigned char alternate_vertical_scan_flag : 1; ++ }; ++ unsigned short vop_fields; ++ }; ++ unsigned char vop_fcode_forward; ++ unsigned char vop_fcode_backward; ++ /* short header related */ ++ unsigned char num_gobs_in_vop; ++ unsigned char num_macroblocks_in_gob; ++ /* for direct mode prediction */ ++ short TRB; ++ short TRD; ++} VAPictureParameterBufferMPEG4_0_29; ++ ++/* H.264 Picture (0.30) */ ++typedef struct _VAPictureH264_0_30 ++{ ++ VASurfaceID picture_id; ++ unsigned int flags; ++ unsigned int TopFieldOrderCnt; ++ unsigned int BottomFieldOrderCnt; ++} VAPictureH264_0_30; ++ ++/* H.264 Picture Parameter Buffer (0.30) */ ++typedef struct _VAPictureParameterBufferH264_0_30 ++{ ++ VAPictureH264 CurrPic; ++ VAPictureH264 ReferenceFrames[16]; /* in DPB */ ++ unsigned short picture_width_in_mbs_minus1; ++ unsigned short picture_height_in_mbs_minus1; ++ unsigned char bit_depth_luma_minus8; ++ unsigned char bit_depth_chroma_minus8; ++ unsigned char num_ref_frames; ++ union { ++ struct { ++ unsigned char chroma_format_idc : 2; ++ unsigned char residual_colour_transform_flag : 1; ++ unsigned char frame_mbs_only_flag : 1; ++ unsigned char mb_adaptive_frame_field_flag : 1; ++ unsigned char direct_8x8_inference_flag : 1; ++ unsigned char MinLumaBiPredSize8x8 : 1; /* see A.3.3.2 */ ++ } bits; ++ unsigned char value; ++ } seq_fields; ++ unsigned char num_slice_groups_minus1; ++ unsigned char slice_group_map_type; ++ signed char pic_init_qp_minus26; ++ signed char chroma_qp_index_offset; ++ signed char second_chroma_qp_index_offset; ++ union { ++ struct { ++ unsigned char entropy_coding_mode_flag : 1; ++ unsigned char weighted_pred_flag : 1; ++ unsigned char weighted_bipred_idc : 2; ++ unsigned char transform_8x8_mode_flag : 1; ++ unsigned char field_pic_flag : 1; ++ unsigned char constrained_intra_pred_flag : 1; ++ } bits; ++ unsigned char value; ++ } pic_fields; ++ unsigned short frame_num; ++} VAPictureParameterBufferH264_0_30; ++ ++/* H.264 Slice Parameter Buffer (0.30) */ ++typedef struct _VASliceParameterBufferH264_0_30 ++{ ++ unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */ ++ unsigned int slice_data_offset;/* the offset to the NAL start code for this slice */ ++ unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */ ++ unsigned short slice_data_bit_offset; /* bit offset from NAL start code to the beginning of slice data */ ++ unsigned short first_mb_in_slice; ++ unsigned char slice_type; ++ unsigned char direct_spatial_mv_pred_flag; ++ unsigned char num_ref_idx_l0_active_minus1; ++ unsigned char num_ref_idx_l1_active_minus1; ++ unsigned char cabac_init_idc; ++ char slice_qp_delta; ++ unsigned char disable_deblocking_filter_idc; ++ char slice_alpha_c0_offset_div2; ++ char slice_beta_offset_div2; ++ VAPictureH264 RefPicList0[32]; /* See 8.2.4.2 */ ++ VAPictureH264 RefPicList1[32]; /* See 8.2.4.2 */ ++ unsigned char luma_log2_weight_denom; ++ unsigned char chroma_log2_weight_denom; ++ unsigned char luma_weight_l0_flag; ++ short luma_weight_l0[32]; ++ short luma_offset_l0[32]; ++ unsigned char chroma_weight_l0_flag; ++ short chroma_weight_l0[32][2]; ++ short chroma_offset_l0[32][2]; ++ unsigned char luma_weight_l1_flag; ++ short luma_weight_l1[32]; ++ short luma_offset_l1[32]; ++ unsigned char chroma_weight_l1_flag; ++ short chroma_weight_l1[32][2]; ++ short chroma_offset_l1[32][2]; ++} VASliceParameterBufferH264_0_30; ++ ++/* VC-1 Picture Parameter Buffer (0.30) */ ++typedef struct _VAPictureParameterBufferVC1_0_30 ++{ ++ VASurfaceID forward_reference_picture; ++ VASurfaceID backward_reference_picture; ++ /* if out-of-loop post-processing is done on the render ++ target, then we need to keep the in-loop decoded ++ picture as a reference picture */ ++ VASurfaceID inloop_decoded_picture; ++ ++ /* sequence layer for AP or meta data for SP and MP */ ++ union { ++ struct { ++ unsigned char interlace : 1; /* SEQUENCE_LAYER::INTERLACE */ ++ unsigned char syncmarker : 1;/* METADATA::SYNCMARKER */ ++ unsigned char overlap : 1;/* METADATA::OVERLAP */ ++ } bits; ++ unsigned char value; ++ } sequence_fields; ++ ++ unsigned short coded_width; /* ENTRY_POINT_LAYER::CODED_WIDTH */ ++ unsigned short coded_height; /* ENTRY_POINT_LAYER::CODED_HEIGHT */ ++ unsigned char closed_entry; /* ENTRY_POINT_LAYER::CLOSED_ENTRY */ ++ unsigned char broken_link; /* ENTRY_POINT_LAYER::BROKEN_LINK */ ++ unsigned char loopfilter; /* ENTRY_POINT_LAYER::LOOPFILTER */ ++ unsigned char conditional_overlap_flag; /* ENTRY_POINT_LAYER::CONDOVER */ ++ unsigned char fast_uvmc_flag; /* ENTRY_POINT_LAYER::FASTUVMC */ ++ union { ++ struct { ++ unsigned char luma_flag : 1; /* ENTRY_POINT_LAYER::RANGE_MAPY_FLAG */ ++ unsigned char luma : 3; /* ENTRY_POINT_LAYER::RANGE_MAPY */ ++ unsigned char chroma_flag : 1; /* ENTRY_POINT_LAYER::RANGE_MAPUV_FLAG */ ++ unsigned char chroma : 3; /* ENTRY_POINT_LAYER::RANGE_MAPUV */ ++ } bits; ++ unsigned char value; ++ } range_mapping_fields; ++ ++ unsigned char b_picture_fraction; /* PICTURE_LAYER::BFRACTION */ ++ unsigned char cbp_table; /* PICTURE_LAYER::CBPTAB/ICBPTAB */ ++ unsigned char mb_mode_table; /* PICTURE_LAYER::MBMODETAB */ ++ unsigned char range_reduction_frame;/* PICTURE_LAYER::RANGEREDFRM */ ++ unsigned char rounding_control; /* PICTURE_LAYER::RNDCTRL */ ++ unsigned char post_processing; /* PICTURE_LAYER::POSTPROC */ ++ unsigned char picture_resolution_index; /* PICTURE_LAYER::RESPIC */ ++ unsigned char luma_scale; /* PICTURE_LAYER::LUMSCALE */ ++ unsigned char luma_shift; /* PICTURE_LAYER::LUMSHIFT */ ++ union { ++ struct { ++ unsigned char picture_type : 2; /* PICTURE_LAYER::PTYPE */ ++ unsigned char frame_coding_mode : 3; /* PICTURE_LAYER::FCM */ ++ unsigned char top_field_first : 1; /* PICTURE_LAYER::TFF */ ++ unsigned char is_first_field : 1; /* set to 1 if it is the first field */ ++ unsigned char intensity_compensation : 1; /* PICTURE_LAYER::INTCOMP */ ++ } bits; ++ unsigned char value; ++ } picture_fields; ++ union { ++ struct { ++ unsigned char mv_type_mb : 1; /* PICTURE::MVTYPEMB */ ++ unsigned char direct_mb : 1; /* PICTURE::DIRECTMB */ ++ unsigned char skip_mb : 1; /* PICTURE::SKIPMB */ ++ unsigned char field_tx : 1; /* PICTURE::FIELDTX */ ++ unsigned char forward_mb : 1; /* PICTURE::FORWARDMB */ ++ unsigned char ac_pred : 1; /* PICTURE::ACPRED */ ++ unsigned char overflags : 1; /* PICTURE::OVERFLAGS */ ++ } flags; ++ unsigned char value; ++ } raw_coding; ++ union { ++ struct { ++ unsigned char bp_mv_type_mb : 1; /* PICTURE::MVTYPEMB */ ++ unsigned char bp_direct_mb : 1; /* PICTURE::DIRECTMB */ ++ unsigned char bp_skip_mb : 1; /* PICTURE::SKIPMB */ ++ unsigned char bp_field_tx : 1; /* PICTURE::FIELDTX */ ++ unsigned char bp_forward_mb : 1; /* PICTURE::FORWARDMB */ ++ unsigned char bp_ac_pred : 1; /* PICTURE::ACPRED */ ++ unsigned char bp_overflags : 1; /* PICTURE::OVERFLAGS */ ++ } flags; ++ unsigned char value; ++ } bitplane_present; /* signal what bitplane is being passed via the bitplane buffer */ ++ union { ++ struct { ++ unsigned char reference_distance_flag : 1;/* PICTURE_LAYER::REFDIST_FLAG */ ++ unsigned char reference_distance : 5;/* PICTURE_LAYER::REFDIST */ ++ unsigned char num_reference_pictures: 1;/* PICTURE_LAYER::NUMREF */ ++ unsigned char reference_field_pic_indicator : 1;/* PICTURE_LAYER::REFFIELD */ ++ } bits; ++ unsigned short value; ++ } reference_fields; ++ union { ++ struct { ++ unsigned char mv_mode : 3; /* PICTURE_LAYER::MVMODE */ ++ unsigned char mv_mode2 : 3; /* PICTURE_LAYER::MVMODE2 */ ++ unsigned char mv_table : 3; /* PICTURE_LAYER::MVTAB/IMVTAB */ ++ unsigned char two_mv_block_pattern_table: 2; /* PICTURE_LAYER::2MVBPTAB */ ++ unsigned char four_mv_switch : 1; /* PICTURE_LAYER::4MVSWITCH */ ++ unsigned char four_mv_block_pattern_table : 2; /* PICTURE_LAYER::4MVBPTAB */ ++ unsigned char extended_mv_flag : 1; /* ENTRY_POINT_LAYER::EXTENDED_MV */ ++ unsigned char extended_mv_range : 2; /* PICTURE_LAYER::MVRANGE */ ++ unsigned char extended_dmv_flag : 1; /* ENTRY_POCHAR_LAYER::EXTENDED_DMV */ ++ unsigned char extended_dmv_range : 2; /* PICTURE_LAYER::DMVRANGE */ ++ } bits; ++ unsigned int value; ++ } mv_fields; ++ union { ++ struct { ++ unsigned char dquant : 2; /* ENTRY_POINT_LAYER::DQUANT */ ++ unsigned char quantizer : 2; /* ENTRY_POINT_LAYER::QUANTIZER */ ++ unsigned char half_qp : 1; /* PICTURE_LAYER::HALFQP */ ++ unsigned char pic_quantizer_scale : 5;/* PICTURE_LAYER::PQUANT */ ++ unsigned char pic_quantizer_type : 1;/* PICTURE_LAYER::PQUANTIZER */ ++ unsigned char dq_frame : 1; /* VOPDQUANT::DQUANTFRM */ ++ unsigned char dq_profile : 2; /* VOPDQUANT::DQPROFILE */ ++ unsigned char dq_sb_edge : 2; /* VOPDQUANT::DQSBEDGE */ ++ unsigned char dq_db_edge : 2; /* VOPDQUANT::DQDBEDGE */ ++ unsigned char dq_binary_level : 1; /* VOPDQUANT::DQBILEVEL */ ++ unsigned char alt_pic_quantizer : 5;/* VOPDQUANT::ALTPQUANT */ ++ } bits; ++ unsigned long value; ++ } pic_quantizer_fields; ++ union { ++ struct { ++ unsigned char variable_sized_transform_flag : 1;/* ENTRY_POINT_LAYER::VSTRANSFORM */ ++ unsigned char mb_level_transform_type_flag : 1;/* PICTURE_LAYER::TTMBF */ ++ unsigned char frame_level_transform_type : 2;/* PICTURE_LAYER::TTFRM */ ++ unsigned char transform_ac_codingset_idx1 : 2;/* PICTURE_LAYER::TRANSACFRM */ ++ unsigned char transform_ac_codingset_idx2 : 2;/* PICTURE_LAYER::TRANSACFRM2 */ ++ unsigned char intra_transform_dc_table : 1;/* PICTURE_LAYER::TRANSDCTAB */ ++ } bits; ++ unsigned short value; ++ } transform_fields; ++} VAPictureParameterBufferVC1_0_30; ++ ++/* MPEG-2 Picture Parameter Buffer (0.30) */ ++typedef struct _VAPictureParameterBufferMPEG2_0_30 ++{ ++ unsigned short horizontal_size; ++ unsigned short vertical_size; ++ VASurfaceID forward_reference_picture; ++ VASurfaceID backward_reference_picture; ++ /* meanings of the following fields are the same as in the standard */ ++ int picture_coding_type; ++ int f_code; /* pack all four fcode into this */ ++ union { ++ struct { ++ unsigned int intra_dc_precision : 2; ++ unsigned int picture_structure : 2; ++ unsigned int top_field_first : 1; ++ unsigned int frame_pred_frame_dct : 1; ++ unsigned int concealment_motion_vectors : 1; ++ unsigned int q_scale_type : 1; ++ unsigned int intra_vlc_format : 1; ++ unsigned int alternate_scan : 1; ++ unsigned int repeat_first_field : 1; ++ unsigned int progressive_frame : 1; ++ unsigned int is_first_field : 1; /* indicate whether the current field ++ * is the first field for field picture ++ */ ++ } bits; ++ unsigned int value; ++ } picture_coding_extension; ++} VAPictureParameterBufferMPEG2_0_30; ++ ++/* MPEG-2 Slice Parameter Buffer (0.29) */ ++typedef VASliceParameterBufferMPEG2_0_29 VASliceParameterBufferMPEG2_0_30; ++ ++/* MPEG-4 Picture Parameter Buffer (0.30) */ ++typedef struct _VAPictureParameterBufferMPEG4_0_30 ++{ ++ unsigned short vop_width; ++ unsigned short vop_height; ++ VASurfaceID forward_reference_picture; ++ VASurfaceID backward_reference_picture; ++ union { ++ struct { ++ unsigned char short_video_header : 1; ++ unsigned char chroma_format : 2; ++ unsigned char interlaced : 1; ++ unsigned char obmc_disable : 1; ++ unsigned char sprite_enable : 2; ++ unsigned char sprite_warping_accuracy : 2; ++ unsigned char quant_type : 1; ++ unsigned char quarter_sample : 1; ++ unsigned char data_partitioned : 1; ++ unsigned char reversible_vlc : 1; ++ } bits; ++ unsigned short value; ++ } vol_fields; ++ unsigned char no_of_sprite_warping_points; ++ short sprite_trajectory_du[3]; ++ short sprite_trajectory_dv[3]; ++ unsigned char quant_precision; ++ union { ++ struct { ++ unsigned char vop_coding_type : 2; ++ unsigned char backward_reference_vop_coding_type : 2; ++ unsigned char vop_rounding_type : 1; ++ unsigned char intra_dc_vlc_thr : 3; ++ unsigned char top_field_first : 1; ++ unsigned char alternate_vertical_scan_flag : 1; ++ } bits; ++ unsigned short value; ++ } vop_fields; ++ unsigned char vop_fcode_forward; ++ unsigned char vop_fcode_backward; ++ /* short header related */ ++ unsigned char num_gobs_in_vop; ++ unsigned char num_macroblocks_in_gob; ++ /* for direct mode prediction */ ++ short TRB; ++ short TRD; ++} VAPictureParameterBufferMPEG4_0_30; ++ ++/* Encode Slice Parameter Buffer (0.30) */ ++typedef struct _VAEncSliceParameterBuffer_0_30 ++{ ++ unsigned int start_row_number; /* starting MB row number for this slice */ ++ unsigned int slice_height; /* slice height measured in MB */ ++ union { ++ struct { ++ unsigned char is_intra : 1; ++ unsigned char disable_deblocking_filter_idc : 2; ++ } bits; ++ unsigned char value; ++ } slice_flags; ++} VAEncSliceParameterBuffer_0_30; ++ ++/* MPEG-4 Picture Parameter Buffer (0.31) */ ++typedef struct _VAPictureParameterBufferMPEG4_0_31 ++{ ++ unsigned short vop_width; ++ unsigned short vop_height; ++ VASurfaceID forward_reference_picture; ++ VASurfaceID backward_reference_picture; ++ union { ++ struct { ++ unsigned int short_video_header : 1; ++ unsigned int chroma_format : 2; ++ unsigned int interlaced : 1; ++ unsigned int obmc_disable : 1; ++ unsigned int sprite_enable : 2; ++ unsigned int sprite_warping_accuracy : 2; ++ unsigned int quant_type : 1; ++ unsigned int quarter_sample : 1; ++ unsigned int data_partitioned : 1; ++ unsigned int reversible_vlc : 1; ++ } bits; ++ unsigned int value; ++ } vol_fields; ++ unsigned char no_of_sprite_warping_points; ++ short sprite_trajectory_du[3]; ++ short sprite_trajectory_dv[3]; ++ unsigned char quant_precision; ++ union { ++ struct { ++ unsigned int vop_coding_type : 2; ++ unsigned int backward_reference_vop_coding_type : 2; ++ unsigned int vop_rounding_type : 1; ++ unsigned int intra_dc_vlc_thr : 3; ++ unsigned int top_field_first : 1; ++ unsigned int alternate_vertical_scan_flag : 1; ++ } bits; ++ unsigned int value; ++ } vop_fields; ++ unsigned char vop_fcode_forward; ++ unsigned char vop_fcode_backward; ++ /* short header related */ ++ unsigned char num_gobs_in_vop; ++ unsigned char num_macroblocks_in_gob; ++ /* for direct mode prediction */ ++ short TRB; ++ short TRD; ++} VAPictureParameterBufferMPEG4_0_31; ++ ++typedef struct VADriverContext_0_29 *VADriverContextP_0_29; ++ ++/* Driver VTable (0.29) */ ++struct VADriverVTable_0_29 ++{ ++ VAStatus (*vaTerminate) ( VADriverContextP_0_29 ctx ); ++ ++ VAStatus (*vaQueryConfigProfiles) ( ++ VADriverContextP_0_29 ctx, ++ VAProfile *profile_list, /* out */ ++ int *num_profiles /* out */ ++ ); ++ ++ VAStatus (*vaQueryConfigEntrypoints) ( ++ VADriverContextP_0_29 ctx, ++ VAProfile profile, ++ VAEntrypoint *entrypoint_list, /* out */ ++ int *num_entrypoints /* out */ ++ ); ++ ++ VAStatus (*vaGetConfigAttributes) ( ++ VADriverContextP_0_29 ctx, ++ VAProfile profile, ++ VAEntrypoint entrypoint, ++ VAConfigAttrib *attrib_list, /* in/out */ ++ int num_attribs ++ ); ++ ++ VAStatus (*vaCreateConfig) ( ++ VADriverContextP_0_29 ctx, ++ VAProfile profile, ++ VAEntrypoint entrypoint, ++ VAConfigAttrib *attrib_list, ++ int num_attribs, ++ VAConfigID *config_id /* out */ ++ ); ++ ++ VAStatus (*vaDestroyConfig) ( ++ VADriverContextP_0_29 ctx, ++ VAConfigID config_id ++ ); ++ ++ VAStatus (*vaQueryConfigAttributes) ( ++ VADriverContextP_0_29 ctx, ++ VAConfigID config_id, ++ VAProfile *profile, /* out */ ++ VAEntrypoint *entrypoint, /* out */ ++ VAConfigAttrib *attrib_list, /* out */ ++ int *num_attribs /* out */ ++ ); ++ ++ VAStatus (*vaCreateSurfaces) ( ++ VADriverContextP_0_29 ctx, ++ int width, ++ int height, ++ int format, ++ int num_surfaces, ++ VASurfaceID *surfaces /* out */ ++ ); ++ ++ VAStatus (*vaDestroySurfaces) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID *surface_list, ++ int num_surfaces ++ ); ++ ++ VAStatus (*vaCreateContext) ( ++ VADriverContextP_0_29 ctx, ++ VAConfigID config_id, ++ int picture_width, ++ int picture_height, ++ int flag, ++ VASurfaceID *render_targets, ++ int num_render_targets, ++ VAContextID *context /* out */ ++ ); ++ ++ VAStatus (*vaDestroyContext) ( ++ VADriverContextP_0_29 ctx, ++ VAContextID context ++ ); ++ ++ VAStatus (*vaCreateBuffer) ( ++ VADriverContextP_0_29 ctx, ++ VAContextID context, /* in */ ++ VABufferType type, /* in */ ++ unsigned int size, /* in */ ++ unsigned int num_elements, /* in */ ++ void *data, /* in */ ++ VABufferID *buf_id /* out */ ++ ); ++ ++ VAStatus (*vaBufferSetNumElements) ( ++ VADriverContextP_0_29 ctx, ++ VABufferID buf_id, /* in */ ++ unsigned int num_elements /* in */ ++ ); ++ ++ VAStatus (*vaMapBuffer) ( ++ VADriverContextP_0_29 ctx, ++ VABufferID buf_id, /* in */ ++ void **pbuf /* out */ ++ ); ++ ++ VAStatus (*vaUnmapBuffer) ( ++ VADriverContextP_0_29 ctx, ++ VABufferID buf_id /* in */ ++ ); ++ ++ VAStatus (*vaDestroyBuffer) ( ++ VADriverContextP_0_29 ctx, ++ VABufferID buffer_id ++ ); ++ ++ VAStatus (*vaBeginPicture) ( ++ VADriverContextP_0_29 ctx, ++ VAContextID context, ++ VASurfaceID render_target ++ ); ++ ++ VAStatus (*vaRenderPicture) ( ++ VADriverContextP_0_29 ctx, ++ VAContextID context, ++ VABufferID *buffers, ++ int num_buffers ++ ); ++ ++ VAStatus (*vaEndPicture) ( ++ VADriverContextP_0_29 ctx, ++ VAContextID context ++ ); ++ ++ VAStatus (*vaSyncSurface) ( ++ VADriverContextP_0_29 ctx, ++ VAContextID context, ++ VASurfaceID render_target ++ ); ++ ++ VAStatus (*vaQuerySurfaceStatus) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID render_target, ++ VASurfaceStatus *status /* out */ ++ ); ++ ++ VAStatus (*vaPutSurface) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID surface, ++ unsigned long draw, /* X Drawable */ ++ short srcx, ++ short srcy, ++ unsigned short srcw, ++ unsigned short srch, ++ short destx, ++ short desty, ++ unsigned short destw, ++ unsigned short desth, ++ VARectangle *cliprects, /* client supplied clip list */ ++ unsigned int number_cliprects, /* number of clip rects in the clip list */ ++ unsigned int flags /* de-interlacing flags */ ++ ); ++ ++ VAStatus (*vaQueryImageFormats) ( ++ VADriverContextP_0_29 ctx, ++ VAImageFormat *format_list, /* out */ ++ int *num_formats /* out */ ++ ); ++ ++ VAStatus (*vaCreateImage) ( ++ VADriverContextP_0_29 ctx, ++ VAImageFormat *format, ++ int width, ++ int height, ++ VAImage *image /* out */ ++ ); ++ ++ VAStatus (*vaDeriveImage) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID surface, ++ VAImage *image /* out */ ++ ); ++ ++ VAStatus (*vaDestroyImage) ( ++ VADriverContextP_0_29 ctx, ++ VAImageID image ++ ); ++ ++ VAStatus (*vaSetImagePalette) ( ++ VADriverContextP_0_29 ctx, ++ VAImageID image, ++ /* ++ * pointer to an array holding the palette data. The size of the array is ++ * num_palette_entries * entry_bytes in size. The order of the components ++ * in the palette is described by the component_order in VAImage struct ++ */ ++ unsigned char *palette ++ ); ++ ++ VAStatus (*vaGetImage) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID surface, ++ int x, /* coordinates of the upper left source pixel */ ++ int y, ++ unsigned int width, /* width and height of the region */ ++ unsigned int height, ++ VAImageID image ++ ); ++ ++ VAStatus (*vaPutImage) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID surface, ++ VAImageID image, ++ int src_x, ++ int src_y, ++ unsigned int width, ++ unsigned int height, ++ int dest_x, ++ int dest_y ++ ); ++ ++ VAStatus (*vaPutImage2) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID surface, ++ VAImageID image, ++ int src_x, ++ int src_y, ++ unsigned int src_width, ++ unsigned int src_height, ++ int dest_x, ++ int dest_y, ++ unsigned int dest_width, ++ unsigned int dest_height ++ ); ++ ++ VAStatus (*vaQuerySubpictureFormats) ( ++ VADriverContextP_0_29 ctx, ++ VAImageFormat *format_list, /* out */ ++ unsigned int *flags, /* out */ ++ unsigned int *num_formats /* out */ ++ ); ++ ++ VAStatus (*vaCreateSubpicture) ( ++ VADriverContextP_0_29 ctx, ++ VAImageID image, ++ VASubpictureID *subpicture /* out */ ++ ); ++ ++ VAStatus (*vaDestroySubpicture) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture ++ ); ++ ++ VAStatus (*vaSetSubpictureImage) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture, ++ VAImageID image ++ ); ++ ++ VAStatus (*vaSetSubpicturePalette) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture, ++ /* ++ * pointer to an array holding the palette data. The size of the array is ++ * num_palette_entries * entry_bytes in size. The order of the components ++ * in the palette is described by the component_order in VASubpicture struct ++ */ ++ unsigned char *palette ++ ); ++ ++ VAStatus (*vaSetSubpictureChromakey) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture, ++ unsigned int chromakey_min, ++ unsigned int chromakey_max, ++ unsigned int chromakey_mask ++ ); ++ ++ VAStatus (*vaSetSubpictureGlobalAlpha) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture, ++ float global_alpha ++ ); ++ ++ VAStatus (*vaAssociateSubpicture) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces, ++ short src_x, /* upper left offset in subpicture */ ++ short src_y, ++ short dest_x, /* upper left offset in surface */ ++ short dest_y, ++ unsigned short width, ++ unsigned short height, ++ /* ++ * whether to enable chroma-keying or global-alpha ++ * see VA_SUBPICTURE_XXX values ++ */ ++ unsigned int flags ++ ); ++ ++ VAStatus (*vaAssociateSubpicture2) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces, ++ short src_x, /* upper left offset in subpicture */ ++ short src_y, ++ unsigned short src_width, ++ unsigned short src_height, ++ short dest_x, /* upper left offset in surface */ ++ short dest_y, ++ unsigned short dest_width, ++ unsigned short dest_height, ++ /* ++ * whether to enable chroma-keying or global-alpha ++ * see VA_SUBPICTURE_XXX values ++ */ ++ unsigned int flags ++ ); ++ ++ VAStatus (*vaDeassociateSubpicture) ( ++ VADriverContextP_0_29 ctx, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces ++ ); ++ ++ VAStatus (*vaQueryDisplayAttributes) ( ++ VADriverContextP_0_29 ctx, ++ VADisplayAttribute *attr_list, /* out */ ++ int *num_attributes /* out */ ++ ); ++ ++ VAStatus (*vaGetDisplayAttributes) ( ++ VADriverContextP_0_29 ctx, ++ VADisplayAttribute *attr_list, /* in/out */ ++ int num_attributes ++ ); ++ ++ VAStatus (*vaSetDisplayAttributes) ( ++ VADriverContextP_0_29 ctx, ++ VADisplayAttribute *attr_list, ++ int num_attributes ++ ); ++ ++ ++ VAStatus (*vaDbgCopySurfaceToBuffer) ( ++ VADriverContextP_0_29 ctx, ++ VASurfaceID surface, ++ void **buffer, /* out */ ++ unsigned int *stride /* out */ ++ ); ++}; ++ ++/* Driver context (0.29) */ ++struct VADriverContext_0_29 ++{ ++ void *old_pNext; /* preserved for binary compatibility */ ++ ++ void *pDriverData; ++ struct VADriverVTable_0_29 vtable; ++ ++ void *x11_dpy; ++ int x11_screen; ++ ++ int version_major; ++ int version_minor; ++ int max_profiles; ++ int max_entrypoints; ++ int max_attributes; ++ int max_image_formats; ++ int max_subpic_formats; ++ int max_display_attributes; ++ const char *str_vendor; ++ ++ void *handle; /* dlopen handle */ ++}; ++ ++/* Forward declarations for VA API 0.30 */ ++struct v4l2_format; ++struct v4l2_buffer; ++typedef struct VADriverContext_0_30 *VADriverContextP_0_30; ++ ++/* Driver VTable (0.30) */ ++struct VADriverVTable_0_30 ++{ ++ VAStatus (*vaTerminate) ( VADriverContextP_0_30 ctx ); ++ ++ VAStatus (*vaQueryConfigProfiles) ( ++ VADriverContextP_0_30 ctx, ++ VAProfile *profile_list, /* out */ ++ int *num_profiles /* out */ ++ ); ++ ++ VAStatus (*vaQueryConfigEntrypoints) ( ++ VADriverContextP_0_30 ctx, ++ VAProfile profile, ++ VAEntrypoint *entrypoint_list, /* out */ ++ int *num_entrypoints /* out */ ++ ); ++ ++ VAStatus (*vaGetConfigAttributes) ( ++ VADriverContextP_0_30 ctx, ++ VAProfile profile, ++ VAEntrypoint entrypoint, ++ VAConfigAttrib *attrib_list, /* in/out */ ++ int num_attribs ++ ); ++ ++ VAStatus (*vaCreateConfig) ( ++ VADriverContextP_0_30 ctx, ++ VAProfile profile, ++ VAEntrypoint entrypoint, ++ VAConfigAttrib *attrib_list, ++ int num_attribs, ++ VAConfigID *config_id /* out */ ++ ); ++ ++ VAStatus (*vaDestroyConfig) ( ++ VADriverContextP_0_30 ctx, ++ VAConfigID config_id ++ ); ++ ++ VAStatus (*vaQueryConfigAttributes) ( ++ VADriverContextP_0_30 ctx, ++ VAConfigID config_id, ++ VAProfile *profile, /* out */ ++ VAEntrypoint *entrypoint, /* out */ ++ VAConfigAttrib *attrib_list, /* out */ ++ int *num_attribs /* out */ ++ ); ++ ++ VAStatus (*vaCreateSurfaces) ( ++ VADriverContextP_0_30 ctx, ++ int width, ++ int height, ++ int format, ++ int num_surfaces, ++ VASurfaceID *surfaces /* out */ ++ ); ++ ++ VAStatus (*vaDestroySurfaces) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID *surface_list, ++ int num_surfaces ++ ); ++ ++ VAStatus (*vaCreateContext) ( ++ VADriverContextP_0_30 ctx, ++ VAConfigID config_id, ++ int picture_width, ++ int picture_height, ++ int flag, ++ VASurfaceID *render_targets, ++ int num_render_targets, ++ VAContextID *context /* out */ ++ ); ++ ++ VAStatus (*vaDestroyContext) ( ++ VADriverContextP_0_30 ctx, ++ VAContextID context ++ ); ++ ++ VAStatus (*vaCreateBuffer) ( ++ VADriverContextP_0_30 ctx, ++ VAContextID context, /* in */ ++ VABufferType type, /* in */ ++ unsigned int size, /* in */ ++ unsigned int num_elements, /* in */ ++ void *data, /* in */ ++ VABufferID *buf_id /* out */ ++ ); ++ ++ VAStatus (*vaBufferSetNumElements) ( ++ VADriverContextP_0_30 ctx, ++ VABufferID buf_id, /* in */ ++ unsigned int num_elements /* in */ ++ ); ++ ++ VAStatus (*vaMapBuffer) ( ++ VADriverContextP_0_30 ctx, ++ VABufferID buf_id, /* in */ ++ void **pbuf /* out */ ++ ); ++ ++ VAStatus (*vaUnmapBuffer) ( ++ VADriverContextP_0_30 ctx, ++ VABufferID buf_id /* in */ ++ ); ++ ++ VAStatus (*vaDestroyBuffer) ( ++ VADriverContextP_0_30 ctx, ++ VABufferID buffer_id ++ ); ++ ++ VAStatus (*vaBeginPicture) ( ++ VADriverContextP_0_30 ctx, ++ VAContextID context, ++ VASurfaceID render_target ++ ); ++ ++ VAStatus (*vaRenderPicture) ( ++ VADriverContextP_0_30 ctx, ++ VAContextID context, ++ VABufferID *buffers, ++ int num_buffers ++ ); ++ ++ VAStatus (*vaEndPicture) ( ++ VADriverContextP_0_30 ctx, ++ VAContextID context ++ ); ++ ++ VAStatus (*vaSyncSurface) ( ++ VADriverContextP_0_30 ctx, ++ VAContextID context, ++ VASurfaceID render_target ++ ); ++ ++ VAStatus (*vaQuerySurfaceStatus) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID render_target, ++ VASurfaceStatus *status /* out */ ++ ); ++ ++ VAStatus (*vaPutSurface) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID surface, ++ unsigned long draw, /* X Drawable */ ++ short srcx, ++ short srcy, ++ unsigned short srcw, ++ unsigned short srch, ++ short destx, ++ short desty, ++ unsigned short destw, ++ unsigned short desth, ++ VARectangle *cliprects, /* client supplied clip list */ ++ unsigned int number_cliprects, /* number of clip rects in the clip list */ ++ unsigned int flags /* de-interlacing flags */ ++ ); ++ ++ VAStatus (*vaQueryImageFormats) ( ++ VADriverContextP_0_30 ctx, ++ VAImageFormat *format_list, /* out */ ++ int *num_formats /* out */ ++ ); ++ ++ VAStatus (*vaCreateImage) ( ++ VADriverContextP_0_30 ctx, ++ VAImageFormat *format, ++ int width, ++ int height, ++ VAImage *image /* out */ ++ ); ++ ++ VAStatus (*vaDeriveImage) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID surface, ++ VAImage *image /* out */ ++ ); ++ ++ VAStatus (*vaDestroyImage) ( ++ VADriverContextP_0_30 ctx, ++ VAImageID image ++ ); ++ ++ VAStatus (*vaSetImagePalette) ( ++ VADriverContextP_0_30 ctx, ++ VAImageID image, ++ /* ++ * pointer to an array holding the palette data. The size of the array is ++ * num_palette_entries * entry_bytes in size. The order of the components ++ * in the palette is described by the component_order in VAImage struct ++ */ ++ unsigned char *palette ++ ); ++ ++ VAStatus (*vaGetImage) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID surface, ++ int x, /* coordinates of the upper left source pixel */ ++ int y, ++ unsigned int width, /* width and height of the region */ ++ unsigned int height, ++ VAImageID image ++ ); ++ ++ VAStatus (*vaPutImage) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID surface, ++ VAImageID image, ++ int src_x, ++ int src_y, ++ unsigned int width, ++ unsigned int height, ++ int dest_x, ++ int dest_y ++ ); ++ ++ VAStatus (*vaPutImage2) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID surface, ++ VAImageID image, ++ int src_x, ++ int src_y, ++ unsigned int src_width, ++ unsigned int src_height, ++ int dest_x, ++ int dest_y, ++ unsigned int dest_width, ++ unsigned int dest_height ++ ); ++ ++ VAStatus (*vaQuerySubpictureFormats) ( ++ VADriverContextP_0_30 ctx, ++ VAImageFormat *format_list, /* out */ ++ unsigned int *flags, /* out */ ++ unsigned int *num_formats /* out */ ++ ); ++ ++ VAStatus (*vaCreateSubpicture) ( ++ VADriverContextP_0_30 ctx, ++ VAImageID image, ++ VASubpictureID *subpicture /* out */ ++ ); ++ ++ VAStatus (*vaDestroySubpicture) ( ++ VADriverContextP_0_30 ctx, ++ VASubpictureID subpicture ++ ); ++ ++ VAStatus (*vaSetSubpictureImage) ( ++ VADriverContextP_0_30 ctx, ++ VASubpictureID subpicture, ++ VAImageID image ++ ); ++ ++ VAStatus (*vaSetSubpictureChromakey) ( ++ VADriverContextP_0_30 ctx, ++ VASubpictureID subpicture, ++ unsigned int chromakey_min, ++ unsigned int chromakey_max, ++ unsigned int chromakey_mask ++ ); ++ ++ VAStatus (*vaSetSubpictureGlobalAlpha) ( ++ VADriverContextP_0_30 ctx, ++ VASubpictureID subpicture, ++ float global_alpha ++ ); ++ ++ VAStatus (*vaAssociateSubpicture) ( ++ VADriverContextP_0_30 ctx, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces, ++ short src_x, /* upper left offset in subpicture */ ++ short src_y, ++ short dest_x, /* upper left offset in surface */ ++ short dest_y, ++ unsigned short width, ++ unsigned short height, ++ /* ++ * whether to enable chroma-keying or global-alpha ++ * see VA_SUBPICTURE_XXX values ++ */ ++ unsigned int flags ++ ); ++ ++ VAStatus (*vaAssociateSubpicture2) ( ++ VADriverContextP_0_30 ctx, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces, ++ short src_x, /* upper left offset in subpicture */ ++ short src_y, ++ unsigned short src_width, ++ unsigned short src_height, ++ short dest_x, /* upper left offset in surface */ ++ short dest_y, ++ unsigned short dest_width, ++ unsigned short dest_height, ++ /* ++ * whether to enable chroma-keying or global-alpha ++ * see VA_SUBPICTURE_XXX values ++ */ ++ unsigned int flags ++ ); ++ ++ VAStatus (*vaDeassociateSubpicture) ( ++ VADriverContextP_0_30 ctx, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces ++ ); ++ ++ VAStatus (*vaQueryDisplayAttributes) ( ++ VADriverContextP_0_30 ctx, ++ VADisplayAttribute *attr_list, /* out */ ++ int *num_attributes /* out */ ++ ); ++ ++ VAStatus (*vaGetDisplayAttributes) ( ++ VADriverContextP_0_30 ctx, ++ VADisplayAttribute *attr_list, /* in/out */ ++ int num_attributes ++ ); ++ ++ VAStatus (*vaSetDisplayAttributes) ( ++ VADriverContextP_0_30 ctx, ++ VADisplayAttribute *attr_list, ++ int num_attributes ++ ); ++ ++ /* device specific */ ++ VAStatus (*vaCreateSurfaceFromCIFrame) ( ++ VADriverContextP_0_30 ctx, ++ unsigned long frame_id, ++ VASurfaceID *surface /* out */ ++ ); ++ ++ ++ VAStatus (*vaCreateSurfaceFromV4L2Buf) ( ++ VADriverContextP_0_30 ctx, ++ int v4l2_fd, /* file descriptor of V4L2 device */ ++ struct v4l2_format *v4l2_fmt, /* format of V4L2 */ ++ struct v4l2_buffer *v4l2_buf, /* V4L2 buffer */ ++ VASurfaceID *surface /* out */ ++ ); ++ ++ VAStatus (*vaCopySurfaceToBuffer) ( ++ VADriverContextP_0_30 ctx, ++ VASurfaceID surface, ++ unsigned int *fourcc, /* out for follow argument */ ++ unsigned int *luma_stride, ++ unsigned int *chroma_u_stride, ++ unsigned int *chroma_v_stride, ++ unsigned int *luma_offset, ++ unsigned int *chroma_u_offset, ++ unsigned int *chroma_v_offset, ++ void **buffer ++ ); ++}; ++ ++/* Driver context (0.30) */ ++struct VADriverContext_0_30 ++{ ++ void *pDriverData; ++ struct VADriverVTable_0_30 vtable; ++ ++ void *x11_dpy; ++ int x11_screen; ++ int version_major; ++ int version_minor; ++ int max_profiles; ++ int max_entrypoints; ++ int max_attributes; ++ int max_image_formats; ++ int max_subpic_formats; ++ int max_display_attributes; ++ const char *str_vendor; ++ ++ void *handle; /* dlopen handle */ ++ ++ void *dri_state; ++}; ++ ++/* Driver VTable and context (0.31) */ ++#define VADriverVTable_0_31 VADriverVTable ++#define VADriverContext_0_31 VADriverContext ++ ++#endif /* VA_COMPAT_H */ +diff --git a/src/va_compat_template.h b/src/va_compat_template.h +new file mode 100644 +index 0000000..18349de +--- /dev/null ++++ b/src/va_compat_template.h +@@ -0,0 +1,539 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#undef CONCAT_ ++#define CONCAT_(x, y) x##y ++#undef CONCAT ++#define CONCAT(x, y) CONCAT_(x, y) ++#undef MKCOMPAT_ ++#define MKCOMPAT_(NAME,MINOR) CONCAT(CONCAT(NAME,_0_),MINOR) ++#undef MKCOMPAT ++#define MKCOMPAT(NAME) MKCOMPAT_(NAME,COMPAT_MINOR) ++#undef STRUCT ++#define STRUCT(BUFFER, CODEC) MKCOMPAT(VA##BUFFER##Buffer##CODEC) ++#undef TRANSLATE_1 ++#define TRANSLATE_1(NAME) CONCAT(va_compat_translate_,NAME) ++#undef TRANSLATE_ ++#define TRANSLATE_(NAME) TRANSLATE_1(MKCOMPAT(NAME)) ++#undef TRANSLATE ++#define TRANSLATE(BUFFER, CODEC) TRANSLATE_1(STRUCT(BUFFER,CODEC)) ++ ++#undef COPY_ARRAY ++#define COPY_ARRAY(DST, SRC, ARRAY) \ ++ memcpy((DST)->ARRAY, (SRC)->ARRAY, sizeof((DST)->ARRAY)) ++ ++#undef COPY_FIELD ++#define COPY_FIELD(DST, SRC, MEMBER) \ ++ (DST)->MEMBER = (SRC)->MEMBER ++ ++#undef COPY_VTABLE__ ++#define COPY_VTABLE__(DST, DST_MEMBER, SRC, SRC_MEMBER) \ ++ (DST##_vtable)->DST_MEMBER = (SRC##_vtable)->SRC_MEMBER ++ ++#undef COPY_VTABLE_ ++#define COPY_VTABLE_(DST, DST_SUFFIX, SRC, MEMBER) \ ++ COPY_VTABLE__(DST, MEMBER##_##DST_SUFFIX, SRC, MEMBER) ++ ++#undef COPY_VTABLE ++#define COPY_VTABLE(DST, SRC, MEMBER) \ ++ COPY_VTABLE__(DST, MEMBER, SRC, MEMBER) ++ ++/* 0.29 */ ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 29 ++#undef BFV ++#define BFV(a, b) a ++#undef BFM ++#define BFM(a, b, c) c ++#undef COPY_BIT_FIELD ++#define COPY_BIT_FIELD(DST, SRC, FIELD, MEMBER) \ ++ (DST)->MEMBER = (SRC)->FIELD.bits.MEMBER ++#undef COPY_BIT_FLAG ++#define COPY_BIT_FLAG(DST, SRC, FIELD, MEMBER) \ ++ (DST)->MEMBER = (SRC)->FIELD.flags.MEMBER ++#endif ++ ++/* 0.29 glue to match 0.30 names */ ++#undef M_raw_coding ++#undef M_bitplane_present ++#undef M_luma_flag ++#undef M_luma ++#undef M_chroma_flag ++#undef M_chroma ++ ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 29 ++#define M_raw_coding raw_coding_flag ++#define M_bitplane_present bitplane_present_flag ++#define M_luma_flag range_mapping_luma_flag ++#define M_luma range_mapping_luma ++#define M_chroma_flag range_mapping_chroma_flag ++#define M_chroma range_mapping_chroma ++#else ++#define M_raw_coding raw_coding ++#define M_bitplane_present bitplane_present ++#define M_luma_flag luma_flag ++#define M_luma luma ++#define M_chroma_flag chroma_flag ++#define M_chroma chroma ++#endif ++ ++/* 0.30 */ ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 30 ++#undef BFV ++#define BFV(a, b) a.b ++#undef BFM ++#define BFM(a, b, c) a.b.c ++#undef COPY_BIT_FIELD ++#define COPY_BIT_FIELD(DST, SRC, FIELD, MEMBER) \ ++ (DST)->FIELD.bits.MEMBER = (SRC)->FIELD.bits.MEMBER ++#undef COPY_BIT_FLAG ++#define COPY_BIT_FLAG(DST, SRC, FIELD, MEMBER) \ ++ (DST)->FIELD.flags.MEMBER = (SRC)->FIELD.flags.MEMBER ++#endif ++ ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR < 31 ++static VAStatus TRANSLATE_(VAPictureH264)( ++ VACompatContextP ctx, ++ void *dest_pic, ++ const void *src_pic ++) ++{ ++ MKCOMPAT(VAPictureH264) *dest = dest_pic; ++ const VAPictureH264 *src = src_pic; ++ ++ COPY_FIELD(dest, src, picture_id); ++ COPY_FIELD(dest, src, flags); ++ COPY_FIELD(dest, src, TopFieldOrderCnt); ++ COPY_FIELD(dest, src, BottomFieldOrderCnt); ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus TRANSLATE(PictureParameter,H264)( ++ VACompatContextP ctx, ++ void *dest_buffer, ++ const void *src_buffer ++) ++{ ++ STRUCT(PictureParameter,H264) *dest = dest_buffer; ++ const VAPictureParameterBufferH264 *src = src_buffer; ++ VAStatus status; ++ int i; ++ ++ status = TRANSLATE_(VAPictureH264)(ctx, ++ &dest->CurrPic, &src->CurrPic); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ ++ for (i = 0; i < 16; i++) { ++ status = TRANSLATE_(VAPictureH264)(ctx, ++ &dest->ReferenceFrames[i], ++ &src->ReferenceFrames[i]); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ } ++ ++ COPY_FIELD(dest, src, picture_width_in_mbs_minus1); ++ COPY_FIELD(dest, src, picture_height_in_mbs_minus1); ++ COPY_FIELD(dest, src, bit_depth_luma_minus8); ++ COPY_FIELD(dest, src, bit_depth_chroma_minus8); ++ COPY_FIELD(dest, src, num_ref_frames); ++ dest->BFV(seq_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, seq_fields, chroma_format_idc); ++ COPY_BIT_FIELD(dest, src, seq_fields, residual_colour_transform_flag); ++ COPY_BIT_FIELD(dest, src, seq_fields, frame_mbs_only_flag); ++ COPY_BIT_FIELD(dest, src, seq_fields, mb_adaptive_frame_field_flag); ++ COPY_BIT_FIELD(dest, src, seq_fields, direct_8x8_inference_flag); ++ COPY_BIT_FIELD(dest, src, seq_fields, MinLumaBiPredSize8x8); ++ COPY_FIELD(dest, src, num_slice_groups_minus1); ++ COPY_FIELD(dest, src, slice_group_map_type); ++ COPY_FIELD(dest, src, pic_init_qp_minus26); ++ COPY_FIELD(dest, src, chroma_qp_index_offset); ++ COPY_FIELD(dest, src, second_chroma_qp_index_offset); ++ dest->BFV(pic_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, pic_fields, entropy_coding_mode_flag); ++ COPY_BIT_FIELD(dest, src, pic_fields, weighted_pred_flag); ++ COPY_BIT_FIELD(dest, src, pic_fields, weighted_bipred_idc); ++ COPY_BIT_FIELD(dest, src, pic_fields, transform_8x8_mode_flag); ++ COPY_BIT_FIELD(dest, src, pic_fields, field_pic_flag); ++ COPY_BIT_FIELD(dest, src, pic_fields, constrained_intra_pred_flag); ++ COPY_FIELD(dest, src, frame_num); ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus TRANSLATE(SliceParameter,H264)( ++ VACompatContextP ctx, ++ void *dest_buffer, ++ const void *src_buffer ++) ++{ ++ STRUCT(SliceParameter,H264) *dest = dest_buffer; ++ const VASliceParameterBufferH264 *src = src_buffer; ++ VAStatus status; ++ int i; ++ ++ COPY_FIELD(dest, src, slice_data_size); ++ COPY_FIELD(dest, src, slice_data_offset); ++ COPY_FIELD(dest, src, slice_data_flag); ++ COPY_FIELD(dest, src, slice_data_bit_offset); ++ COPY_FIELD(dest, src, first_mb_in_slice); ++ COPY_FIELD(dest, src, slice_type); ++ COPY_FIELD(dest, src, direct_spatial_mv_pred_flag); ++ COPY_FIELD(dest, src, num_ref_idx_l0_active_minus1); ++ COPY_FIELD(dest, src, num_ref_idx_l1_active_minus1); ++ COPY_FIELD(dest, src, cabac_init_idc); ++ COPY_FIELD(dest, src, slice_qp_delta); ++ COPY_FIELD(dest, src, disable_deblocking_filter_idc); ++ COPY_FIELD(dest, src, slice_alpha_c0_offset_div2); ++ COPY_FIELD(dest, src, slice_beta_offset_div2); ++ for (i = 0; i < 32; i++) { ++ status = TRANSLATE_(VAPictureH264)(ctx, ++ &dest->RefPicList0[i], ++ &src->RefPicList0[i]); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ status = TRANSLATE_(VAPictureH264)(ctx, ++ &dest->RefPicList1[i], ++ &src->RefPicList1[i]); ++ if (status != VA_STATUS_SUCCESS) ++ return status; ++ } ++ COPY_FIELD(dest, src, luma_log2_weight_denom); ++ COPY_FIELD(dest, src, chroma_log2_weight_denom); ++ COPY_FIELD(dest, src, luma_weight_l0_flag); ++ COPY_ARRAY(dest, src, luma_weight_l0); ++ COPY_ARRAY(dest, src, luma_offset_l0); ++ COPY_FIELD(dest, src, chroma_weight_l0_flag); ++ COPY_ARRAY(dest, src, chroma_weight_l0); ++ COPY_ARRAY(dest, src, chroma_offset_l0); ++ COPY_FIELD(dest, src, luma_weight_l1_flag); ++ COPY_ARRAY(dest, src, luma_weight_l1); ++ COPY_ARRAY(dest, src, luma_offset_l1); ++ COPY_FIELD(dest, src, chroma_weight_l1_flag); ++ COPY_ARRAY(dest, src, chroma_weight_l1); ++ COPY_ARRAY(dest, src, chroma_offset_l1); ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus TRANSLATE(PictureParameter,VC1)( ++ VACompatContextP ctx, ++ void *dest_buffer, ++ const void *src_buffer ++) ++{ ++ STRUCT(PictureParameter,VC1) *dest = dest_buffer; ++ const VAPictureParameterBufferVC1 *src = src_buffer; ++ ++ COPY_FIELD(dest, src, forward_reference_picture); ++ COPY_FIELD(dest, src, backward_reference_picture); ++ COPY_FIELD(dest, src, inloop_decoded_picture); ++ dest->BFV(sequence_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, sequence_fields, interlace); ++ COPY_BIT_FIELD(dest, src, sequence_fields, syncmarker); ++ COPY_BIT_FIELD(dest, src, sequence_fields, overlap); ++ COPY_FIELD(dest, src, coded_width); ++ COPY_FIELD(dest, src, coded_height); ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 30 ++ dest->closed_entry = src->entrypoint_fields.bits.closed_entry; ++ dest->broken_link = src->entrypoint_fields.bits.broken_link; ++ dest->loopfilter = src->entrypoint_fields.bits.loopfilter; ++#else ++ COPY_BIT_FIELD(dest, src, entrypoint_fields, closed_entry); ++ COPY_BIT_FIELD(dest, src, entrypoint_fields, broken_link); ++ COPY_BIT_FIELD(dest, src, entrypoint_fields, loopfilter); ++#endif ++ COPY_FIELD(dest, src, conditional_overlap_flag); ++ COPY_FIELD(dest, src, fast_uvmc_flag); ++ dest->BFV(range_mapping_fields, value) = 0; /* reset all bits */ ++ dest->BFM(range_mapping_fields, bits, M_luma_flag) = ++ src->range_mapping_fields.bits.luma_flag; ++ dest->BFM(range_mapping_fields, bits, M_luma) = ++ src->range_mapping_fields.bits.luma; ++ dest->BFM(range_mapping_fields, bits, M_chroma_flag) = ++ src->range_mapping_fields.bits.chroma_flag; ++ dest->BFM(range_mapping_fields, bits, M_chroma) = ++ src->range_mapping_fields.bits.chroma; ++ COPY_FIELD(dest, src, b_picture_fraction); ++ COPY_FIELD(dest, src, cbp_table); ++ COPY_FIELD(dest, src, mb_mode_table); ++ COPY_FIELD(dest, src, range_reduction_frame); ++ COPY_FIELD(dest, src, rounding_control); ++ COPY_FIELD(dest, src, post_processing); ++ COPY_FIELD(dest, src, picture_resolution_index); ++ COPY_FIELD(dest, src, luma_scale); ++ COPY_FIELD(dest, src, luma_shift); ++ dest->BFV(picture_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, picture_fields, picture_type); ++ COPY_BIT_FIELD(dest, src, picture_fields, frame_coding_mode); ++ COPY_BIT_FIELD(dest, src, picture_fields, top_field_first); ++ COPY_BIT_FIELD(dest, src, picture_fields, is_first_field); ++ COPY_BIT_FIELD(dest, src, picture_fields, intensity_compensation); ++ dest->BFV(M_raw_coding, value) = 0; /* reset all bits */ ++ COPY_BIT_FLAG(dest, src, raw_coding, mv_type_mb); ++ COPY_BIT_FLAG(dest, src, raw_coding, direct_mb); ++ COPY_BIT_FLAG(dest, src, raw_coding, skip_mb); ++ COPY_BIT_FLAG(dest, src, raw_coding, field_tx); ++ COPY_BIT_FLAG(dest, src, raw_coding, forward_mb); ++ COPY_BIT_FLAG(dest, src, raw_coding, ac_pred); ++ COPY_BIT_FLAG(dest, src, raw_coding, overflags); ++ dest->BFV(M_bitplane_present, value) = 0; /* reset all bits */ ++ COPY_BIT_FLAG(dest, src, bitplane_present, bp_mv_type_mb); ++ COPY_BIT_FLAG(dest, src, bitplane_present, bp_direct_mb); ++ COPY_BIT_FLAG(dest, src, bitplane_present, bp_skip_mb); ++ COPY_BIT_FLAG(dest, src, bitplane_present, bp_field_tx); ++ COPY_BIT_FLAG(dest, src, bitplane_present, bp_forward_mb); ++ COPY_BIT_FLAG(dest, src, bitplane_present, bp_ac_pred); ++ COPY_BIT_FLAG(dest, src, bitplane_present, bp_overflags); ++ dest->BFV(reference_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, reference_fields, reference_distance_flag); ++ COPY_BIT_FIELD(dest, src, reference_fields, reference_distance); ++ COPY_BIT_FIELD(dest, src, reference_fields, num_reference_pictures); ++ COPY_BIT_FIELD(dest, src, reference_fields, reference_field_pic_indicator); ++ dest->BFV(mv_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, mv_fields, mv_mode); ++ COPY_BIT_FIELD(dest, src, mv_fields, mv_mode2); ++ COPY_BIT_FIELD(dest, src, mv_fields, mv_table); ++ COPY_BIT_FIELD(dest, src, mv_fields, two_mv_block_pattern_table); ++ COPY_BIT_FIELD(dest, src, mv_fields, four_mv_switch); ++ COPY_BIT_FIELD(dest, src, mv_fields, four_mv_block_pattern_table); ++ COPY_BIT_FIELD(dest, src, mv_fields, extended_mv_flag); ++ COPY_BIT_FIELD(dest, src, mv_fields, extended_mv_range); ++ COPY_BIT_FIELD(dest, src, mv_fields, extended_dmv_flag); ++ COPY_BIT_FIELD(dest, src, mv_fields, extended_dmv_range); ++ dest->BFV(pic_quantizer_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dquant); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, quantizer); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, half_qp); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, pic_quantizer_scale); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, pic_quantizer_type); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_frame); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_profile); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_sb_edge); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_db_edge); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, dq_binary_level); ++ COPY_BIT_FIELD(dest, src, pic_quantizer_fields, alt_pic_quantizer); ++ dest->BFV(transform_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, transform_fields, variable_sized_transform_flag); ++ COPY_BIT_FIELD(dest, src, transform_fields, mb_level_transform_type_flag); ++ COPY_BIT_FIELD(dest, src, transform_fields, frame_level_transform_type); ++ COPY_BIT_FIELD(dest, src, transform_fields, transform_ac_codingset_idx1); ++ COPY_BIT_FIELD(dest, src, transform_fields, transform_ac_codingset_idx2); ++ COPY_BIT_FIELD(dest, src, transform_fields, intra_transform_dc_table); ++ ++ if (src->picture_fields.bits.picture_type == 4) { ++ dest->BFM(picture_fields, bits, picture_type) = 1; /* P-frame */ ++ ctx->skip_frame = 1; ++ } ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus TRANSLATE(PictureParameter,MPEG2)( ++ VACompatContextP ctx, ++ void *dest_buffer, ++ const void *src_buffer ++) ++{ ++ STRUCT(PictureParameter,MPEG2) *dest = dest_buffer; ++ const VAPictureParameterBufferMPEG2 *src = src_buffer; ++ ++ COPY_FIELD(dest, src, horizontal_size); ++ COPY_FIELD(dest, src, vertical_size); ++ COPY_FIELD(dest, src, forward_reference_picture); ++ COPY_FIELD(dest, src, backward_reference_picture); ++ COPY_FIELD(dest, src, picture_coding_type); ++ COPY_FIELD(dest, src, f_code); ++ dest->BFV(picture_coding_extension, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, intra_dc_precision); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, picture_structure); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, top_field_first); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, frame_pred_frame_dct); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, concealment_motion_vectors); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, q_scale_type); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, intra_vlc_format); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, alternate_scan); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, repeat_first_field); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, progressive_frame); ++ COPY_BIT_FIELD(dest, src, picture_coding_extension, is_first_field); ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++static VAStatus TRANSLATE(SliceParameter,MPEG2)( ++ VACompatContextP ctx, ++ void *dest_buffer, ++ const void *src_buffer ++) ++{ ++ STRUCT(SliceParameter,MPEG2) *dest = dest_buffer; ++ const VASliceParameterBufferMPEG2 *src = src_buffer; ++ ++ COPY_FIELD(dest, src, slice_data_size); ++ COPY_FIELD(dest, src, slice_data_offset); ++ COPY_FIELD(dest, src, slice_data_flag); ++ COPY_FIELD(dest, src, macroblock_offset); ++ COPY_FIELD(dest, src, slice_vertical_position); ++ COPY_FIELD(dest, src, quantiser_scale_code); ++ COPY_FIELD(dest, src, intra_slice_flag); ++ ++ return VA_STATUS_SUCCESS; ++} ++#endif ++ ++static VAStatus TRANSLATE(PictureParameter,MPEG4)( ++ VACompatContextP ctx, ++ void *dest_buffer, ++ const void *src_buffer ++) ++{ ++ STRUCT(PictureParameter,MPEG4) *dest = dest_buffer; ++ const VAPictureParameterBufferMPEG4 *src = src_buffer; ++ ++ COPY_FIELD(dest, src, vop_width); ++ COPY_FIELD(dest, src, vop_height); ++ COPY_FIELD(dest, src, forward_reference_picture); ++ COPY_FIELD(dest, src, backward_reference_picture); ++ dest->BFV(vol_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, vol_fields, short_video_header); ++ COPY_BIT_FIELD(dest, src, vol_fields, chroma_format); ++ COPY_BIT_FIELD(dest, src, vol_fields, interlaced); ++ COPY_BIT_FIELD(dest, src, vol_fields, obmc_disable); ++ COPY_BIT_FIELD(dest, src, vol_fields, sprite_enable); ++ COPY_BIT_FIELD(dest, src, vol_fields, sprite_warping_accuracy); ++ COPY_BIT_FIELD(dest, src, vol_fields, quant_type); ++ COPY_BIT_FIELD(dest, src, vol_fields, quarter_sample); ++ COPY_BIT_FIELD(dest, src, vol_fields, data_partitioned); ++ COPY_BIT_FIELD(dest, src, vol_fields, reversible_vlc); ++ COPY_FIELD(dest, src, no_of_sprite_warping_points); ++ COPY_ARRAY(dest, src, sprite_trajectory_du); ++ COPY_ARRAY(dest, src, sprite_trajectory_dv); ++ COPY_FIELD(dest, src, quant_precision); ++ dest->BFV(vop_fields, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, vop_fields, vop_coding_type); ++ COPY_BIT_FIELD(dest, src, vop_fields, backward_reference_vop_coding_type); ++ COPY_BIT_FIELD(dest, src, vop_fields, vop_rounding_type); ++ COPY_BIT_FIELD(dest, src, vop_fields, intra_dc_vlc_thr); ++ COPY_BIT_FIELD(dest, src, vop_fields, top_field_first); ++ COPY_BIT_FIELD(dest, src, vop_fields, alternate_vertical_scan_flag); ++ COPY_FIELD(dest, src, vop_fcode_forward); ++ COPY_FIELD(dest, src, vop_fcode_backward); ++ COPY_FIELD(dest, src, num_gobs_in_vop); ++ COPY_FIELD(dest, src, num_macroblocks_in_gob); ++ COPY_FIELD(dest, src, TRB); ++ COPY_FIELD(dest, src, TRD); ++ ++ return VA_STATUS_SUCCESS; ++} ++ ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR == 30 ++static VAStatus TRANSLATE_(VAEncSliceParameterBuffer)( ++ VACompatContextP ctx, ++ void *dest_buffer, ++ const void *src_buffer ++) ++{ ++ MKCOMPAT(VAEncSliceParameterBuffer) * const dest = dest_buffer; ++ const VAEncSliceParameterBuffer * const src = src_buffer; ++ ++ COPY_FIELD(dest, src, start_row_number); ++ COPY_FIELD(dest, src, slice_height); ++ dest->BFV(slice_flags, value) = 0; /* reset all bits */ ++ COPY_BIT_FIELD(dest, src, slice_flags, is_intra); ++ COPY_BIT_FIELD(dest, src, slice_flags, disable_deblocking_filter_idc); ++ ++ return VA_STATUS_SUCCESS; ++} ++#endif ++ ++static void TRANSLATE_(VADriverContext)( ++ VACompatContext *dest, ++ const struct MKCOMPAT(VADriverContext) *src ++) ++{ ++ VACompatDriverVTable *dest_vtable = &dest->vtable; ++ const struct MKCOMPAT(VADriverVTable) *src_vtable = &src->vtable; ++ ++ memset(dest_vtable, 0, sizeof(*dest_vtable)); ++ COPY_VTABLE(dest, src, vaTerminate); ++ COPY_VTABLE(dest, src, vaQueryConfigProfiles); ++ COPY_VTABLE(dest, src, vaQueryConfigEntrypoints); ++ COPY_VTABLE(dest, src, vaGetConfigAttributes); ++ COPY_VTABLE(dest, src, vaCreateConfig); ++ COPY_VTABLE(dest, src, vaDestroyConfig); ++ COPY_VTABLE(dest, src, vaQueryConfigAttributes); ++ COPY_VTABLE(dest, src, vaCreateSurfaces); ++ COPY_VTABLE(dest, src, vaDestroySurfaces); ++ COPY_VTABLE(dest, src, vaCreateContext); ++ COPY_VTABLE(dest, src, vaDestroyContext); ++ COPY_VTABLE(dest, src, vaCreateBuffer); ++ COPY_VTABLE(dest, src, vaBufferSetNumElements); ++ COPY_VTABLE(dest, src, vaMapBuffer); ++ COPY_VTABLE(dest, src, vaUnmapBuffer); ++ COPY_VTABLE(dest, src, vaDestroyBuffer); ++ COPY_VTABLE(dest, src, vaBeginPicture); ++ COPY_VTABLE(dest, src, vaRenderPicture); ++ COPY_VTABLE(dest, src, vaEndPicture); ++ COPY_VTABLE(dest, src, vaQuerySurfaceStatus); ++ COPY_VTABLE(dest, src, vaPutSurface); ++ COPY_VTABLE(dest, src, vaQueryImageFormats); ++ COPY_VTABLE(dest, src, vaCreateImage); ++ COPY_VTABLE(dest, src, vaDeriveImage); ++ COPY_VTABLE(dest, src, vaDestroyImage); ++ COPY_VTABLE(dest, src, vaSetImagePalette); ++ COPY_VTABLE(dest, src, vaGetImage); ++ COPY_VTABLE(dest, src, vaQuerySubpictureFormats); ++ COPY_VTABLE(dest, src, vaCreateSubpicture); ++ COPY_VTABLE(dest, src, vaDestroySubpicture); ++ COPY_VTABLE(dest, src, vaSetSubpictureImage); ++ COPY_VTABLE(dest, src, vaSetSubpictureChromakey); ++ COPY_VTABLE(dest, src, vaSetSubpictureGlobalAlpha); ++ COPY_VTABLE(dest, src, vaDeassociateSubpicture); ++ COPY_VTABLE(dest, src, vaQueryDisplayAttributes); ++ COPY_VTABLE(dest, src, vaGetDisplayAttributes); ++ COPY_VTABLE(dest, src, vaSetDisplayAttributes); ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR <= 29 ++ COPY_VTABLE(dest, src, vaSetSubpicturePalette); ++ COPY_VTABLE(dest, src, vaDbgCopySurfaceToBuffer); ++#endif ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR >= 30 ++ COPY_VTABLE(dest, src, vaCreateSurfaceFromCIFrame); ++ COPY_VTABLE(dest, src, vaCreateSurfaceFromV4L2Buf); ++ COPY_VTABLE(dest, src, vaCopySurfaceToBuffer); ++#endif ++#if COMPAT_MAJOR == 0 && COMPAT_MINOR >= 31 ++ COPY_VTABLE(dest, src, vaSyncSurface); ++ COPY_VTABLE(dest, src, vaPutImage); ++ COPY_VTABLE(dest, src, vaAssociateSubpicture); ++#else ++ COPY_VTABLE_(dest, pre31, src, vaSyncSurface); ++ COPY_VTABLE_(dest, pre31, src, vaPutImage); ++ COPY_VTABLE_(dest, pre31, src, vaPutImage2); ++ COPY_VTABLE_(dest, pre31, src, vaAssociateSubpicture); ++ COPY_VTABLE_(dest, pre31, src, vaAssociateSubpicture2); ++#endif ++} ++ ++#undef COMPAT_MAJOR ++#undef COMPAT_MINOR diff --git a/meta-emenlow/packages/libva/libva-0.31.0/392_compat.dso.patch b/meta-emenlow/packages/libva/libva-0.31.0/392_compat.dso.patch new file mode 100644 index 0000000000..57ae44f9d4 --- /dev/null +++ b/meta-emenlow/packages/libva/libva-0.31.0/392_compat.dso.patch @@ -0,0 +1,183 @@ +commit 389323f728fb2d6392d266d967eddde40465fd93 +Author: Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> +Date: Fri Oct 16 12:35:27 2009 +0000 + + Fix compatibility with older programs linked against libva.so.0. + +diff --git a/src/Makefile.am b/src/Makefile.am +index 232d8e8..2d696f1 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -72,3 +72,8 @@ EXTRA_DIST = \ + va_compat_template.h + + va_compat.c: va_compat_template.h ++ ++lib_LTLIBRARIES += libva-compat.la ++libva_compat_la_SOURCES = va_compat_lib.c ++libva_compat_la_LIBADD = libva-x11.la -ldl ++libva_compat_la_DEPENDENCIES = libva-x11.la +diff --git a/src/va_compat_lib.c b/src/va_compat_lib.c +new file mode 100644 +index 0000000..b7e9ea5 +--- /dev/null ++++ b/src/va_compat_lib.c +@@ -0,0 +1,158 @@ ++/* ++ * Copyright (C) 2009 Splitted-Desktop Systems. All Rights Reserved. ++ * ++ * Permission is hereby granted, free of charge, to any person obtaining a ++ * copy of this software and associated documentation files (the ++ * "Software"), to deal in the Software without restriction, including ++ * without limitation the rights to use, copy, modify, merge, publish, ++ * distribute, sub license, and/or sell copies of the Software, and to ++ * permit persons to whom the Software is furnished to do so, subject to ++ * the following conditions: ++ * ++ * The above copyright notice and this permission notice (including the ++ * next paragraph) shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. ++ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ */ ++ ++#define _GNU_SOURCE 1 ++#include <dlfcn.h> ++#include <assert.h> ++#include <stddef.h> ++ ++typedef void *VADisplay; ++typedef int VAStatus; ++typedef unsigned int VAGenericID; ++typedef VAGenericID VAContextID; ++typedef VAGenericID VASurfaceID; ++typedef VAGenericID VAImageID; ++typedef VAGenericID VASubpictureID; ++ ++#define PREPARE_FUNC(NAME, RET, ARGS) \ ++ static RET (*lib_##NAME) ARGS; \ ++ if (lib_##NAME == NULL) \ ++ lib_##NAME = dlsym(RTLD_NEXT, #NAME); \ ++ assert(lib_##NAME != NULL) ++ ++VAStatus ++vaSyncSurface( ++ VADisplay dpy, ++ VAContextID context, ++ VASurfaceID render_target ++) ++{ ++ PREPARE_FUNC(vaSyncSurface, VAStatus, (VADisplay, VASurfaceID)); ++ ++ return lib_vaSyncSurface(dpy, render_target); ++} ++ ++VAStatus ++vaPutImage( ++ VADisplay dpy, ++ VASurfaceID surface, ++ VAImageID image, ++ int src_x, ++ int src_y, ++ unsigned int width, ++ unsigned int height, ++ int dest_x, ++ int dest_y ++) ++{ ++ PREPARE_FUNC(vaPutImage, VAStatus, (VADisplay, VASurfaceID, VAImageID, ++ int, int, unsigned int, unsigned int, ++ int, int, unsigned int, unsigned int)); ++ ++ return lib_vaPutImage(dpy, surface, image, ++ src_x, src_y, width, height, ++ dest_x, dest_y, width, height); ++} ++ ++VAStatus ++vaPutImage2( ++ VADisplay dpy, ++ VASurfaceID surface, ++ VAImageID image, ++ int src_x, ++ int src_y, ++ unsigned int src_width, ++ unsigned int src_height, ++ int dest_x, ++ int dest_y, ++ unsigned int dest_width, ++ unsigned int dest_height ++) ++{ ++ PREPARE_FUNC(vaPutImage, VAStatus, (VADisplay, VASurfaceID, VAImageID, ++ int, int, unsigned int, unsigned int, ++ int, int, unsigned int, unsigned int)); ++ ++ return lib_vaPutImage(dpy, surface, image, ++ src_x, src_y, src_width, src_height, ++ dest_x, dest_y, dest_width, dest_height); ++} ++ ++VAStatus ++vaAssociateSubpicture( ++ VADisplay dpy, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces, ++ short src_x, ++ short src_y, ++ short dest_x, ++ short dest_y, ++ unsigned short width, ++ unsigned short height, ++ unsigned int flags ++) ++{ ++ PREPARE_FUNC(vaAssociateSubpicture, ++ VAStatus, (VADisplay, VASubpictureID, VASurfaceID *, int, ++ short, short, unsigned short, unsigned short, ++ short, short, unsigned short, unsigned short, ++ unsigned int)); ++ ++ return lib_vaAssociateSubpicture(dpy, subpicture, ++ target_surfaces, num_surfaces, ++ src_x, src_y, width, height, ++ dest_x, dest_y, width, height, ++ flags); ++} ++ ++VAStatus ++vaAssociateSubpicture2( ++ VADisplay dpy, ++ VASubpictureID subpicture, ++ VASurfaceID *target_surfaces, ++ int num_surfaces, ++ short src_x, ++ short src_y, ++ unsigned short src_width, ++ unsigned short src_height, ++ short dest_x, ++ short dest_y, ++ unsigned short dest_width, ++ unsigned short dest_height, ++ unsigned int flags ++) ++{ ++ PREPARE_FUNC(vaAssociateSubpicture, ++ VAStatus, (VADisplay, VASubpictureID, VASurfaceID *, int, ++ short, short, unsigned short, unsigned short, ++ short, short, unsigned short, unsigned short, ++ unsigned int)); ++ ++ return lib_vaAssociateSubpicture(dpy, subpicture, ++ target_surfaces, num_surfaces, ++ src_x, src_y, src_width, src_height, ++ dest_x, dest_y, dest_width, dest_height, ++ flags); ++} diff --git a/meta-emenlow/packages/libva/libva_0.31.0.bb b/meta-emenlow/packages/libva/libva_0.31.0.bb new file mode 100644 index 0000000000..52cd599957 --- /dev/null +++ b/meta-emenlow/packages/libva/libva_0.31.0.bb @@ -0,0 +1,35 @@ +DESCRIPTION = "Video Acceleration (VA) API for Linux" +LICENSE = "MIT" +LIC_FILES_CHKSUM = "file://COPYING;md5=efc13a0998e678466e556756613c582e" +PR = "r0" + +inherit autotools + +SRC_URI = "https://launchpad.net/~gma500/+archive/ppa/+files/libva_0.31.0-1+sds9.1ubuntu1.tar.gz \ + file://033_g45_add_rgba_subpic.patch;patch=1 \ + file://034_g45_fix_return_for_unimpl.patch;patch=1 \ + file://035_g45_add_yv12_image_format.patch;patch=1 \ + file://036_g45_add_vaGetImage.patch;patch=1 \ + file://037_g45_add_vaPutImage.patch;patch=1 \ + file://038_g45_vaPutSurface_cliprects.patch;patch=1 \ + file://102_attribute_visibility.patch;patch=1 \ + file://103_fix_vainfo_deps.patch;patch=1 \ + file://104_fix_libva_pkgconfig_deps.patch;patch=1 \ + file://105_dont_search_LIBGL_DRIVERS_PATH.patch;patch=1 \ + file://108_drivers_path.patch;patch=1 \ + file://203_fix_fglrx_detection.patch;patch=1 \ + file://204_check_ATIFGLEXTENSION.patch;patch=1 \ + file://300_sds_version.patch;patch=1 \ + file://301_vdpau_mpeg4.patch;patch=1 \ + file://320_move_vaPutSurface_flags_def.patch;patch=1 \ + file://321_libva_glx.base.patch;patch=1 \ + file://322_libva_glx.patch;patch=1 \ + file://390_compat.base.patch;patch=1 \ + file://391_compat.patch;patch=1 \ + file://392_compat.dso.patch;patch=1" + +export LDFLAGS="-Wl,-z,defs" + +EXTRA_OECONF = "--disable-i965-driver" + +FILES_${PN} += "${libdir}/va/drivers/*" |