dummy_drv_video_la_LTLIBRARIES = dummy_drv_video.la
dummy_drv_video_ladir = /usr/X11R6/lib/modules/dri
-dummy_drv_video_la_LDFLAGS = -no-undefined -module -Wl,--no-undefined
-dummy_drv_video_la_LIBADD = -lva
+dummy_drv_video_la_LDFLAGS = -module -avoid-version -no-undefined -Wl,--no-undefined
+dummy_drv_video_la_LIBADD = ../src/libva.la
AM_CFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/../../include/external/ -I$(top_srcdir)/../../include/kmd
dummy_drv_video_la_SOURCES = dummy_drv_video.c object_heap.c
return VA_STATUS_SUCCESS;
}
-VAStatus dummy_QueryConfigAttributes(
+VAStatus dummy_GetConfigAttributes(
VADriverContextP ctx,
VAProfile profile,
VAEntrypoint entrypoint,
return vaStatus;
}
-VAStatus dummy_GetConfigAttributes(
+VAStatus dummy_DestroyConfig(
+ VADriverContextP ctx,
+ VAConfigID config_id
+ )
+{
+ INIT_DRIVER_DATA
+ VAStatus vaStatus;
+ object_config_p obj_config;
+
+ obj_config = CONFIG(config_id);
+ if (NULL == obj_config)
+ {
+ vaStatus = VA_STATUS_ERROR_INVALID_CONFIG;
+ return vaStatus;
+ }
+
+ object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
+ return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_QueryConfigAttributes(
VADriverContextP ctx,
VAConfigID config_id,
VAProfile *profile, /* out */
{
case VAPictureParameterBufferType:
case VAIQMatrixBufferType:
+ case VABitPlaneBufferType:
+ case VASliceGroupMapBufferType:
case VASliceParameterBufferType:
case VASliceDataBufferType:
case VAMacroblockParameterBufferType:
case VAResidualDataBufferType:
case VADeblockingParameterBufferType:
+ case VAImageBufferType:
/* Ok */
break;
default:
unsigned short desth,
VARectangle *cliprects, /* client supplied clip list */
unsigned int number_cliprects, /* number of clip rects in the clip list */
- int flags /* de-interlacing flags */
+ unsigned int flags /* de-interlacing flags */
)
{
/* TODO */
return VA_STATUS_ERROR_UNKNOWN;
}
+/*
+ * Query display attributes
+ * The caller must provide a "attr_list" array that can hold at
+ * least vaMaxNumDisplayAttributes() entries. The actual number of attributes
+ * returned in "attr_list" is returned in "num_attributes".
+ */
+VAStatus dummy_QueryDisplayAttributes (
+ VADriverContextP ctx,
+ VADisplayAttribute *attr_list, /* out */
+ int *num_attributes /* out */
+ )
+{
+ /* TODO */
+ return VA_STATUS_ERROR_UNKNOWN;
+}
-VAStatus dummy_CopySurfaceToGLXPbuffer (
- VADriverContextP ctx,
- VASurface *surface,
- XID pbuffer_id,
- short srcx,
- short srcy,
- unsigned short width,
- unsigned short height,
- short destx,
- short desty,
- unsigned int draw_buffer,
- unsigned int flags /* de-interlacing flags */
-)
+/*
+ * Get display attributes
+ * This function returns the current attribute values in "attr_list".
+ * Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can have their values retrieved.
+ */
+VAStatus dummy_GetDisplayAttributes (
+ VADriverContextP ctx,
+ VADisplayAttribute *attr_list, /* in/out */
+ int num_attributes
+ )
{
/* TODO */
return VA_STATUS_ERROR_UNKNOWN;
}
+/*
+ * Set display attributes
+ * Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can be set. If the attribute is not settable or
+ * the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
+ */
+VAStatus dummy_SetDisplayAttributes (
+ VADriverContextP ctx,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+ )
+{
+ /* TODO */
+ return VA_STATUS_ERROR_UNKNOWN;
+}
+
+
VAStatus dummy_DbgCopySurfaceToBuffer(
VADriverContextP ctx,
VASurface *surface,
return VA_STATUS_SUCCESS;
}
-VAStatus __vaDriverInit_0_23( VADriverContextP ctx )
+VAStatus __vaDriverInit_0_24( VADriverContextP ctx )
{
object_base_p obj;
int result;
int i;
ctx->version_major = 0;
- ctx->version_minor = 22;
+ ctx->version_minor = 24;
ctx->max_profiles = DUMMY_MAX_PROFILES;
ctx->max_entrypoints = DUMMY_MAX_ENTRYPOINTS;
ctx->max_attributes = DUMMY_MAX_CONFIG_ATTRIBUTES;
ctx->max_image_formats = DUMMY_MAX_IMAGE_FORMATS;
ctx->max_subpic_formats = DUMMY_MAX_SUBPIC_FORMATS;
+ ctx->max_display_attributes = DUMMY_MAX_DISPLAY_ATTRIBUTES;
ctx->vtable.vaTerminate = dummy_Terminate;
ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
ctx->vtable.vaQueryConfigAttributes = dummy_QueryConfigAttributes;
ctx->vtable.vaCreateConfig = dummy_CreateConfig;
+ ctx->vtable.vaDestroyConfig = dummy_DestroyConfig;
ctx->vtable.vaGetConfigAttributes = dummy_GetConfigAttributes;
ctx->vtable.vaCreateSurfaces = dummy_CreateSurfaces;
ctx->vtable.vaDestroySurface = dummy_DestroySurface;
ctx->vtable.vaSyncSurface = dummy_SyncSurface;
ctx->vtable.vaQuerySurfaceStatus = dummy_QuerySurfaceStatus;
ctx->vtable.vaPutSurface = dummy_PutSurface;
- ctx->vtable.vaCopySurfaceToGLXPbuffer = dummy_CopySurfaceToGLXPbuffer;
ctx->vtable.vaQueryImageFormats = dummy_QueryImageFormats;
ctx->vtable.vaCreateImage = dummy_CreateImage;
ctx->vtable.vaDestroyImage = dummy_DestroyImage;
ctx->vtable.vaSetSubpictureChromakey = dummy_SetSubpictureChromakey;
ctx->vtable.vaSetSubpictureGlobalAlpha = dummy_SetSubpictureGlobalAlpha;
ctx->vtable.vaAssociateSubpicture = dummy_AssociateSubpicture;
+ ctx->vtable.vaQueryDisplayAttributes = dummy_QueryDisplayAttributes;
+ ctx->vtable.vaGetDisplayAttributes = dummy_GetDisplayAttributes;
+ ctx->vtable.vaSetDisplayAttributes = dummy_SetDisplayAttributes;
+
ctx->vtable.vaDbgCopySurfaceToBuffer = dummy_DbgCopySurfaceToBuffer;
driver_data = (struct dummy_driver_data *) malloc( sizeof(*driver_data) );
#define DUMMY_MAX_CONFIG_ATTRIBUTES 10
#define DUMMY_MAX_IMAGE_FORMATS 10
#define DUMMY_MAX_SUBPIC_FORMATS 4
+#define DUMMY_MAX_DISPLAY_ATTRIBUTES 4
struct dummy_driver_data {
struct object_heap config_heap;
libva_la_LTLIBRARIES = libva.la
libva_ladir = $(libdir)
-libva_la_LDFLAGS = -version-number 0:22:0 -no-undefined
+libva_la_LDFLAGS = -version-number 0:24:0 -no-undefined
libva_la_LIBADD = -ldl -lX11 -lXext
libva_la_SOURCES = va_dri.c va.c va_dristr.h
#define DEFAULT_DRIVER_DIR "/usr/X11R6/lib/modules/dri"
#define DRIVER_EXTENSION "_drv_video.so"
-#define DRIVER_INIT_FUNC "__vaDriverInit_0_23"
+#define DRIVER_INIT_FUNC "__vaDriverInit_0_24"
#define CTX(dpy) ((VADriverContextP) dpy );
#define ASSERT_CONTEXT(dpy) assert( vaDbgContextIsValid(dpy) )
CHECK_MAXIMUM(vaStatus, ctx, attributes);
CHECK_MAXIMUM(vaStatus, ctx, image_formats);
CHECK_MAXIMUM(vaStatus, ctx, subpic_formats);
+ CHECK_MAXIMUM(vaStatus, ctx, display_attributes);
CHECK_VTABLE(vaStatus, ctx, Terminate);
CHECK_VTABLE(vaStatus, ctx, QueryConfigProfiles);
CHECK_VTABLE(vaStatus, ctx, QueryConfigEntrypoints);
CHECK_VTABLE(vaStatus, ctx, QueryConfigAttributes);
CHECK_VTABLE(vaStatus, ctx, CreateConfig);
+ CHECK_VTABLE(vaStatus, ctx, DestroyConfig);
CHECK_VTABLE(vaStatus, ctx, GetConfigAttributes);
CHECK_VTABLE(vaStatus, ctx, CreateSurfaces);
CHECK_VTABLE(vaStatus, ctx, DestroySurface);
CHECK_VTABLE(vaStatus, ctx, SyncSurface);
CHECK_VTABLE(vaStatus, ctx, QuerySurfaceStatus);
CHECK_VTABLE(vaStatus, ctx, PutSurface);
- CHECK_VTABLE(vaStatus, ctx, CopySurfaceToGLXPbuffer);
CHECK_VTABLE(vaStatus, ctx, QueryImageFormats);
CHECK_VTABLE(vaStatus, ctx, CreateImage);
CHECK_VTABLE(vaStatus, ctx, DestroyImage);
CHECK_VTABLE(vaStatus, ctx, SetSubpictureChromakey);
CHECK_VTABLE(vaStatus, ctx, SetSubpictureGlobalAlpha);
CHECK_VTABLE(vaStatus, ctx, AssociateSubpicture);
+ CHECK_VTABLE(vaStatus, ctx, QueryDisplayAttributes);
+ CHECK_VTABLE(vaStatus, ctx, GetDisplayAttributes);
+ CHECK_VTABLE(vaStatus, ctx, SetDisplayAttributes);
CHECK_VTABLE(vaStatus, ctx, DbgCopySurfaceToBuffer);
}
if (VA_STATUS_SUCCESS != vaStatus)
return ctx->vtable.vaQueryConfigEntrypoints ( ctx, profile, entrypoints, num_entrypoints);
}
-VAStatus vaQueryConfigAttributes (
+VAStatus vaGetConfigAttributes (
VADisplay dpy,
VAProfile profile,
VAEntrypoint entrypoint,
VADriverContextP ctx = CTX(dpy);
ASSERT_CONTEXT(ctx);
- TRACE(vaQueryConfigAttributes);
- return ctx->vtable.vaQueryConfigAttributes ( ctx, profile, entrypoint, attrib_list, num_attribs );
+ TRACE(vaGetConfigAttributes);
+ return ctx->vtable.vaGetConfigAttributes ( ctx, profile, entrypoint, attrib_list, num_attribs );
}
VAStatus vaQueryConfigProfiles (
return ctx->vtable.vaCreateConfig ( ctx, profile, entrypoint, attrib_list, num_attribs, config_id );
}
-VAStatus vaGetConfigAttributes (
+VAStatus vaDestroyConfig (
+ VADisplay dpy,
+ VAConfigID config_id
+)
+{
+ VADriverContextP ctx = CTX(dpy);
+ ASSERT_CONTEXT(ctx);
+
+ TRACE(vaDestroyConfig);
+ return ctx->vtable.vaDestroyConfig ( ctx, config_id );
+}
+
+VAStatus vaQueryConfigAttributes (
VADisplay dpy,
VAConfigID config_id,
VAProfile *profile, /* out */
VADriverContextP ctx = CTX(dpy);
ASSERT_CONTEXT(ctx);
- TRACE(vaGetConfigAttributes);
- return ctx->vtable.vaGetConfigAttributes( ctx, config_id, profile, entrypoint, attrib_list, num_attribs);
+ TRACE(vaQueryConfigAttributes);
+ return ctx->vtable.vaQueryConfigAttributes( ctx, config_id, profile, entrypoint, attrib_list, num_attribs);
}
VAStatus vaCreateSurfaces (
unsigned short desth,
VARectangle *cliprects, /* client supplied clip list */
unsigned int number_cliprects, /* number of clip rects in the clip list */
- int flags /* de-interlacing flags */
+ unsigned int flags /* de-interlacing flags */
)
{
VADriverContextP ctx = CTX(dpy);
cliprects, number_cliprects, flags );
}
-VAStatus vaCopySurfaceToGLXPbuffer (
- VADisplay dpy,
- VASurface *surface,
- XID pbuffer_id,
- short srcx,
- short srcy,
- unsigned short width,
- unsigned short height,
- short destx,
- short desty,
- unsigned int draw_buffer,
- unsigned int flags /* de-interlacing flags */
-)
-{
- VADriverContextP ctx = CTX(dpy);
- ASSERT_CONTEXT(ctx);
-
- TRACE(vaCopySurfaceToGLXPbuffer);
- return ctx->vtable.vaCopySurfaceToGLXPbuffer( ctx, surface, pbuffer_id,
- srcx,srcy,width, height,destx,desty,
- draw_buffer, flags );
-}
-
/* Get maximum number of image formats supported by the implementation */
int vaMaxNumImageFormats (
VADisplay dpy
return ctx->vtable.vaAssociateSubpicture ( ctx, target_surface, subpicture, src_x, src_y, dest_x, dest_y, width, height, flags );
}
+/* Get maximum number of display attributes supported by the implementation */
+int vaMaxNumDisplayAttributes (
+ VADisplay dpy
+)
+{
+ VADriverContextP ctx = CTX(dpy);
+ ASSERT_CONTEXT(ctx);
+
+ return ctx->max_display_attributes;
+}
+
+/*
+ * Query display attributes
+ * The caller must provide a "attr_list" array that can hold at
+ * least vaMaxNumDisplayAttributes() entries. The actual number of attributes
+ * returned in "attr_list" is returned in "num_attributes".
+ */
+VAStatus vaQueryDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list, /* out */
+ int *num_attributes /* out */
+)
+{
+ VADriverContextP ctx = CTX(dpy);
+ ASSERT_CONTEXT(ctx);
+
+ TRACE(vaQueryDisplayAttributes);
+ return ctx->vtable.vaQueryDisplayAttributes ( ctx, attr_list, num_attributes );
+}
+
+/*
+ * Get display attributes
+ * This function returns the current attribute values in "attr_list".
+ * Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can have their values retrieved.
+ */
+VAStatus vaGetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list, /* in/out */
+ int num_attributes
+)
+{
+ VADriverContextP ctx = CTX(dpy);
+ ASSERT_CONTEXT(ctx);
+
+ TRACE(vaGetDisplayAttributes);
+ return ctx->vtable.vaGetDisplayAttributes ( ctx, attr_list, num_attributes );
+}
+
+/*
+ * Set display attributes
+ * Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can be set. If the attribute is not settable or
+ * the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
+ */
+VAStatus vaSetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+)
+{
+ VADriverContextP ctx = CTX(dpy);
+ ASSERT_CONTEXT(ctx);
+
+ TRACE(vaSetDisplayAttributes);
+ return ctx->vtable.vaSetDisplayAttributes ( ctx, attr_list, num_attributes );
+}
+
+
VAStatus vaDbgCopySurfaceToBuffer(VADisplay dpy,
VASurface *surface,
/*
* Video Decode Acceleration API Specification
*
- * Rev. 0.23
+ * Rev. 0.24
* <jonathan.bian@intel.com>
*
* Revision History:
* rev 0.21 (08/20/2007 Jonathan Bian) - Added image and subpicture support.
* rev 0.22 (08/27/2007 Jonathan Bian) - Added support for chroma-keying and global alpha.
* rev 0.23 (09/07/2007 Jonathan Bian) - Fixed some issues with images and subpictures.
+ * rev 0.24 (09/18/2007 Jonathan Bian) - Added display attributes.
*
* Acknowledgements:
* Some concepts borrowed from XvMC and XvImage.
#define VA_STATUS_ERROR_INVALID_CONTEXT 0x00000003
#define VA_STATUS_ERROR_INVALID_SURFACE 0x00000004
#define VA_STATUS_ERROR_INVALID_BUFFER 0x00000005
-#define VA_STATUS_ERROR_ATTR_NOT_SUPPORTED 0x00000006 /* Todo: Remove */
+#define VA_STATUS_ERROR_ATTR_NOT_SUPPORTED 0x00000006
#define VA_STATUS_ERROR_MAX_NUM_EXCEEDED 0x00000007
#define VA_STATUS_ERROR_UNSUPPORTED_PROFILE 0x00000008
#define VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT 0x00000009
);
/*
- * Query attributes for a given profile/entrypoint pair
+ * Get attributes for a given profile/entrypoint pair
* The caller must provide an \93attrib_list\94 with all attributes to be
* queried. Upon return, the attributes in \93attrib_list\94 have been
* updated with their value. Unknown attributes or attributes that are
* not supported for the given profile/entrypoint pair will have their
* value set to VA_ATTRIB_NOT_SUPPORTED
*/
-VAStatus vaQueryConfigAttributes (
+VAStatus vaGetConfigAttributes (
VADisplay dpy,
VAProfile profile,
VAEntrypoint entrypoint,
int num_attribs
);
-typedef int VAConfigID;
+/* Generic ID type, can be re-typed for specific implementation */
+typedef unsigned int VAGenericID;
+
+typedef VAGenericID VAConfigID;
/*
* Create a configuration for the decode pipeline
);
/*
- * Get all attributes for a given configuration
+ * Free resources associdated with a given config
+ */
+VAStatus vaDestroyConfig (
+ VADisplay dpy,
+ VAConfigID config_id
+);
+
+/*
+ * Query all attributes for a given configuration
* The profile of the configuration is returned in \93profile\94
* The entrypoint of the configuration is returned in \93entrypoint\94
* The caller must provide an \93attrib_list\94 array that can hold at least
* vaMaxNumConfigAttributes() entries. The actual number of attributes
* returned in \93attrib_list\94 is returned in \93num_attribs\94
*/
-VAStatus vaGetConfigAttributes (
+VAStatus vaQueryConfigAttributes (
VADisplay dpy,
VAConfigID config_id,
VAProfile *profile, /* out */
* Context represents a "virtual" video decode pipeline
*/
-/* generic context ID type, can be re-typed for specific implementation */
-typedef int VAContextID;
+typedef VAGenericID VAContextID;
-/* generic surface ID type, can be re-typed for specific implementation */
-typedef int VASurfaceID;
+typedef VAGenericID VASurfaceID;
#define VA_INVALID_SURFACE -1
*
*/
-typedef int VABufferID;
+typedef VAGenericID VABufferID;
typedef enum
{
};
unsigned char num_slice_groups_minus1;
unsigned char slice_group_map_type;
- unsigned char pic_init_qp_minus26;
- unsigned char chroma_qp_index_offset;
- unsigned char second_chroma_qp_index_offset;
+ 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 : 1;
- unsigned char transform_8x8_mode_flag : 1;
+ 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 int alpha_mask;
} VAImageFormat;
-typedef int VAImageID;
+typedef VAGenericID VAImageID;
typedef struct _VAImage
{
* DVD sub-titles or closed captioning text etc.
*/
-typedef int VASubpictureID;
+typedef VAGenericID VASubpictureID;
typedef struct _VASubpicture
{
unsigned short height;
} VARectangle;
+/*
+ * Display attributes
+ * Display attributes are used to control things such as contrast, hue, saturation,
+ * brightness etc. in the rendering process. The application can query what
+ * attributes are supported by the driver, and then set the appropriate attributes
+ * before calling vaPutSurface()
+ */
+
+/* Currently defined display attribute types */
+typedef enum
+{
+ VADisplayAttribBrightness = 0,
+ VADisplayAttribContrast = 1,
+ VADisplayAttribHue = 2,
+ VADisplayAttribSaturation = 3,
+} VADisplayAttribType;
+
+/* flags for VADisplayAttribute */
+#define VA_DISPLAY_ATTRIB_NOT_SUPPORTED 0x0000
+#define VA_DISPLAY_ATTRIB_GETTABLE 0x0001
+#define VA_DISPLAY_ATTRIB_SETTABLE 0x0002
+
+typedef struct _VADisplayAttribute
+{
+ VADisplayAttribType type;
+ int min_value;
+ int max_value;
+ int value; /* used by the set/get attribute functions */
+/* flags can be VA_DISPLAY_ATTRIB_GETTABLE or VA_DISPLAY_ATTRIB_SETTABLE or OR'd together */
+ unsigned int flags;
+} VADisplayAttribute;
+
+/* Get maximum number of display attributs supported by the implementation */
+int vaMaxNumDisplayAttributes (
+ VADisplay dpy
+);
+
+/*
+ * Query display attributes
+ * The caller must provide a "attr_list" array that can hold at
+ * least vaMaxNumDisplayAttributes() entries. The actual number of attributes
+ * returned in "attr_list" is returned in "num_attributes".
+ */
+VAStatus vaQueryDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list, /* out */
+ int *num_attributes /* out */
+);
+
+/*
+ * Get display attributes
+ * This function returns the current attribute values in "attr_list".
+ * Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can have their values retrieved.
+ */
+VAStatus vaGetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list, /* in/out */
+ int num_attributes
+);
+
+/*
+ * Set display attributes
+ * Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
+ * from vaQueryDisplayAttributes() can be set. If the attribute is not settable or
+ * the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
+ */
+VAStatus vaSetDisplayAttributes (
+ VADisplay dpy,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+);
+
#ifdef __cplusplus
}
#endif
/* Assuming finding VLD, find out the format for the render target */
VAConfigAttrib attrib;
attrib.type = VAConfigAttribRTFormat;
- vaQueryConfigAttributes(dpy, VAProfileMPEG2Main, VAEntrypointVLD,
+ vaGetConfigAttributes(dpy, VAProfileMPEG2Main, VAEntrypointVLD,
&attrib, 1);
if (attrib.value & VA_RT_FORMAT_YUV420)
VAImage sub_image;
VASubpicture subpicture;
unsigned char sub_data[128][16];
- /* fill sub_data with subtitle in AI44 */
- vaCreateImage(dpy, sub_formats, 128, 16,&sub_image);
+ /* create an image for the subtitle */
+ vaCreateImage(dpy, sub_formats, 128, 16, &sub_image);
+ vaCreateBuffer(dpy, VAImageBufferType, &sub_image->buf);
+ /* fill the image data */
+ vaBufferData(dpy, sub_image->buf, sub_image->data_size, sub_data);
vaCreateSubpicture(dpy, &sub_image, &subpicture);
unsigned char palette[3][16];
/* fill the palette data */
int max_attributes;
int max_image_formats;
int max_subpic_formats;
+ int max_display_attributes;
void *handle; /* dlopen handle */
void *pDriverData;
struct
int *num_entrypoints /* out */
);
- VAStatus (*vaQueryConfigAttributes) (
+ VAStatus (*vaGetConfigAttributes) (
VADriverContextP ctx,
VAProfile profile,
VAEntrypoint entrypoint,
VAConfigID *config_id /* out */
);
- VAStatus (*vaGetConfigAttributes) (
+ VAStatus (*vaDestroyConfig) (
+ VADriverContextP ctx,
+ VAConfigID config_id
+ );
+
+ VAStatus (*vaQueryConfigAttributes) (
VADriverContextP ctx,
VAConfigID config_id,
VAProfile *profile, /* out */
unsigned short desth,
VARectangle *cliprects, /* client supplied clip list */
unsigned int number_cliprects, /* number of clip rects in the clip list */
- int flags /* de-interlacing flags */
+ unsigned int flags /* de-interlacing flags */
);
- VAStatus (*vaCopySurfaceToGLXPbuffer) (
- VADriverContextP ctx,
- VASurface *surface,
- XID pbuffer_id,
- short srcx,
- short srcy,
- unsigned short width,
- unsigned short height,
- short destx,
- short desty,
- unsigned int draw_buffer,
- unsigned int flags /* de-interlacing flags */
- );
-
VAStatus (*vaQueryImageFormats) (
VADriverContextP ctx,
VAImageFormat *format_list, /* out */
unsigned int flags
);
+ VAStatus (*vaQueryDisplayAttributes) (
+ VADriverContextP ctx,
+ VADisplayAttribute *attr_list, /* out */
+ int *num_attributes /* out */
+ );
+
+ VAStatus (*vaGetDisplayAttributes) (
+ VADriverContextP ctx,
+ VADisplayAttribute *attr_list, /* in/out */
+ int num_attributes
+ );
+
+ VAStatus (*vaSetDisplayAttributes) (
+ VADriverContextP ctx,
+ VADisplayAttribute *attr_list,
+ int num_attributes
+ );
+
+
VAStatus (*vaDbgCopySurfaceToBuffer) (
VADriverContextP ctx,
VASurface *surface,
unsigned short desth,
VARectangle *cliprects, /* client supplied clip list */
unsigned int number_cliprects, /* number of clip rects in the clip list */
- int flags /* de-interlacing flags */
-);
-
-/*
- This function copies a rectangle of dimension "width" by "height"
- from the VASurface indicated by "surface" to the GLXPbuffer
- identified by its XID "pbuffer_id". The locations of source and
- destination rectangles are specified differently for the VASurface
- source and the GLXPbuffer destination as follows. On the VASurface,
- the rectangle location is specified in the usual X-Window fashion
- with srcx and srcy indicating the location of the upper left hand
- corner of the rectangle relative to the VASurface origin (the upper
- left hand corner of the XvMCSurface with positive Y axis going in the
- down direction). On the GLXPbuffer the rectangle location is
- specified in the usual OpenGL fashion with the dstx and dsty
- indicating the location of the lower left hand corner of the
- rectangle relative to the GLXPbuffer origin (the lower left hand
- corner of the GLXPbuffer with the positive Y axis going in the
- up direction).
-
- The "draw_buffer" takes the same OpenGL enums that glDrawBuffer()
- takes (ie. GL_FRONT_LEFT, GL_FRONT_RIGHT, GL_BACK_LEFT, GL_BACK_RIGHT,
- GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT or GL_FRONT_AND_BACK). This
- indicates which buffer of the GLXPbuffer is to be used for the
- destination of the copy. Buffers specified in the "draw_buffer"
- that do not exist in the GLXPbuffer are ignored.
-
- "flags" may be VA_TOP_FIELD, VA_BOTTOM_FIELD or VA_FRAME_PICTURE.
- If flags is not VA_FRAME_PICTURE, the srcy and height are in field
- coordinates, not frame. That is, the total copyable height is half
- the height of the VASurface.
-*/
-VAStatus vaCopySurfaceToGLXPbuffer (
- VADisplay dpy,
- VASurface *surface,
- XID pbuffer_id,
- short srcx,
- short srcy,
- unsigned short width,
- unsigned short height,
- short destx,
- short desty,
- unsigned int draw_buffer,
unsigned int flags /* de-interlacing flags */
);
-
#ifdef __cplusplus
}
#endif
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-check_PROGRAMS = test
-testdir = $(bindir)
+check_PROGRAMS = test_01 test_02 test_03 test_04 test_05 test_06 \
+ test_07 test_08 test_09 test_10 test_11
-# This gives better backtraces when running valgrind:
-# test_LDADD = ../src/libva.la ../../psb-video/src/psb_drv_video.la
-test_LDADD = ../src/libva.la
+testdir = $(bindir)
AM_CFLAGS = -I$(top_srcdir)/../../include/external/ -I$(top_srcdir)/src
-test_SOURCES = test.c
TESTS = $(check_PROGRAMS)
+
+TEST_LIBS = ../src/libva.la
+
+test_01_LDADD = $(TEST_LIBS)
+test_01_SOURCES = test_01.c
+
+test_02_LDADD = $(TEST_LIBS)
+test_02_SOURCES = test_02.c
+
+test_03_LDADD = $(TEST_LIBS)
+test_03_SOURCES = test_03.c
+
+test_04_LDADD = $(TEST_LIBS)
+test_04_SOURCES = test_04.c
+
+test_05_LDADD = $(TEST_LIBS)
+test_05_SOURCES = test_05.c
+
+test_06_LDADD = $(TEST_LIBS)
+test_06_SOURCES = test_06.c
+
+test_07_LDADD = $(TEST_LIBS)
+test_07_SOURCES = test_07.c
+
+test_08_LDADD = $(TEST_LIBS)
+test_08_SOURCES = test_08.c
+
+test_09_LDADD = $(TEST_LIBS)
+test_09_SOURCES = test_09.c
+
+test_10_LDADD = $(TEST_LIBS)
+test_10_SOURCES = test_10.c
+
+test_11_LDADD = $(TEST_LIBS)
+test_11_SOURCES = test_11.c
+
+
+valgrind: $(check_PROGRAMS)
+ for a in $(check_PROGRAMS); do \
+ valgrind --leak-check=full --show-reachable=yes .libs/$$a; \
+ done
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Initialize & Terminate"
+
+#include "test_common.c"
+
+void pre()
+{
+}
+
+void post()
+{
+}
+
+void test()
+{
+ test_init();
+
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Query profiles"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+}
+
+void test()
+{
+ test_profiles();
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Query entrypoints for all profiles"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+ test_profiles();
+}
+
+void test()
+{
+ int max_entrypoints;
+ int num_entrypoints;
+ int i, j;
+ max_entrypoints = vaMaxNumEntrypoints(va_dpy);
+ status("vaMaxEntryPoints = %d\n", max_entrypoints);
+ ASSERT(max_entrypoints > 0);
+
+ VAEntrypoint *entrypoints = malloc(max_entrypoints * sizeof(VAEntrypoint));
+ ASSERT(entrypoints);
+
+ for(i = 0; i < num_profiles; i++)
+ {
+ memset(entrypoints, 0xff, max_entrypoints * sizeof(VAEntrypoint));
+ va_status = vaQueryConfigEntrypoints(va_dpy, profiles[i], entrypoints, &num_entrypoints);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ status("vaQueryConfigEntryPoints(%s) reports %d entrypoints\n", profile2string(profiles[i]), num_entrypoints);
+ ASSERT(num_entrypoints <= max_entrypoints);
+ ASSERT(num_entrypoints > 0);
+ for(j = 0; j < num_entrypoints; j++)
+ {
+ status(" entrypoint %d [%s]\n", entrypoints[j], entrypoint2string(entrypoints[j]));
+ }
+ }
+
+ free(entrypoints);
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Get config attributes for all profiles / entrypoints"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+ test_profiles();
+}
+
+#define DEADVALUE 0xdeaddead
+
+void test()
+{
+ VAConfigAttrib attributes[] = {
+ { type: VAConfigAttribRTFormat, value: DEADVALUE },
+ { type: VAConfigAttribSpatialResidual, value: DEADVALUE },
+ { type: VAConfigAttribSpatialClipping, value: DEADVALUE },
+ { type: VAConfigAttribIntraResidual, value: DEADVALUE },
+ { type: VAConfigAttribEncryption, value: DEADVALUE }
+ };
+ int max_entrypoints;
+ int num_entrypoints;
+ int num_attribs = sizeof(attributes) / sizeof(VAConfigAttrib);
+ int i, j, k;
+ max_entrypoints = vaMaxNumEntrypoints(va_dpy);
+ ASSERT(max_entrypoints > 0);
+ VAEntrypoint *entrypoints = malloc(max_entrypoints * sizeof(VAEntrypoint));
+ ASSERT(entrypoints);
+
+ VAConfigAttrib *attrib_list = (VAConfigAttrib *) malloc(sizeof(attributes));
+ ASSERT(attrib_list);
+
+ for(i = 0; i < num_profiles; i++)
+ {
+ va_status = vaQueryConfigEntrypoints(va_dpy, profiles[i], entrypoints, &num_entrypoints);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ for(j = 0; j < num_entrypoints; j++)
+ {
+ memcpy(attrib_list, attributes, sizeof(attributes));
+ status("vaGetConfigAttributes for %s, %s\n", profile2string(profiles[i]), entrypoint2string(entrypoints[j]));
+ va_status = vaGetConfigAttributes(va_dpy, profiles[i], entrypoints[j], attrib_list, num_attribs);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ for(k = 0; k < num_attribs; k++)
+ {
+ status(" %d -> %08x\n", attrib_list[k].type, attrib_list[k].value);
+ ASSERT(attrib_list[k].value != DEADVALUE);
+ }
+ }
+ }
+
+ free(attrib_list);
+ free(entrypoints);
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Create/destroy configs for all profiles / entrypoints"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+ test_profiles();
+}
+
+void test()
+{
+ int max_entrypoints;
+ int num_entrypoints;
+ int i, j, k;
+ int config_count = 0;
+ max_entrypoints = vaMaxNumEntrypoints(va_dpy);
+ ASSERT(max_entrypoints > 0);
+ VAEntrypoint *entrypoints = malloc(max_entrypoints * sizeof(VAEntrypoint));
+ ASSERT(entrypoints);
+
+ VAConfigID *configs = malloc(max_entrypoints * num_profiles * sizeof(VAConfigID));
+
+ for(i = 0; i < num_profiles; i++)
+ {
+ va_status = vaQueryConfigEntrypoints(va_dpy, profiles[i], entrypoints, &num_entrypoints);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ for(j = 0; j < num_entrypoints; j++)
+ {
+ status("vaCreateConfig for %s, %s\n", profile2string(profiles[i]), entrypoint2string(entrypoints[j]));
+ va_status = vaCreateConfig(va_dpy, profiles[i], entrypoints[j], NULL, 0, &(configs[config_count]));
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ status("vaCreateConfig returns %08x\n", configs[config_count]);
+ config_count++;
+ }
+ }
+
+ for(i = 0; i < config_count; i++)
+ {
+ status("vaDestroyConfig for config %08x\n", configs[i]);
+ va_status = vaDestroyConfig( va_dpy, configs[i] );
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ }
+
+ free(configs);
+ free(entrypoints);
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Get config attributes from configs"
+
+#include "test_common.c"
+
+int max_entrypoints;
+VAEntrypoint *entrypoints;
+
+VAConfigID *configs;
+int config_count = 0;
+
+
+
+void pre()
+{
+ int i, j, k;
+
+ test_init();
+ test_profiles();
+
+ max_entrypoints = vaMaxNumEntrypoints(va_dpy);
+ ASSERT(max_entrypoints > 0);
+ entrypoints = malloc(max_entrypoints * sizeof(VAEntrypoint));
+ ASSERT(entrypoints);
+
+ configs = malloc(max_entrypoints * num_profiles * sizeof(VAConfigID));
+ ASSERT(configs);
+
+ // Create configs
+ for(i = 0; i < num_profiles; i++)
+ {
+ int num_entrypoints;
+ va_status = vaQueryConfigEntrypoints(va_dpy, profiles[i], entrypoints, &num_entrypoints);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ for(j = 0; j < num_entrypoints; j++)
+ {
+ va_status = vaCreateConfig(va_dpy, profiles[i], entrypoints[j], NULL, 0, &(configs[config_count]));
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ config_count++;
+ }
+ }
+}
+
+void test()
+{
+ int i, j, k;
+ int max_attribs;
+
+ max_attribs = vaMaxNumConfigAttributes(va_dpy);
+ ASSERT(max_attribs > 0);
+
+ VAConfigAttrib *attrib_list = malloc(max_attribs * sizeof(VAConfigAttrib));
+
+ config_count = 0;
+ for(i = 0; i < num_profiles; i++)
+ {
+ int num_entrypoints;
+
+ va_status = vaQueryConfigEntrypoints(va_dpy, profiles[i], entrypoints, &num_entrypoints);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ for(j = 0; j < num_entrypoints; j++)
+ {
+ VAProfile profile= -1;
+ VAEntrypoint entrypoint = -1;
+ int num_attribs = -1;
+
+ status("Checking vaQueryConfigAttributes for %s, %s\n", profile2string(profiles[i]), entrypoint2string(entrypoints[j]));
+ memset(attrib_list, 0xff, max_attribs * sizeof(VAConfigAttrib));
+
+ va_status = vaQueryConfigAttributes(va_dpy, configs[config_count], &profile, &entrypoint, attrib_list, &num_attribs);
+ config_count++;
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ ASSERT( profile == profiles[i] );
+ ASSERT( entrypoint == entrypoints[j] );
+ ASSERT( num_attribs >= 0 );
+ for(k = 0; k < num_attribs; k++)
+ {
+ status(" %d -> %08x\n", attrib_list[k].type, attrib_list[k].value);
+ ASSERT(attrib_list[k].value != VA_ATTRIB_NOT_SUPPORTED);
+ }
+ }
+ }
+
+ free(attrib_list);
+}
+
+void post()
+{
+ int i;
+ for(i = 0; i < config_count; i++)
+ {
+ va_status = vaDestroyConfig( va_dpy, configs[i] );
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ }
+
+ free(configs);
+ free(entrypoints);
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Create and destory surfaces"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+}
+
+#define DEAD_SURFACE_ID (VASurfaceID) 0xbeefdead
+
+void test_unique_surfaces(VASurface *surface_list1, int surface_count1, VASurface *surface_list2, int surface_count2)
+{
+ int i,j;
+
+ for(i = 0; i < surface_count1; i++)
+ {
+ for(j = 0; j < surface_count2; j++)
+ {
+ if ((surface_list1 == surface_list2) && (i == j)) continue;
+ ASSERT(surface_list1[i].surface_id != VA_INVALID_SURFACE);
+ ASSERT(surface_list2[j].surface_id != VA_INVALID_SURFACE);
+ ASSERT(surface_list1[i].surface_id != surface_list2[j].surface_id);
+ }
+ }
+}
+
+
+void test()
+{
+ VASurface surfaces_1[1+1];
+ VASurface surfaces_4[4+1];
+ VASurface surfaces_16[16+1];
+ VASurface surfaces_6[6+1];
+
+ memset(surfaces_1, 0xff, sizeof(surfaces_1));
+ memset(surfaces_4, 0xff, sizeof(surfaces_4));
+ memset(surfaces_16, 0xff, sizeof(surfaces_16));
+ memset(surfaces_6, 0xff, sizeof(surfaces_6));
+
+ status("vaCreateSurfaces 1 surface\n");
+ surfaces_1[1].surface_id = DEAD_SURFACE_ID;
+ va_status = vaCreateSurfaces(va_dpy, 352, 288, VA_RT_FORMAT_YUV420, 1, surfaces_1);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ ASSERT( DEAD_SURFACE_ID == surfaces_1[1].surface_id ); /* bounds check */
+
+ status("vaCreateSurfaces 4 surfaces\n");
+ surfaces_4[4].surface_id = DEAD_SURFACE_ID;
+ va_status = vaCreateSurfaces(va_dpy, 352, 288, VA_RT_FORMAT_YUV420, 4, surfaces_4);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ ASSERT( DEAD_SURFACE_ID == surfaces_4[4].surface_id ); /* bounds check */
+
+ status("vaCreateSurfaces 16 surfaces\n");
+ surfaces_16[16].surface_id = DEAD_SURFACE_ID;
+ va_status = vaCreateSurfaces(va_dpy, 352, 288, VA_RT_FORMAT_YUV420, 16, surfaces_16);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ ASSERT( DEAD_SURFACE_ID == surfaces_16[16].surface_id ); /* bounds check */
+
+ test_unique_surfaces(surfaces_1, 1, surfaces_4, 4);
+ test_unique_surfaces(surfaces_4, 4, surfaces_16, 4);
+ test_unique_surfaces(surfaces_4, 4, surfaces_16, 16);
+ test_unique_surfaces(surfaces_4, 1, surfaces_16, 16);
+ test_unique_surfaces(surfaces_1, 16, surfaces_16, 16);
+
+ status("vaDestroySurface 4 surfaces\n");
+ va_status = vaDestroySurface(va_dpy, surfaces_4, 4);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ status("vaCreateSurfaces 6 surfaces\n");
+ surfaces_6[6].surface_id = DEAD_SURFACE_ID;
+ va_status = vaCreateSurfaces(va_dpy, 352, 288, VA_RT_FORMAT_YUV420, 6, surfaces_6);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ ASSERT( DEAD_SURFACE_ID == surfaces_6[6].surface_id ); /* bounds check */
+
+ test_unique_surfaces(surfaces_1, 1, surfaces_6, 6);
+ test_unique_surfaces(surfaces_6, 6, surfaces_16, 16);
+ test_unique_surfaces(surfaces_1, 6, surfaces_16, 6);
+
+ status("vaDestroySurface 16 surfaces\n");
+ va_status = vaDestroySurface(va_dpy, surfaces_16, 16);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ status("vaDestroySurface 1 surface\n");
+ va_status = vaDestroySurface(va_dpy, surfaces_1, 1);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ status("vaDestroySurface 6 surfaces\n");
+ va_status = vaDestroySurface(va_dpy, surfaces_6, 6);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Create and destory surfaces of different sizes"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+}
+
+#define DEAD_SURFACE_ID (VASurfaceID) 0xbeefdead
+
+void test_unique_surfaces(VASurface *surface_list, int surface_count)
+{
+ int i,j;
+
+ for(i = 0; i < surface_count; i++)
+ {
+ ASSERT(surface_list[i].surface_id != VA_INVALID_SURFACE);
+ for(j = 0; j < i; j++)
+ {
+ if (i == j) continue;
+ ASSERT(surface_list[i].surface_id != surface_list[j].surface_id);
+ }
+ }
+}
+
+typedef struct test_size { int w; int h; } test_size_t;
+
+test_size_t test_sizes[] = {
+ { 10, 10 },
+ { 128, 128 },
+ { 176, 144 },
+ { 144, 176 },
+ { 352, 288 },
+ { 399, 299 },
+ { 640, 480 },
+ { 1280, 720 }
+};
+
+#define NUM_SIZES (sizeof(test_sizes) / sizeof(test_size_t))
+
+void test()
+{
+ VASurface surfaces[NUM_SIZES+1];
+ int i;
+
+ memset(surfaces, 0xff, sizeof(surfaces));
+
+ for(i = 0; i < NUM_SIZES; i++)
+ {
+ status("vaCreateSurfaces create %dx%d surface\n", test_sizes[i].w, test_sizes[i].h);
+ surfaces[i+1].surface_id = DEAD_SURFACE_ID;
+ va_status = vaCreateSurfaces(va_dpy, test_sizes[i].w, test_sizes[i].h, VA_RT_FORMAT_YUV420, 1, &surfaces[i]);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ ASSERT( DEAD_SURFACE_ID == surfaces[i+1].surface_id );
+ }
+
+ test_unique_surfaces(surfaces, NUM_SIZES);
+
+ status("vaDestroySurface all surfaces\n");
+ va_status = vaDestroySurface(va_dpy, surfaces, NUM_SIZES);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Create/destroy contexts for all profiles / entrypoints"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+ test_profiles();
+}
+
+void test()
+{
+ int max_entrypoints;
+ int num_entrypoints;
+ int i, j, k;
+ int config_count = 0;
+ max_entrypoints = vaMaxNumEntrypoints(va_dpy);
+ ASSERT(max_entrypoints > 0);
+ VAEntrypoint *entrypoints = malloc(max_entrypoints * sizeof(VAEntrypoint));
+ ASSERT(entrypoints);
+
+ VAConfigID *configs = malloc(max_entrypoints * num_profiles * sizeof(VAConfigID));
+ VAContext *contexts = malloc(max_entrypoints * num_profiles * sizeof(VAContext));
+
+ for(i = 0; i < num_profiles; i++)
+ {
+ va_status = vaQueryConfigEntrypoints(va_dpy, profiles[i], entrypoints, &num_entrypoints);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ for(j = 0; j < num_entrypoints; j++)
+ {
+ status("vaCreateConfig for %s, %s\n", profile2string(profiles[i]), entrypoint2string(entrypoints[j]));
+ va_status = vaCreateConfig(va_dpy, profiles[i], entrypoints[j], NULL, 0, &(configs[config_count]));
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ status("vaCreateConfig returns %08x\n", configs[config_count]);
+ config_count++;
+ }
+ }
+
+ int width = 352;
+ int height = 288;
+ int surface_count = 4;
+ int total_surfaces = config_count * surface_count;
+
+ VASurface *surfaces = malloc(total_surfaces * sizeof(VASurface));
+
+ // TODO: Don't assume VA_RT_FORMAT_YUV420 is supported / needed for each config
+ va_status = vaCreateSurfaces(va_dpy, width, height, VA_RT_FORMAT_YUV420, total_surfaces, surfaces);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ for(i = 0; i < config_count; i++)
+ {
+ status("vaCreateContext with config %08x\n", configs[i]);
+ int flags = 0;
+ va_status = vaCreateContext( va_dpy, configs[i], width, height, flags, surfaces + i*surface_count, surface_count, &contexts[i] );
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ }
+
+ for(i = 0; i < config_count; i++)
+ {
+ status("vaDestroyContext for context %08x\n", contexts[i].context_id);
+ va_status = vaDestroyContext( va_dpy, &contexts[i] );
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ }
+
+ for(i = 0; i < config_count; i++)
+ {
+ status("vaDestroyConfig for config %08x\n", configs[i]);
+ va_status = vaDestroyConfig( va_dpy, configs[i] );
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ }
+
+ va_status = vaDestroySurface(va_dpy, surfaces, total_surfaces);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ free(contexts);
+ free(configs);
+ free(surfaces);
+ free(entrypoints);
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Create and destroy buffers"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+}
+
+void test_unique_buffers(VABufferID *buffer_list, int buffer_count)
+{
+ int i,j;
+
+ for(i = 0; i < buffer_count; i++)
+ {
+ for(j = 0; j < i; j++)
+ {
+ ASSERT(buffer_list[i] != buffer_list[j]);
+ }
+ }
+}
+
+VABufferType buffer_types[] =
+{
+ VAPictureParameterBufferType,
+ VAIQMatrixBufferType,
+ VABitPlaneBufferType,
+ VASliceGroupMapBufferType,
+ VASliceParameterBufferType,
+ VASliceDataBufferType,
+ VAMacroblockParameterBufferType,
+ VAResidualDataBufferType,
+ VADeblockingParameterBufferType,
+ VAImageBufferType
+};
+
+#define NUM_BUFFER_TYPES (sizeof(buffer_types) / sizeof(VABufferType))
+
+#define DEAD_BUFFER_ID ((VABufferID) 0x1234ffff)
+
+void test()
+{
+ VABufferID buffer_ids[NUM_BUFFER_TYPES+1];
+ int i;
+ memset(buffer_ids, 0xff, sizeof(buffer_ids));
+ for(i=0; i < NUM_BUFFER_TYPES; i++)
+ {
+ buffer_ids[i+1] = DEAD_BUFFER_ID;
+ va_status = vaCreateBuffer(va_dpy, buffer_types[i], &buffer_ids[i]);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ ASSERT( DEAD_BUFFER_ID == buffer_ids[i+1] ); /* Bounds check */
+ }
+ test_unique_buffers(buffer_ids, NUM_BUFFER_TYPES);
+
+ for(i=0; i < NUM_BUFFER_TYPES; i++)
+ {
+ va_status = vaDestroyBuffer(va_dpy, buffer_ids[i]);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ }
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TEST_DESCRIPTION "Map and unmap buffers"
+
+#include "test_common.c"
+
+void pre()
+{
+ test_init();
+}
+
+VABufferType buffer_types[] =
+{
+ VAPictureParameterBufferType,
+ VAIQMatrixBufferType,
+ VABitPlaneBufferType,
+ VASliceGroupMapBufferType,
+ VASliceParameterBufferType,
+ VASliceDataBufferType,
+ VAMacroblockParameterBufferType,
+ VAResidualDataBufferType,
+ VADeblockingParameterBufferType,
+ VAImageBufferType
+};
+
+unsigned int buffer_sizes[] =
+{
+ sizeof(VAPictureParameterBufferMPEG4),
+ sizeof(VAIQMatrixBufferH264),
+ 32*1024,
+ 48*1024,
+ sizeof(VASliceParameterBufferMPEG2),
+ 128*1024,
+ sizeof(VAMacroblockParameterBufferMPEG2),
+ 32*1024,
+ 15*1024,
+ 32*1024,
+};
+
+#define NUM_BUFFER_TYPES (sizeof(buffer_types) / sizeof(VABufferType))
+
+void test()
+{
+ VABufferID buffer_ids[NUM_BUFFER_TYPES+1];
+ uint32_t *input_data[NUM_BUFFER_TYPES];
+ int i, j;
+ memset(buffer_ids, 0xff, sizeof(buffer_ids));
+ for(i=0; i < NUM_BUFFER_TYPES; i++)
+ {
+ uint32_t *data;
+ va_status = vaCreateBuffer(va_dpy, buffer_types[i], &buffer_ids[i]);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ status("vaCreateBuffer created buffer %08x of type %d\n", buffer_ids[i], buffer_types[i]);
+
+ input_data[i] = malloc(buffer_sizes[i]+4);
+ ASSERT(input_data[i]);
+
+ /* Generate input data */
+ for(j = buffer_sizes[i] / 4; j--;)
+ {
+ input_data[i][j] = random();
+ }
+
+ /* Copy to secondary buffer */
+ data = malloc(buffer_sizes[i]);
+ ASSERT(data);
+ memcpy(data, input_data[i], buffer_sizes[i]);
+
+ /* Send to VA Buffer */
+ va_status = vaBufferData(va_dpy, buffer_ids[i], buffer_sizes[i], 1, data);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ /* Wipe secondary buffer */
+ memset(data, 0, buffer_sizes[i]);
+ free(data);
+ }
+
+ for(i=0; i < NUM_BUFFER_TYPES; i++)
+ {
+ void *data = NULL;
+ /* Fetch VA Buffer */
+ va_status = vaBufferData(va_dpy, buffer_ids[i], buffer_sizes[i], 1, NULL);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ va_status = vaMapBuffer(va_dpy, buffer_ids[i], &data);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ status("vaMapBuffer mapped buffer %08x\n", buffer_ids[i]);
+
+ /* Compare data */
+ ASSERT( memcmp(input_data[i], data, buffer_sizes[i]) == 0 );
+ }
+
+ for(i=0; i < NUM_BUFFER_TYPES; i++)
+ {
+ va_status = vaUnmapBuffer(va_dpy, buffer_ids[i]);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ va_status = vaDestroyBuffer(va_dpy, buffer_ids[i]);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ free(input_data[i]);
+ }
+}
+
+void post()
+{
+ test_terminate();
+}
--- /dev/null
+/*
+ * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "va.h"
+#include "X11/Xlib.h"
+
+#include "assert.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <dlfcn.h>
+
+#define ASSERT assert
+
+Display *dpy;
+VADisplay va_dpy;
+VAStatus va_status;
+int major_version, minor_version;
+int print_status = 0;
+int num_profiles;
+VAProfile *profiles = NULL;
+
+void pre();
+void test();
+void post();
+
+void status(const char *msg, ...)
+{
+ if (!print_status) return;
+ va_list args;
+ printf("--- ");
+ va_start(args, msg);
+ vfprintf(stdout, msg, args);
+ va_end(args);
+}
+
+
+int main(int argc, const char* argv[])
+{
+ const char *name = rindex(argv[0], '/');
+ if (name)
+ name++;
+ else
+ name = argv[0];
+ printf("*** %s: %s\n", name, TEST_DESCRIPTION);
+ pre();
+ print_status = 1;
+ test();
+ print_status = 0;
+ post();
+ printf("*** %s: Finished\n", name);
+ return 0;
+}
+
+void test_init()
+{
+ dpy = XOpenDisplay(NULL);
+ ASSERT( dpy );
+ status("XOpenDisplay: dpy = %08x\n", dpy);
+
+ va_dpy = vaGetDisplay(dpy);
+ ASSERT( va_dpy );
+ status("vaGetDisplay: va_dpy = %08x\n", va_dpy);
+
+ va_status = vaInitialize(va_dpy, &major_version, &minor_version);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ status("vaInitialize: major = %d minor = %d\n", major_version, minor_version);
+}
+
+void test_terminate()
+{
+ va_status = vaTerminate(va_dpy);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+ status("vaTerminate\n");
+
+ XCloseDisplay(dpy);
+ status("XCloseDisplay\n");
+
+ if (profiles)
+ {
+ free(profiles);
+ profiles = NULL;
+ }
+}
+
+#define PROFILE(profile) case VAProfile##profile: return("VAProfile" #profile);
+
+const char *profile2string(VAProfile profile)
+{
+ switch(profile)
+ {
+ PROFILE(MPEG2Simple)
+ PROFILE(MPEG2Main)
+ PROFILE(MPEG4Simple)
+ PROFILE(MPEG4AdvancedSimple)
+ PROFILE(MPEG4Main)
+ PROFILE(H264Baseline)
+ PROFILE(H264Main)
+ PROFILE(H264High)
+ PROFILE(VC1Simple)
+ PROFILE(VC1Main)
+ PROFILE(VC1Advanced)
+ }
+ ASSERT(0);
+ return "Unknown";
+}
+
+#define ENTRYPOINT(profile) case VAEntrypoint##profile: return("VAEntrypoint" #profile);
+
+const char *entrypoint2string(VAEntrypoint entrypoint)
+{
+ switch(entrypoint)
+ {
+ ENTRYPOINT(VLD)
+ ENTRYPOINT(IZZ)
+ ENTRYPOINT(IDCT)
+ ENTRYPOINT(MoComp)
+ ENTRYPOINT(Deblocking)
+ }
+ ASSERT(0);
+ return "Unknown";
+}
+
+
+void test_profiles()
+{
+ int max_profiles;
+ int i;
+ max_profiles = vaMaxNumProfiles(va_dpy);
+ status("vaMaxNumProfiles = %d\n", max_profiles);
+ ASSERT(max_profiles > 0);
+ profiles = malloc(max_profiles * sizeof(VAProfile));
+ ASSERT(profiles);
+
+ va_status = vaQueryConfigProfiles(va_dpy, profiles, &num_profiles);
+ ASSERT( VA_STATUS_SUCCESS == va_status );
+
+ status("vaQueryConfigProfiles reports %d profiles\n", num_profiles);
+ ASSERT(num_profiles <= max_profiles);
+ ASSERT(num_profiles > 0);
+
+ if (print_status)
+ {
+ for(i = 0; i < num_profiles; i++)
+ {
+ status(" profile %d [%s]\n", profiles[i], profile2string(profiles[i]));
+ }
+ }
+}
--- /dev/null
+
+Test 1
+- Initialize & Terminate
+- vaGetDisplay, vaInitialize, vaTerminate
+
+Test 2
+- Query profiles
+- vaQueryConfigProfiles, vaMaxNumProfiles
+
+Test 3
+- Query Entrypoints for all profiles
+- vaQueryConfigEntryPoints, vaMaxNumEntryPoints
+
+Test 4
+- Get Config attributes for all profiles / entrypoints
+- vaGetConfigAttributes
+
+Test 5
+- Create & destroy config for each profile / entrypoint
+- vaCreateConfig, vaDestroyConfig
+
+Test 6
+- Get config attributes of various possible configs
+- vaQueryConfigAttributes, vaMaxNumConfigAttributes
+- Check if results for vaGetConfigAttributes match with vaQueryConfigAttributes for
+a given profile / entrypoint
+
+Test 7
+- Create and destroy surfaces
+- vaCreateSurfaces, vaDestroySurface
+- Create surfaces of 352 x 288 pixels
+- Create 1, 4 and 16 surfaces, destroy 4, create 6 surfaces, destroy 16, 1
+and 6 surfaces.
+
+Test 8
+- Create and destroy surfaces of different sizes
+- Create surfaces of 10 x 10 pixels, 128 x 128 pixels, 176 x 144 pixels, 144 x 176
+pixels, 352 x 288 pixels, 399 x 299 pixels, 640 x 480 pixels, 1280 x 720
+pixels
+
+Test 9
+- Create and destroy a context for each profile / entrypoint
+- Pass 4 surfaces of 352 x 288 pixels
+- vaCreateContext, vaDestroyContext
+- See also Test 5
+
+Test 10
+- Create and destroy buffers
+- vaCreateBuffer, vaDestroyBuffer
+- For each different buffertype, create a buffer, then destroy them one by
+one.
+
+Test 11
+- Map & unmap buffers
+- vaBufferData, vaMapBuffer, vaUnmapBuffer
+- For each different buffertype, copy data to the buffer with vaBufferData.
+Then map the buffer and verify the contents of the buffer.
+
+Test 12
+- Render single MPEG2 I-frame
+- vaBeginPicture, vaRenderPicture (num_buffers == 1), vaEndPicture
+
+Test 13
+- Render single MPEG2 I-frame, multiple buffer submission
+- vaRenderPicture (num_buffers > 1)
+
+Test 14
+- Render single MPEG2 I-frame, split buffers
+- Slice split over 2 buffers
+
+Test 15
+- Render single MPEG2 I-frame, split buffers
+- Slice split over 3 buffers
+
+Test 16
+- Sync Surface
+- Render single MPEG2 I-frame, then check vaQuerySurfaceStatus, vaSyncSurface and vaQuerySurfaceStatus
+
+Test 17
+- Query image formats
+- vaMaxNumImageFormats, vaQueryImageFormats
+
+Test 18
+- Create and destroy vaImage
+- vaCreateImage, vaDestroyImage
+
+Test 19
+- Get image data
+- Render single MPEG2 I-frame, copy surface data to image, check resulting
+image
+- vaGetImage
+
+Test 20
+- Put image data
+- Render single MPEG2 I-frame, copy half of a VAImage to surface, copy
+surface back to VAImage, check resulting image
+- vaPutImage
+
+Test 21
+- Query subpicture formats
+- vaMaxNumSubpictureFormats, vaQuerySubpictureFromats
+
+Test 22
+- Create and destory subpictures
+- vaCreateSubpicture, vaDestroySubpicture
+
OSDN Git Service
