diff options
Diffstat (limited to 'meta-emenlow/recipes-graphics/libva/libva-0.31.0/391_compat.patch')
-rw-r--r-- | meta-emenlow/recipes-graphics/libva/libva-0.31.0/391_compat.patch | 3273 |
1 files changed, 3273 insertions, 0 deletions
diff --git a/meta-emenlow/recipes-graphics/libva/libva-0.31.0/391_compat.patch b/meta-emenlow/recipes-graphics/libva/libva-0.31.0/391_compat.patch new file mode 100644 index 0000000000..5e09d22b82 --- /dev/null +++ b/meta-emenlow/recipes-graphics/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 |