Initial commit of libva 69/269/1
authorroot <root@localhost.localdomain>
Tue, 19 Jun 2007 23:09:11 +0000 (16:09 -0700)
committerroot <root@localhost.localdomain>
Tue, 19 Jun 2007 23:09:11 +0000 (16:09 -0700)
36 files changed:
.cvsignore [new file with mode: 0644]
Makefile.am [new file with mode: 0644]
autogen.sh [new file with mode: 0755]
configure.ac [new file with mode: 0644]
debian/README.Debian [new file with mode: 0644]
debian/changelog [new file with mode: 0644]
debian/compat [new file with mode: 0644]
debian/control [new file with mode: 0644]
debian/copyright [new file with mode: 0644]
debian/dirs [new file with mode: 0644]
debian/docs [new file with mode: 0644]
debian/files [new file with mode: 0644]
debian/libva-dev.dirs [new file with mode: 0644]
debian/libva-dev.install [new file with mode: 0644]
debian/libva-dev.substvars [new file with mode: 0644]
debian/libva1.dirs [new file with mode: 0644]
debian/libva1.install [new file with mode: 0644]
debian/libva1.substvars [new file with mode: 0644]
debian/rules [new file with mode: 0755]
dummy_drv_video/Makefile.am [new file with mode: 0644]
dummy_drv_video/dummy_drv_video.c [new file with mode: 0644]
dummy_drv_video/dummy_drv_video.h [new file with mode: 0644]
dummy_drv_video/object_heap.c [new file with mode: 0644]
dummy_drv_video/object_heap.h [new file with mode: 0644]
libva.pc.in [new file with mode: 0644]
src/Makefile.am [new file with mode: 0644]
src/XF86dri.c [new file with mode: 0644]
src/dri_interface.h [new file with mode: 0644]
src/va.c [new file with mode: 0644]
src/va.h [new file with mode: 0755]
src/va_backend.h [new file with mode: 0755]
src/va_x11.h [new file with mode: 0755]
src/xf86dri.h [new file with mode: 0644]
src/xf86dristr.h [new file with mode: 0644]
test/Makefile.am [new file with mode: 0644]
test/test.c [new file with mode: 0644]

diff --git a/.cvsignore b/.cvsignore
new file mode 100644 (file)
index 0000000..68156f9
--- /dev/null
@@ -0,0 +1,3 @@
+*~
+Makefile.in
+Makefile
diff --git a/Makefile.am b/Makefile.am
new file mode 100644 (file)
index 0000000..e9a4031
--- /dev/null
@@ -0,0 +1,10 @@
+#  @COPYRIGHT@ Intel Confidential - Unreleased Software
+# 
+
+AUTOMAKE_OPTIONS = foreign
+SUBDIRS = src dummy_drv_video test
+
+pkgconfigdir = @pkgconfigdir@
+pkgconfig_DATA = libva.pc
+
+EXTRA_DIST = libva.pc.in
diff --git a/autogen.sh b/autogen.sh
new file mode 100755 (executable)
index 0000000..904cd67
--- /dev/null
@@ -0,0 +1,12 @@
+#! /bin/sh
+
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+cd $srcdir
+
+autoreconf -v --install || exit 1
+cd $ORIGDIR || exit $?
+
+$srcdir/configure --enable-maintainer-mode "$@"
diff --git a/configure.ac b/configure.ac
new file mode 100644 (file)
index 0000000..2017e47
--- /dev/null
@@ -0,0 +1,22 @@
+#  @COPYRIGHT@ Intel Confidential - Unreleased Software
+
+AC_PREREQ(2.57)
+AC_INIT([libva], 0.1, [waldo.bastian@intel.com], libva)
+AC_CONFIG_SRCDIR([Makefile.am])
+AM_INIT_AUTOMAKE([dist-bzip2])
+
+AM_CONFIG_HEADER([src/config.h])
+
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
+AC_PROG_CC
+
+AC_HEADER_STDC
+AC_SYS_LARGEFILE
+
+PKG_CHECK_MODULES([libva_la], [libdrm])
+
+pkgconfigdir=${libdir}/pkgconfig
+AC_SUBST(pkgconfigdir)
+
+AC_OUTPUT([Makefile src/Makefile dummy_drv_video/Makefile test/Makefile libva.pc])
diff --git a/debian/README.Debian b/debian/README.Debian
new file mode 100644 (file)
index 0000000..d10d702
--- /dev/null
@@ -0,0 +1,7 @@
+libva for Debian
+----------------
+
+This library implements the Video Acceleration (VA) API for Linux.
+It will load a hardware dependendent video acceleration driver.
+
+ -- Waldo Bastian <waldo.bastian@intel.com>  Mon, 18 Jun 2007 21:35:31 -0700
diff --git a/debian/changelog b/debian/changelog
new file mode 100644 (file)
index 0000000..b834347
--- /dev/null
@@ -0,0 +1,6 @@
+libva (0.18-1) unstable; urgency=low
+
+  * Initial release of libva
+
+ -- Waldo Bastian <waldo.bastian@intel.com>  Mon, 18 Jun 2007 21:35:31 -0700
+
diff --git a/debian/compat b/debian/compat
new file mode 100644 (file)
index 0000000..7ed6ff8
--- /dev/null
@@ -0,0 +1 @@
+5
diff --git a/debian/control b/debian/control
new file mode 100644 (file)
index 0000000..3a415bd
--- /dev/null
@@ -0,0 +1,34 @@
+Source: libva
+Priority: extra
+Maintainer: Waldo Bastian <waldo.bastian@intel.com>
+Build-Depends: debhelper (>= 5),
+               autotools-dev,
+               libdrm-dev (>= 2.3.0),
+               mesa-common-dev,
+               x11proto-gl-dev,
+               pkg-config
+Standards-Version: 3.7.2
+Section: libs
+
+Package: libva-dev
+Section: libdevel
+Architecture: any
+Depends: libva1 (= ${binary:Version}),
+         libdrm-dev (>= 2.3.0),
+         pkg-config
+Description: Video Acceleration (VA) API for Linux -- development files
+ The libva library implements the Video Acceleration (VA) API for Linux.
+ The library loads a hardware dependendent driver.
+ .
+ This package provides the development environment for libva.
+
+Package: libva1
+Section: libs
+Architecture: any
+Depends: ${shlibs:Depends},
+         ${misc:Depends},
+         libdrm2 (>= 2.3.0)
+Description: Video Acceleration (VA) API for Linux -- runtime
+ The libva library implements the Video Acceleration (VA) API for Linux.
+ The library loads a hardware dependendent driver.
+
diff --git a/debian/copyright b/debian/copyright
new file mode 100644 (file)
index 0000000..38b60ef
--- /dev/null
@@ -0,0 +1,44 @@
+This package was debianized by Waldo Bastian <waldo.bastian@intel.com> on
+Mon, 18 Jun 2007 21:35:31 -0700.
+
+It was downloaded from <url://example.com>
+
+Upstream Author(s): 
+
+    Waldo Bastian <waldo.bastian@intel.com>
+    Jonathan Bian <jonathan.bian@intel.com>
+
+Copyright: 
+
+    (C) Copyright IBM Corporation 2004
+    Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+    Copyright 2000 VA Linux Systems, Inc.
+    Copyright 2007 Intel Corportation
+
+License:
+
+    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.
+
+The Debian packaging is (C) 2007, Intel Corporation and
+is licensed under the GPL, see `/usr/share/common-licenses/GPL'.
+
+# Please also look if there are files or directories which have a
+# different copyright/license attached and list them here.
diff --git a/debian/dirs b/debian/dirs
new file mode 100644 (file)
index 0000000..ca882bb
--- /dev/null
@@ -0,0 +1,2 @@
+usr/bin
+usr/sbin
diff --git a/debian/docs b/debian/docs
new file mode 100644 (file)
index 0000000..e69de29
diff --git a/debian/files b/debian/files
new file mode 100644 (file)
index 0000000..b47d914
--- /dev/null
@@ -0,0 +1,2 @@
+libva-dev_0.18-1_i386.deb libdevel extra
+libva1_0.18-1_i386.deb libs extra
diff --git a/debian/libva-dev.dirs b/debian/libva-dev.dirs
new file mode 100644 (file)
index 0000000..4418816
--- /dev/null
@@ -0,0 +1,2 @@
+usr/lib
+usr/include
diff --git a/debian/libva-dev.install b/debian/libva-dev.install
new file mode 100644 (file)
index 0000000..d2e402c
--- /dev/null
@@ -0,0 +1,6 @@
+debian/tmp/usr/include/va.h
+debian/tmp/usr/include/va_x11.h
+debian/tmp/usr/lib/dummy_drv_video.*
+debian/tmp/usr/lib/libva.la
+debian/tmp/usr/lib/libva.so
+debian/tmp/usr/lib/pkgconfig/libva.pc
diff --git a/debian/libva-dev.substvars b/debian/libva-dev.substvars
new file mode 100644 (file)
index 0000000..ca71235
--- /dev/null
@@ -0,0 +1 @@
+shlibs:Depends=libc6 (>= 2.5-5)
diff --git a/debian/libva1.dirs b/debian/libva1.dirs
new file mode 100644 (file)
index 0000000..6845771
--- /dev/null
@@ -0,0 +1 @@
+usr/lib
diff --git a/debian/libva1.install b/debian/libva1.install
new file mode 100644 (file)
index 0000000..bad195c
--- /dev/null
@@ -0,0 +1 @@
+debian/tmp/usr/lib/libva.so.*
diff --git a/debian/libva1.substvars b/debian/libva1.substvars
new file mode 100644 (file)
index 0000000..b165906
--- /dev/null
@@ -0,0 +1 @@
+shlibs:Depends=libc6 (>= 2.5-5), libx11-6, libxext6
diff --git a/debian/rules b/debian/rules
new file mode 100755 (executable)
index 0000000..60fbc95
--- /dev/null
@@ -0,0 +1,114 @@
+#!/usr/bin/make -f
+# -*- makefile -*-
+# Sample debian/rules that uses debhelper.
+# This file was originally written by Joey Hess and Craig Small.
+# As a special exception, when this file is copied by dh-make into a
+# dh-make output file, you may use that output file without restriction.
+# This special exception was added by Craig Small in version 0.37 of dh-make.
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+
+# These are used for cross-compiling and for saving the configure script
+# from having to guess our platform (since we know it already)
+DEB_HOST_GNU_TYPE   ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
+DEB_BUILD_GNU_TYPE  ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)
+
+
+CFLAGS = -Wall -g
+
+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
+       CFLAGS += -O0
+else
+       CFLAGS += -O2
+endif
+
+# shared library versions, option 1
+#version=2.0.5
+#major=2
+# option 2, assuming the library is created as src/.libs/libfoo.so.2.0.5 or so
+version=`ls src/.libs/lib*.so.* | \
+ awk '{if (match($$0,/[0-9]+\.[0-9]+\.[0-9]+$$/)) print substr($$0,RSTART)}'`
+#major=`ls src/.libs/lib*.so.* | \
+# awk '{if (match($$0,/\.so\.[0-9]+$$/)) print substr($$0,RSTART+4)}'`
+
+config.status: configure
+       dh_testdir
+       # Add here commands to configure the package.
+ifneq "$(wildcard /usr/share/misc/config.sub)" ""
+       cp -f /usr/share/misc/config.sub config.sub
+endif
+ifneq "$(wildcard /usr/share/misc/config.guess)" ""
+       cp -f /usr/share/misc/config.guess config.guess
+endif
+       ./configure --host=$(DEB_HOST_GNU_TYPE) --build=$(DEB_BUILD_GNU_TYPE) --prefix=/usr --mandir=\$${prefix}/share/man --infodir=\$${prefix}/share/info CFLAGS="$(CFLAGS)" LDFLAGS="-Wl,-z,defs"
+
+
+build: build-stamp
+build-stamp:  config.status
+       dh_testdir
+
+       # Add here commands to compile the package.
+       $(MAKE)
+
+       touch $@
+
+clean:
+       dh_testdir
+       dh_testroot
+       rm -f build-stamp 
+
+       # Add here commands to clean up after the build process.
+       -$(MAKE) distclean
+       rm -f config.sub config.guess
+
+       dh_clean 
+
+install: build
+       dh_testdir
+       dh_testroot
+       dh_clean -k 
+       dh_installdirs
+
+       # Add here commands to install the package into debian/tmp
+       $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
+
+
+# Build architecture-independent files here.
+binary-indep: build install
+# We have nothing to do by default.
+
+# Build architecture-dependent files here.
+binary-arch: build install
+       dh_testdir
+       dh_testroot
+       dh_installchangelogs 
+       dh_installdocs
+       dh_installexamples
+       dh_install
+#      dh_installmenu
+#      dh_installdebconf       
+#      dh_installlogrotate
+#      dh_installemacsen
+#      dh_installpam
+#      dh_installmime
+#      dh_installinit
+#      dh_installcron
+#      dh_installinfo
+       dh_installman
+       dh_link
+       dh_strip
+       dh_compress
+       dh_fixperms
+#      dh_perl
+#      dh_python
+#      dh_makeshlibs
+       dh_installdeb
+       dh_shlibdeps
+       dh_gencontrol
+       dh_md5sums
+       dh_builddeb
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary install 
diff --git a/dummy_drv_video/Makefile.am b/dummy_drv_video/Makefile.am
new file mode 100644 (file)
index 0000000..6e47a84
--- /dev/null
@@ -0,0 +1,10 @@
+#  @COPYRIGHT@ Intel Confidential - Unreleased Software
+
+dummy_drv_video_la_LTLIBRARIES = dummy_drv_video.la
+dummy_drv_video_ladir = $(libdir)
+dummy_drv_video_la_LDFLAGS = -no-undefined -module
+dummy_drv_video_la_LIBADD = 
+
+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
+
diff --git a/dummy_drv_video/dummy_drv_video.c b/dummy_drv_video/dummy_drv_video.c
new file mode 100644 (file)
index 0000000..cd5ee9c
--- /dev/null
@@ -0,0 +1,923 @@
+/*
+ * @COPYRIGHT@ Intel Confidential - Unreleased Software
+ */
+
+#include "va_backend.h"
+
+#include "dummy_drv_video.h"
+
+#include "assert.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define ASSERT assert
+
+#define INIT_DRIVER_DATA       struct dummy_driver_data *driver_data = (struct dummy_driver_data *) ctx->pDriverData;
+
+#define CONFIG(id)  ((object_config_p) object_heap_lookup( &driver_data->config_heap, id ))
+#define CONTEXT(id) ((object_context_p) object_heap_lookup( &driver_data->context_heap, id ))
+#define SURFACE(id)    ((object_surface_p) object_heap_lookup( &driver_data->surface_heap, id ))
+#define BUFFER(id)  ((object_buffer_p) object_heap_lookup( &driver_data->buffer_heap, id ))
+
+#define CONFIG_ID_OFFSET               0x01000000
+#define CONTEXT_ID_OFFSET              0x02000000
+#define SURFACE_ID_OFFSET              0x04000000
+#define BUFFER_ID_OFFSET               0x08000000
+
+static void dummy__error_message(const char *msg, ...)
+{
+    va_list args;
+
+    fprintf(stderr, "dummy_drv_video error: ");
+    va_start(args, msg);
+    vfprintf(stderr, msg, args);
+    va_end(args);
+}
+
+static void dummy__information_message(const char *msg, ...)
+{
+    va_list args;
+
+    fprintf(stderr, "dummy_drv_video: ");
+    va_start(args, msg);
+    vfprintf(stderr, msg, args);
+    va_end(args);
+}
+
+VAStatus dummy_QueryConfigProfiles(
+               VADriverContextP ctx,
+               VAProfile *profile_list,        /* out */
+               int *num_profiles                       /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    int i = 0;
+    
+    profile_list[i++] = VAProfileMPEG2Simple;
+    profile_list[i++] = VAProfileMPEG2Main;
+    profile_list[i++] = VAProfileMPEG4Simple;
+    profile_list[i++] = VAProfileMPEG4AdvancedSimple;
+    profile_list[i++] = VAProfileMPEG4Main;
+    profile_list[i++] = VAProfileH264Baseline;
+    profile_list[i++] = VAProfileH264Main;
+    profile_list[i++] = VAProfileH264High;
+    profile_list[i++] = VAProfileVC1Simple;
+    profile_list[i++] = VAProfileVC1Main;
+    profile_list[i++] = VAProfileVC1Advanced;
+
+    /* If the assert fails then DUMMY_MAX_PROFILES needs to be bigger */
+    ASSERT(i <= DUMMY_MAX_PROFILES);
+    *num_profiles = i;
+
+       return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_QueryConfigEntrypoints(
+               VADriverContextP ctx,
+               VAProfile profile,
+               VAEntrypoint  *entrypoint_list, /* out */
+               int *num_entrypoints            /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    
+    switch (profile) {
+        case VAProfileMPEG2Simple:
+        case VAProfileMPEG2Main:
+                *num_entrypoints = 2;
+                entrypoint_list[0] = VAEntrypointVLD;
+                entrypoint_list[1] = VAEntrypointMoComp;
+                break;
+
+        case VAProfileMPEG4Simple:
+        case VAProfileMPEG4AdvancedSimple:
+        case VAProfileMPEG4Main:
+                *num_entrypoints = 1;
+                entrypoint_list[0] = VAEntrypointVLD;
+                break;
+
+        case VAProfileH264Baseline:
+        case VAProfileH264Main:
+        case VAProfileH264High:
+                *num_entrypoints = 1;
+                entrypoint_list[0] = VAEntrypointVLD;
+                break;
+
+        case VAProfileVC1Simple:
+        case VAProfileVC1Main:
+        case VAProfileVC1Advanced:
+                *num_entrypoints = 1;
+                entrypoint_list[0] = VAEntrypointVLD;
+                break;
+
+        default:
+                *num_entrypoints = 0;
+                break;
+    }
+
+    /* If the assert fails then DUMMY_MAX_ENTRYPOINTS needs to be bigger */
+    ASSERT(*num_entrypoints <= DUMMY_MAX_ENTRYPOINTS);
+       return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_QueryConfigAttributes(
+               VADriverContextP ctx,
+               VAProfile profile,
+               VAEntrypoint entrypoint,
+               VAConfigAttrib *attrib_list,    /* in/out */
+               int num_attribs
+       )
+{
+    INIT_DRIVER_DATA
+
+    int i;
+
+    /* Other attributes don't seem to be defined */
+    /* What to do if we don't know the attribute? */
+    for (i = 0; i < num_attribs; i++)
+    {
+        switch (attrib_list[i].type)
+        {
+          case VAConfigAttribRTFormat:
+              attrib_list[i].value = VA_RT_FORMAT_YUV420;
+              break;
+              
+          default:
+              /* Do nothing */
+              attrib_list[i].value = VA_ATTRIB_NOT_SUPPORTED;
+              break;
+        }
+    }
+
+       return VA_STATUS_SUCCESS;
+}
+
+static VAStatus dummy__update_attribute(object_config_p obj_config, VAConfigAttrib *attrib)
+{
+    int i;
+    /* Check existing attrbiutes */
+    for(i = 0; obj_config->attrib_count < i; i++)
+    {
+        if (obj_config->attrib_list[i].type == attrib->type)
+        {
+            /* Update existing attribute */
+            obj_config->attrib_list[i].value = attrib->value;
+            return VA_STATUS_SUCCESS;
+        }
+    }
+    if (obj_config->attrib_count < DUMMY_MAX_CONFIG_ATTRIBUTES)
+    {
+        i = obj_config->attrib_count;
+        obj_config->attrib_list[i].type = attrib->type;
+        obj_config->attrib_list[i].value = attrib->value;
+        obj_config->attrib_count++;
+        return VA_STATUS_SUCCESS;
+    }
+    return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
+}
+
+VAStatus dummy_CreateConfig(
+               VADriverContextP ctx,
+               VAProfile profile, 
+               VAEntrypoint entrypoint, 
+               VAConfigAttrib *attrib_list,
+               int num_attribs,
+               VAConfigID *config_id           /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus;
+    int configID;
+    object_config_p obj_config;
+    int i;
+    
+    /* Validate profile & entrypoint */
+    switch (profile) {
+        case VAProfileMPEG2Simple:
+        case VAProfileMPEG2Main:
+                if ((VAEntrypointVLD == entrypoint) ||
+                    (VAEntrypointMoComp == entrypoint))
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        case VAProfileMPEG4Simple:
+        case VAProfileMPEG4AdvancedSimple:
+        case VAProfileMPEG4Main:
+                if (VAEntrypointVLD == entrypoint)
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        case VAProfileH264Baseline:
+        case VAProfileH264Main:
+        case VAProfileH264High:
+                if (VAEntrypointVLD == entrypoint)
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        case VAProfileVC1Simple:
+        case VAProfileVC1Main:
+        case VAProfileVC1Advanced:
+                if (VAEntrypointVLD == entrypoint)
+                {
+                    vaStatus = VA_STATUS_SUCCESS;
+                }
+                else
+                {
+                    vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
+                }
+                break;
+
+        default:
+                vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
+                break;
+    }
+
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        return vaStatus;
+    }
+
+    configID = object_heap_allocate( &driver_data->config_heap );
+    obj_config = CONFIG(configID);
+    if (NULL == obj_config)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+        return vaStatus;
+    }
+
+    obj_config->profile = profile;
+    obj_config->entrypoint = entrypoint;
+    obj_config->attrib_list[0].type = VAConfigAttribRTFormat;
+    obj_config->attrib_list[0].value = VA_RT_FORMAT_YUV420;
+    obj_config->attrib_count = 1;
+
+    for(i = 0; i < num_attribs; i++)
+    {
+        vaStatus = dummy__update_attribute(obj_config, &(attrib_list[i]));
+        if (VA_STATUS_SUCCESS != vaStatus)
+        {
+            break;
+        }
+    }
+    
+    /* Error recovery */
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
+    }
+    else
+    {
+        *config_id = configID;
+    }
+
+       return vaStatus;
+}
+       
+VAStatus dummy_GetConfigAttributes(
+               VADriverContextP ctx,
+               VAConfigID config_id, 
+               VAProfile *profile,             /* out */
+               VAEntrypoint *entrypoint,       /* out */
+               VAConfigAttrib *attrib_list,    /* out */
+               int *num_attribs                /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_config_p obj_config;
+    int i;
+
+    obj_config = CONFIG(config_id);
+    ASSERT(obj_config);
+    
+    *profile = obj_config->profile;
+    *entrypoint = obj_config->entrypoint;
+    *num_attribs =  obj_config->attrib_count;
+    for(i = 0; i < obj_config->attrib_count; i++)
+    {
+        attrib_list[i] = obj_config->attrib_list[i];
+    }
+    
+       return vaStatus;
+}
+
+VAStatus dummy_CreateSurfaces(
+               VADriverContextP ctx,
+               int width,
+               int height,
+               int format,
+               int num_surfaces,
+               VASurface *surfaces             /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    int i;
+    
+    /* We only support one format */
+    if (VA_RT_FORMAT_YUV420 != format)
+    {
+        return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
+    }
+    
+    for (i = 0; i < num_surfaces; i++)
+    {
+        int surfaceID = object_heap_allocate( &driver_data->surface_heap );
+        object_surface_p obj_surface = SURFACE(surfaceID);
+        if (NULL == obj_surface)
+        {
+            vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+            break;
+        }
+        obj_surface->surface = &(surfaces[i]);
+        obj_surface->surface->surface_id = surfaceID;
+        obj_surface->surface->context_id = -1;
+        obj_surface->surface->width = width;
+        obj_surface->surface->height = height;
+        obj_surface->surface->format = format;
+        obj_surface->surface->privData = NULL;
+    }
+
+    /* Error recovery */
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        /* surfaces[i-1] was the last successful allocation */
+        for(; i--; )
+        {
+            object_surface_p obj_surface = SURFACE(surfaces[i].surface_id);
+            surfaces[i].surface_id = -1;
+            ASSERT(obj_surface);
+            object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface);
+        }
+    }
+
+       return vaStatus;
+}
+       
+VAStatus dummy_DestroySurface(
+               VADriverContextP ctx,
+               VASurface *surface_list,
+               int num_surfaces
+       )
+{
+    INIT_DRIVER_DATA
+    int i;
+    for(i = num_surfaces; i--; )
+    {
+        object_surface_p obj_surface = SURFACE(surface_list[i].surface_id);
+        ASSERT(obj_surface);
+        object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface);
+    }
+       return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_CreateContext(
+               VADriverContextP ctx,
+               VAConfigID config_id,
+               int picture_width,
+               int picture_height,
+               int flag,
+               VASurface *render_targets,
+               int num_render_targets,
+               VAContext *context              /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_config_p obj_config;
+    int i;
+
+    obj_config = CONFIG(config_id);
+    if (NULL == obj_config)
+    {
+        vaStatus = VA_STATUS_ERROR_INVALID_CONFIG;
+        return vaStatus;
+    }
+    
+    /* Validate flag */
+    /* Validate picture dimensions */
+
+    int contextID = object_heap_allocate( &driver_data->context_heap );
+    object_context_p obj_context = CONTEXT(contextID);
+    if (NULL == obj_context)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+        return vaStatus;
+    }
+
+    obj_context->context = context;
+    obj_context->current_render_target = -1;
+    
+    obj_context->context->context_id = contextID;
+    obj_context->context->config_id = config_id;
+    obj_context->context->picture_width = picture_width;
+    obj_context->context->picture_height = picture_height;
+    obj_context->context->num_render_targets = num_render_targets;
+    obj_context->context->render_targets = (VASurfaceID *) malloc(num_render_targets * sizeof(VASurfaceID));
+    for(i = 0; i < num_render_targets; i++)
+    {
+        if (NULL == SURFACE(render_targets[i].surface_id))
+        {
+            vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
+            break;
+        }
+        obj_context->context->render_targets[i] = render_targets[i].surface_id;
+    }
+    obj_context->context->flags = flag;
+    obj_context->context->privData = NULL;
+
+    /* Error recovery */
+    if (VA_STATUS_SUCCESS != vaStatus)
+    {
+        free(obj_context->context->render_targets);
+        obj_context->context->render_targets = NULL;
+        obj_context->context->context_id = -1;
+        obj_context->context->config_id = -1;
+        obj_context->context->picture_width = 0;
+        obj_context->context->picture_height = 0;
+        free(obj_context->context->render_targets);
+        obj_context->context->render_targets = NULL;
+        obj_context->context->num_render_targets = 0;
+        obj_context->context->flags = 0;
+        obj_context->context->privData = NULL;
+        object_heap_free( &driver_data->context_heap, (object_base_p) obj_context);
+    }
+
+       return vaStatus;
+}
+
+
+VAStatus dummy_DestroyContext(
+               VADriverContextP ctx,
+               VAContext *context
+       )
+{
+    INIT_DRIVER_DATA
+    object_context_p obj_context = CONTEXT(context->context_id);
+    ASSERT(obj_context);
+    
+    obj_context->context->context_id = -1;
+    obj_context->context->config_id = -1;
+    obj_context->context->picture_width = 0;
+    obj_context->context->picture_height = 0;
+    if (obj_context->context->render_targets)
+    {
+        free(obj_context->context->render_targets);
+    }
+    obj_context->context->render_targets = NULL;
+    obj_context->context->num_render_targets = 0;
+    obj_context->context->flags = 0;
+    obj_context->context->privData = NULL;
+
+    obj_context->context = NULL;
+    obj_context->current_render_target = -1;
+
+    object_heap_free( &driver_data->context_heap, (object_base_p) obj_context);
+
+       return VA_STATUS_SUCCESS;
+}
+
+
+VAStatus dummy_CreateBuffer(
+               VADriverContextP ctx,
+               VABufferType type,  /* in */
+               VABufferID *buf_desc    /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    int bufferID;
+    object_buffer_p obj_buffer;
+    
+    /* Validate type */
+    switch (type)
+    {
+        case VAPictureParameterBufferType:
+        case VAPictureBitPlaneBufferType:
+        case VAIQMatrixBufferType:
+        case VASliceParameterBufferType:
+        case VASliceDataBufferType:
+        case VAMacroblockParameterBufferType:
+        case VAResidualDataBufferType:
+        case VADeblockingParameterBufferType:
+            /* Ok */
+            break;
+        default:
+            vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
+            return vaStatus;
+    }
+
+    bufferID = object_heap_allocate( &driver_data->buffer_heap );
+    obj_buffer = BUFFER(bufferID);
+    if (NULL == obj_buffer)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+        return vaStatus;
+    }
+
+    obj_buffer->buffer_data = NULL;
+    
+    *buf_desc = bufferID;
+
+       return vaStatus;
+}
+
+static VAStatus dummy__allocate_buffer(object_buffer_p obj_buffer, int size)
+{
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+
+    obj_buffer->buffer_data = realloc(obj_buffer->buffer_data, size);
+    if (NULL == obj_buffer->buffer_data)
+    {
+        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
+    }
+    return vaStatus;
+}
+
+VAStatus dummy_BufferData(
+               VADriverContextP ctx,
+               VABufferID buf_id,      /* in */
+        unsigned int size,     /* in */
+        unsigned int num_elements,     /* in */
+        void *data             /* in */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_buffer_p obj_buffer = BUFFER(buf_id);
+    ASSERT(obj_buffer);
+    
+    vaStatus = dummy__allocate_buffer(obj_buffer, size * num_elements);
+    if (VA_STATUS_SUCCESS == vaStatus)
+    {
+        obj_buffer->max_num_elements = num_elements;
+        obj_buffer->num_elements = num_elements;
+        if (data)
+        {
+            memcpy(obj_buffer->buffer_data, data, size * num_elements);
+        }
+    }
+
+       return vaStatus;
+}
+
+VAStatus dummy_BufferSetNumElements(
+               VADriverContextP ctx,
+               VABufferID buf_id,      /* in */
+        unsigned int num_elements      /* in */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_buffer_p obj_buffer = BUFFER(buf_id);
+    ASSERT(obj_buffer);
+    
+    if ((num_elements < 0) || (num_elements > obj_buffer->max_num_elements))
+    {
+        vaStatus = VA_STATUS_ERROR_UNKNOWN;
+    }
+    if (VA_STATUS_SUCCESS == vaStatus)
+    {
+        obj_buffer->num_elements = num_elements;
+    }
+
+       return vaStatus;
+}
+
+VAStatus dummy_MapBuffer(
+               VADriverContextP ctx,
+               VABufferID buf_id,      /* in */
+               void **pbuf         /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
+    object_buffer_p obj_buffer = BUFFER(buf_id);
+    ASSERT(obj_buffer);
+    if (NULL == obj_buffer)
+    {
+        vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
+        return vaStatus;
+    }
+    
+    if (NULL != obj_buffer->buffer_data)
+    {
+        *pbuf = obj_buffer->buffer_data;
+        vaStatus = VA_STATUS_SUCCESS;
+    }
+       return vaStatus;
+}
+
+VAStatus dummy_UnmapBuffer(
+               VADriverContextP ctx,
+               VABufferID buf_id       /* in */
+       )
+{
+    /* Do nothing */
+       return VA_STATUS_SUCCESS;
+}
+
+static void dummy__destroy_buffer(struct dummy_driver_data *driver_data, object_buffer_p obj_buffer)
+{
+    if (NULL != obj_buffer->buffer_data)
+    {
+        free(obj_buffer->buffer_data);
+        obj_buffer->buffer_data = NULL;
+    }
+    
+    object_heap_free( &driver_data->buffer_heap, (object_base_p) obj_buffer);
+}
+
+VAStatus dummy_DestroyBuffer(
+               VADriverContextP ctx,
+               VABufferID buffer_id
+       )
+{
+    INIT_DRIVER_DATA
+    object_buffer_p obj_buffer = BUFFER(buffer_id);
+    ASSERT(obj_buffer);
+
+    dummy__destroy_buffer(driver_data, obj_buffer);
+       return VA_STATUS_SUCCESS;
+}
+
+VAStatus dummy_BeginPicture(
+               VADriverContextP ctx,
+               VAContext *context,
+               VASurface *render_target
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+    
+    obj_context = CONTEXT(context->context_id);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(render_target->surface_id);
+    ASSERT(obj_surface);
+
+    obj_context->current_render_target = obj_surface->base.id;
+    
+       return vaStatus;
+}
+
+VAStatus dummy_RenderPicture(
+               VADriverContextP ctx,
+               VAContext *context,
+               VABufferID *buffers,
+               int num_buffers
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+    int i;
+    
+    obj_context = CONTEXT(context->context_id);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(obj_context->current_render_target);
+    ASSERT(obj_surface);
+    
+    /* verify that we got valid buffer references */
+    for(i = 0; i < num_buffers; i++)
+    {
+        object_buffer_p obj_buffer = BUFFER(buffers[i]);
+        ASSERT(obj_buffer);
+        if (NULL == obj_buffer)
+        {
+            vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
+            break;
+        }
+    }
+
+       return vaStatus;
+}
+
+VAStatus dummy_EndPicture(
+               VADriverContextP ctx,
+               VAContext *context
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+    
+    obj_context = CONTEXT(context->context_id);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(obj_context->current_render_target);
+    ASSERT(obj_surface);
+    
+    // For now, assume that we are done with rendering right away
+    obj_context->current_render_target = -1;
+
+       return vaStatus;
+}
+
+
+VAStatus dummy_SyncSurface(
+               VADriverContextP ctx,
+               VAContext *context,
+               VASurface *render_target
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+    
+    obj_context = CONTEXT(context->context_id);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(render_target->surface_id);
+    ASSERT(obj_surface);
+
+    /* Assume that this shouldn't be called before vaEndPicture() */
+    ASSERT( obj_context->current_render_target != obj_surface->base.id );
+    
+       return vaStatus;
+}
+
+VAStatus dummy_QuerySurfaceStatus(
+               VADriverContextP ctx,
+               VAContext *context,
+               VASurface *render_target,
+               VASurfaceStatus *status /* out */
+       )
+{
+    INIT_DRIVER_DATA
+    VAStatus vaStatus = VA_STATUS_SUCCESS;
+    object_context_p obj_context;
+    object_surface_p obj_surface;
+    
+    obj_context = CONTEXT(context->context_id);
+    ASSERT(obj_context);
+
+    obj_surface = SURFACE(render_target->surface_id);
+    ASSERT(obj_surface);
+
+    /* Assume that we are busy until vaEndPicture() is called */
+    if ( obj_context->current_render_target == obj_surface->base.id )
+    {
+        *status = VASurfaceRendering;
+    }
+    else
+    {
+        *status = VASurfaceReady;
+    }
+    
+       return vaStatus;
+}
+
+VAStatus dummy_PutSurface(
+               VADriverContextP ctx,
+               VASurface *surface,
+               Drawable draw, /* X Drawable */
+               short srcx,
+               short srcy,
+               unsigned short srcw,
+               unsigned short srch,
+               short destx,
+               short desty,
+               unsigned short destw,
+               unsigned short desth,
+               int flags /* de-interlacing flags */
+       )
+{
+    /* TODO */
+       return VA_STATUS_ERROR_UNKNOWN;
+}
+
+VAStatus dummy_DbgCopySurfaceToBuffer(
+               VADriverContextP ctx,
+               VASurface *surface,
+               void **buffer, /* out */
+               unsigned int *stride /* out */
+       )
+{
+    /* TODO */
+       return VA_STATUS_ERROR_UNKNOWN;
+}
+
+VAStatus dummy_Terminate( VADriverContextP ctx )
+{
+    INIT_DRIVER_DATA
+    object_buffer_p obj_buffer;
+    object_surface_p obj_surface;
+    object_context_p obj_context;
+    object_config_p obj_config;
+    object_heap_iterator iter;
+
+    /* Clean up left over buffers */
+    obj_buffer = (object_buffer_p) object_heap_first( &driver_data->buffer_heap, &iter);
+    while (obj_buffer)
+    {
+        dummy__information_message("vaTerminate: bufferID %08x still allocated, destroying\n", obj_buffer->base.id);
+        dummy__destroy_buffer(driver_data, obj_buffer);
+        obj_buffer = (object_buffer_p) object_heap_next( &driver_data->buffer_heap, &iter);
+    }
+    object_heap_destroy( &driver_data->buffer_heap );
+
+    /* TODO cleanup */
+    object_heap_destroy( &driver_data->surface_heap );
+    
+    /* TODO cleanup */
+    object_heap_destroy( &driver_data->context_heap );
+
+    /* Clean up configIDs */
+    obj_config = (object_config_p) object_heap_first( &driver_data->config_heap, &iter);
+    while (obj_config)
+    {
+        object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
+        obj_config = (object_config_p) object_heap_next( &driver_data->config_heap, &iter);
+    }
+    object_heap_destroy( &driver_data->config_heap );
+
+    free(ctx->pDriverData);
+    ctx->pDriverData = NULL;
+
+       return VA_STATUS_SUCCESS;
+}
+
+VAStatus __vaDriverInit_0_18(  VADriverContextP ctx )
+{
+    object_base_p obj;
+    int result;
+    struct dummy_driver_data *driver_data;
+    int i;
+    
+    ctx->version_major = 0;
+    ctx->version_minor = 18;
+    ctx->max_profiles = DUMMY_MAX_PROFILES;
+    ctx->max_entrypoints = DUMMY_MAX_ENTRYPOINTS;
+    ctx->max_attributes = DUMMY_MAX_CONFIG_ATTRIBUTES;
+
+       ctx->vtable.vaTerminate = dummy_Terminate;
+       ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
+       ctx->vtable.vaTerminate = dummy_Terminate;
+       ctx->vtable.vaQueryConfigProfiles = dummy_QueryConfigProfiles;
+       ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
+       ctx->vtable.vaQueryConfigAttributes = dummy_QueryConfigAttributes;
+       ctx->vtable.vaCreateConfig = dummy_CreateConfig;
+       ctx->vtable.vaGetConfigAttributes = dummy_GetConfigAttributes;
+       ctx->vtable.vaCreateSurfaces = dummy_CreateSurfaces;
+       ctx->vtable.vaDestroySurface = dummy_DestroySurface;
+       ctx->vtable.vaCreateContext = dummy_CreateContext;
+       ctx->vtable.vaDestroyContext = dummy_DestroyContext;
+       ctx->vtable.vaCreateBuffer = dummy_CreateBuffer;
+       ctx->vtable.vaBufferData = dummy_BufferData;
+       ctx->vtable.vaBufferSetNumElements = dummy_BufferSetNumElements;
+       ctx->vtable.vaMapBuffer = dummy_MapBuffer;
+       ctx->vtable.vaUnmapBuffer = dummy_UnmapBuffer;
+       ctx->vtable.vaDestroyBuffer = dummy_DestroyBuffer;
+       ctx->vtable.vaBeginPicture = dummy_BeginPicture;
+       ctx->vtable.vaRenderPicture = dummy_RenderPicture;
+       ctx->vtable.vaEndPicture = dummy_EndPicture;
+       ctx->vtable.vaSyncSurface = dummy_SyncSurface;
+       ctx->vtable.vaQuerySurfaceStatus = dummy_QuerySurfaceStatus;
+       ctx->vtable.vaPutSurface = dummy_PutSurface;
+       ctx->vtable.vaDbgCopySurfaceToBuffer = dummy_DbgCopySurfaceToBuffer;
+
+       driver_data = (struct dummy_driver_data *) malloc( sizeof(*driver_data) );
+    ctx->pDriverData = (void *) driver_data;
+    
+    result = object_heap_init( &driver_data->config_heap, sizeof(struct object_config), CONFIG_ID_OFFSET );
+    ASSERT( result == 0 );
+
+    result = object_heap_init( &driver_data->context_heap, sizeof(struct object_context), CONTEXT_ID_OFFSET );
+    ASSERT( result == 0 );
+
+    result = object_heap_init( &driver_data->surface_heap, sizeof(struct object_surface), SURFACE_ID_OFFSET );
+    ASSERT( result == 0 );
+
+    result = object_heap_init( &driver_data->buffer_heap, sizeof(struct object_buffer), BUFFER_ID_OFFSET );
+    ASSERT( result == 0 );
+
+
+    return VA_STATUS_SUCCESS;
+}
+
diff --git a/dummy_drv_video/dummy_drv_video.h b/dummy_drv_video/dummy_drv_video.h
new file mode 100644 (file)
index 0000000..07b67b7
--- /dev/null
@@ -0,0 +1,54 @@
+/*
+ * @COPYRIGHT@ Intel Confidential - Unreleased Software
+ */
+
+#ifndef _DUMMY_DRV_VIDEO_H_
+#define _DUMMY_DRV_VIDEO_H_
+
+#include "va.h"
+#include "object_heap.h"
+
+#define DUMMY_MAX_PROFILES                             11
+#define DUMMY_MAX_ENTRYPOINTS                  5
+#define DUMMY_MAX_CONFIG_ATTRIBUTES            10
+
+struct dummy_driver_data {
+    struct object_heap config_heap;
+    struct object_heap context_heap;
+    struct object_heap surface_heap;
+    struct object_heap buffer_heap;
+};
+
+struct object_config {
+    struct object_base base;
+    VAProfile profile;
+    VAEntrypoint entrypoint;
+    VAConfigAttrib attrib_list[DUMMY_MAX_CONFIG_ATTRIBUTES];
+    int attrib_count;
+};
+
+struct object_context {
+    struct object_base base;
+    VAContext *context;
+    VAConfigID config;
+    VASurfaceID current_render_target;
+};
+
+struct object_surface {
+    struct object_base base;
+    VASurface *surface;
+};
+
+struct object_buffer {
+    struct object_base base;
+    void *buffer_data;
+    int max_num_elements;
+    int num_elements;
+};
+
+typedef struct object_config *object_config_p;
+typedef struct object_context *object_context_p;
+typedef struct object_surface *object_surface_p;
+typedef struct object_buffer *object_buffer_p;
+
+#endif /* _DUMMY_DRV_VIDEO_H_ */
diff --git a/dummy_drv_video/object_heap.c b/dummy_drv_video/object_heap.c
new file mode 100644 (file)
index 0000000..af7ad17
--- /dev/null
@@ -0,0 +1,172 @@
+/*
+ * @COPYRIGHT@ Intel Confidential - Unreleased Software
+ */
+
+#include "object_heap.h"
+
+#include "assert.h"
+#include <stdio.h>
+#include <string.h>
+
+#define ASSERT assert
+
+#define LAST_FREE      -1
+#define ALLOCATED      -2
+
+/*
+ * Expands the heap
+ * Return 0 on success, -1 on error
+ */
+static int object_heap_expand( object_heap_p heap )
+{
+    int i;
+    void *new_heap_index;
+    int next_free;
+    int new_heap_size = heap->heap_size + heap->heap_increment;
+    
+    new_heap_index = (void *) realloc( heap->heap_index, new_heap_size * heap->object_size );
+    if ( NULL == new_heap_index )
+    {
+        return -1; /* Out of memory */
+    }
+    heap->heap_index = new_heap_index;
+    next_free = heap->next_free;
+    for(i = new_heap_size; i-- > heap->heap_size; )
+    {
+        object_base_p obj = (object_base_p) (heap->heap_index + i * heap->object_size);
+        obj->id = i + heap->id_offset;
+        obj->next_free = next_free;
+        next_free = i;
+    }
+    heap->next_free = next_free;
+    heap->heap_size = new_heap_size;
+    return 0; /* Success */
+}
+
+/*
+ * Return 0 on success, -1 on error
+ */
+int object_heap_init( object_heap_p heap, int object_size, int id_offset)
+{
+    heap->object_size = object_size;
+    heap->id_offset = id_offset & OBJECT_HEAP_OFFSET_MASK;
+    heap->heap_size = 0;
+    heap->heap_increment = 16;
+    heap->heap_index = NULL;
+    heap->next_free = LAST_FREE;
+    return object_heap_expand(heap);
+}
+
+/*
+ * Allocates an object
+ * Returns the object ID on success, returns -1 on error
+ */
+int object_heap_allocate( object_heap_p heap )
+{
+    object_base_p obj;
+    if ( LAST_FREE == heap->next_free )
+    {
+        if( -1 == object_heap_expand( heap ) )
+        {
+            return -1; /* Out of memory */
+        }
+    }
+    ASSERT( heap->next_free >= 0 );
+    
+    obj = (object_base_p) (heap->heap_index + heap->next_free * heap->object_size);
+    heap->next_free = obj->next_free;
+    obj->next_free = ALLOCATED;
+    return obj->id;
+}
+
+/*
+ * Lookup an object by object ID
+ * Returns a pointer to the object on success, returns NULL on error
+ */
+object_base_p object_heap_lookup( object_heap_p heap, int id )
+{
+    object_base_p obj;
+    if ( (id < heap->id_offset) || (id > (heap->heap_size+heap->id_offset)) )
+    {
+        return NULL;
+    }
+    id &= OBJECT_HEAP_ID_MASK;
+    obj = (object_base_p) (heap->heap_index + id * heap->object_size);
+
+       /* Check if the object has in fact been allocated */
+       if ( obj->next_free != ALLOCATED )
+    {
+        return NULL;
+    }
+    return obj;
+}
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the first object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_first( object_heap_p heap, object_heap_iterator *iter )
+{
+    *iter = -1;
+    return object_heap_next( heap, iter );
+}
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the next object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_next( object_heap_p heap, object_heap_iterator *iter )
+{
+    object_base_p obj;
+    int i = *iter + 1;
+    while ( i < heap->heap_size)
+    {
+        obj = (object_base_p) (heap->heap_index + i * heap->object_size);
+        if (obj->next_free == ALLOCATED)
+        {
+            *iter = i;
+            return obj;
+        }
+        i++;
+    }
+    *iter = i;
+    return NULL;
+}
+
+
+
+/*
+ * Frees an object
+ */
+void object_heap_free( object_heap_p heap, object_base_p obj )
+{
+    /* Don't complain about NULL pointers */
+    if (NULL != obj)
+    {
+        /* Check if the object has in fact been allocated */
+        ASSERT( obj->next_free == ALLOCATED );
+    
+        obj->next_free = heap->next_free;
+        heap->next_free = obj->id & OBJECT_HEAP_ID_MASK;
+    }
+}
+
+/*
+ * Destroys a heap, the heap must be empty.
+ */
+void object_heap_destroy( object_heap_p heap )
+{
+    object_base_p obj;
+    int i;
+    /* Check if heap is empty */
+    for (i = 0; i < heap->heap_size; i++)
+    {
+        /* Check if object is not still allocated */
+        obj = (object_base_p) (heap->heap_index + i * heap->object_size);
+        ASSERT( obj->next_free != ALLOCATED );
+    }
+    free(heap->heap_index);
+    heap->heap_size = 0;
+    heap->heap_index = NULL;
+    heap->next_free = LAST_FREE;
+}
diff --git a/dummy_drv_video/object_heap.h b/dummy_drv_video/object_heap.h
new file mode 100644 (file)
index 0000000..dba5928
--- /dev/null
@@ -0,0 +1,69 @@
+/*
+ * @COPYRIGHT@ Intel Confidential - Unreleased Software
+ */
+
+#ifndef _OBJECT_HEAP_H_
+#define _OBJECT_HEAP_H_
+
+#define OBJECT_HEAP_OFFSET_MASK                0x7F000000
+#define OBJECT_HEAP_ID_MASK                    0x00FFFFFF
+
+typedef struct object_base *object_base_p;
+typedef struct object_heap *object_heap_p;
+
+struct object_base {
+    int id;
+    int next_free;
+};
+
+struct object_heap {
+    int        object_size;
+    int id_offset;
+    void *heap_index;
+    int next_free;
+    int heap_size;
+    int heap_increment;
+};
+
+typedef int object_heap_iterator;
+
+/*
+ * Return 0 on success, -1 on error
+ */
+int object_heap_init( object_heap_p heap, int object_size, int id_offset);
+
+/*
+ * Allocates an object
+ * Returns the object ID on success, returns -1 on error
+ */
+int object_heap_allocate( object_heap_p heap );
+
+/*
+ * Lookup an allocated object by object ID
+ * Returns a pointer to the object on success, returns NULL on error
+ */
+object_base_p object_heap_lookup( object_heap_p heap, int id );
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the first object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_first( object_heap_p heap, object_heap_iterator *iter );
+
+/*
+ * Iterate over all objects in the heap.
+ * Returns a pointer to the next object on the heap, returns NULL if heap is empty.
+ */
+object_base_p object_heap_next( object_heap_p heap, object_heap_iterator *iter );
+
+/*
+ * Frees an object
+ */
+void object_heap_free( object_heap_p heap, object_base_p obj );
+
+/*
+ * Destroys a heap, the heap must be empty.
+ */
+void object_heap_destroy( object_heap_p heap );
+
+#endif /* _OBJECT_HEAP_H_ */
diff --git a/libva.pc.in b/libva.pc.in
new file mode 100644 (file)
index 0000000..d46f53c
--- /dev/null
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libva
+Description: Userspace Video Acceleration (VA) interface
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lva
+Cflags: -I${includedir}
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644 (file)
index 0000000..9682992
--- /dev/null
@@ -0,0 +1,13 @@
+#  @COPYRIGHT@ Intel Confidential - Unreleased Software
+
+libva_la_LTLIBRARIES = libva.la
+libva_ladir = $(libdir)
+libva_la_LDFLAGS = -version-number 0:1:0 -no-undefined
+libva_la_LIBADD = -ldl -lX11 -lXext
+
+libva_la_SOURCES = XF86dri.c xf86dri.h xf86dristr.h va.c
+
+libvaincludedir = ${includedir}
+libvainclude_HEADERS = va.h va_x11.h
+
+EXTRA_DIST = ChangeLog TODO
diff --git a/src/XF86dri.c b/src/XF86dri.c
new file mode 100644 (file)
index 0000000..9dae6d1
--- /dev/null
@@ -0,0 +1,620 @@
+/* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.13 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <martin@valinux.com>
+ *   Jens Owen <jens@tungstengraphics.com>
+ *   Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include "xf86dristr.h"
+
+#define PUBLIC
+
+static XExtensionInfo _xf86dri_info_data;
+static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;
+static char xf86dri_extension_name[] = XF86DRINAME;
+
+#define XF86DRICheckExtension(dpy,i,val) \
+  XextCheckExtension (dpy, i, xf86dri_extension_name, val)
+
+/*****************************************************************************
+ *                                                                           *
+ *                        private utility routines                          *
+ *                                                                           *
+ *****************************************************************************/
+
+static int close_display(Display *dpy, XExtCodes *extCodes);
+static /* const */ XExtensionHooks xf86dri_extension_hooks = {
+    NULL,                              /* create_gc */
+    NULL,                              /* copy_gc */
+    NULL,                              /* flush_gc */
+    NULL,                              /* free_gc */
+    NULL,                              /* create_font */
+    NULL,                              /* free_font */
+    close_display,                     /* close_display */
+    NULL,                              /* wire_to_event */
+    NULL,                              /* event_to_wire */
+    NULL,                              /* error */
+    NULL,                              /* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info, 
+                                  xf86dri_extension_name, 
+                                  &xf86dri_extension_hooks, 
+                                  0, NULL)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
+
+
+/*****************************************************************************
+ *                                                                           *
+ *                 public XFree86-DRI Extension routines                    *
+ *                                                                           *
+ *****************************************************************************/
+
+#if 0
+#include <stdio.h>
+#define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);
+#else
+#define TRACE(msg)
+#endif
+
+
+PUBLIC Bool XF86DRIQueryExtension (dpy, event_basep, error_basep)
+    Display *dpy;
+    int *event_basep, *error_basep;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+
+    TRACE("QueryExtension...");
+    if (XextHasExtension(info)) {
+       *event_basep = info->codes->first_event;
+       *error_basep = info->codes->first_error;
+        TRACE("QueryExtension... return True");
+       return True;
+    } else {
+        TRACE("QueryExtension... return False");
+       return False;
+    }
+}
+
+PUBLIC Bool XF86DRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
+    Display* dpy;
+    int* majorVersion; 
+    int* minorVersion;
+    int* patchVersion;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIQueryVersionReply rep;
+    xXF86DRIQueryVersionReq *req;
+
+    TRACE("QueryVersion...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIQueryVersion, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIQueryVersion;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("QueryVersion... return False");
+       return False;
+    }
+    *majorVersion = rep.majorVersion;
+    *minorVersion = rep.minorVersion;
+    *patchVersion = rep.patchVersion;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("QueryVersion... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIQueryDirectRenderingCapable(dpy, screen, isCapable)
+    Display* dpy;
+    int screen;
+    Bool* isCapable;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIQueryDirectRenderingCapableReply rep;
+    xXF86DRIQueryDirectRenderingCapableReq *req;
+
+    TRACE("QueryDirectRenderingCapable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIQueryDirectRenderingCapable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("QueryDirectRenderingCapable... return False");
+       return False;
+    }
+    *isCapable = rep.isCapable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("QueryDirectRenderingCapable... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIOpenConnection(dpy, screen, hSAREA, busIdString)
+    Display* dpy;
+    int screen;
+    drm_handle_t * hSAREA;
+    char **busIdString;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIOpenConnectionReply rep;
+    xXF86DRIOpenConnectionReq *req;
+
+    TRACE("OpenConnection...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIOpenConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIOpenConnection;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("OpenConnection... return False");
+       return False;
+    }
+
+    *hSAREA = rep.hSAREALow;
+    if (sizeof(drm_handle_t) == 8) {
+       int shift = 32; /* var to prevent warning on next line */
+       *hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;
+    }
+
+    if (rep.length) {
+        if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
+            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("OpenConnection... return False");
+            return False;
+        }
+       _XReadPad(dpy, *busIdString, rep.busIdStringLength);
+    } else {
+        *busIdString = NULL;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("OpenConnection... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIAuthConnection(dpy, screen, magic)
+    Display* dpy;
+    int screen;
+    drm_magic_t magic;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIAuthConnectionReq *req;
+    xXF86DRIAuthConnectionReply rep;
+
+    TRACE("AuthConnection...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIAuthConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIAuthConnection;
+    req->screen = screen;
+    req->magic = magic;
+    rep.authenticated = 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("AuthConnection... return False");
+       return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("AuthConnection... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRICloseConnection(dpy, screen)
+    Display* dpy;
+    int screen;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICloseConnectionReq *req;
+
+    TRACE("CloseConnection...");
+
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICloseConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICloseConnection;
+    req->screen = screen;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CloseConnection... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIGetClientDriverName(dpy, screen, ddxDriverMajorVersion, 
+       ddxDriverMinorVersion, ddxDriverPatchVersion, clientDriverName)
+    Display* dpy;
+    int screen;
+    int* ddxDriverMajorVersion;
+    int* ddxDriverMinorVersion;
+    int* ddxDriverPatchVersion;
+    char** clientDriverName;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetClientDriverNameReply rep;
+    xXF86DRIGetClientDriverNameReq *req;
+
+    TRACE("GetClientDriverName...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetClientDriverName, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetClientDriverName;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("GetClientDriverName... return False");
+       return False;
+    }
+
+    *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
+    *ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
+    *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
+
+    if (rep.length) {
+        if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
+            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("GetClientDriverName... return False");
+            return False;
+        }
+       _XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
+    } else {
+        *clientDriverName = NULL;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetClientDriverName... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRICreateContextWithConfig(dpy, screen, configID, context,
+       hHWContext)
+    Display* dpy;
+    int screen;
+    int configID;
+    XID* context;
+    drm_context_t * hHWContext;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICreateContextReply rep;
+    xXF86DRICreateContextReq *req;
+
+    TRACE("CreateContext...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICreateContext, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICreateContext;
+    req->visual = configID;
+    req->screen = screen;
+    *context = XAllocID(dpy);
+    req->context = *context;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("CreateContext... return False");
+       return False;
+    }
+    *hHWContext = rep.hHWContext;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CreateContext... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRICreateContext(dpy, screen, visual, context, hHWContext)
+    Display* dpy;
+    int screen;
+    Visual* visual;
+    XID* context;
+    drm_context_t * hHWContext;
+{
+    return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
+                                          context, hHWContext );
+}
+
+PUBLIC GLboolean XF86DRIDestroyContext( __DRInativeDisplay * ndpy, int screen, 
+    __DRIid context )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIDestroyContextReq *req;
+
+    TRACE("DestroyContext...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIDestroyContext, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIDestroyContext;
+    req->screen = screen;
+    req->context = context;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("DestroyContext... return True");
+    return True;
+}
+
+PUBLIC GLboolean XF86DRICreateDrawable( __DRInativeDisplay * ndpy, int screen, 
+    __DRIid drawable, drm_drawable_t * hHWDrawable )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICreateDrawableReply rep;
+    xXF86DRICreateDrawableReq *req;
+
+    TRACE("CreateDrawable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICreateDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICreateDrawable;
+    req->screen = screen;
+    req->drawable = drawable;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("CreateDrawable... return False");
+       return False;
+    }
+    *hHWDrawable = rep.hHWDrawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CreateDrawable... return True");
+    return True;
+}
+
+PUBLIC GLboolean XF86DRIDestroyDrawable( __DRInativeDisplay * ndpy, int screen,
+    __DRIid drawable )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIDestroyDrawableReq *req;
+
+    TRACE("DestroyDrawable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIDestroyDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIDestroyDrawable;
+    req->screen = screen;
+    req->drawable = drawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("DestroyDrawable... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
+    unsigned int* index, unsigned int* stamp,
+    int* X, int* Y, int* W, int* H,
+    int* numClipRects, drm_clip_rect_t ** pClipRects,
+    int* backX, int* backY,
+    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetDrawableInfoReply rep;
+    xXF86DRIGetDrawableInfoReq *req;
+    int total_rects;
+
+    TRACE("GetDrawableInfo...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetDrawableInfo, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetDrawableInfo;
+    req->screen = screen;
+    req->drawable = drawable;
+
+    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 
+    {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("GetDrawableInfo... return False");
+       return False;
+    }
+    *index = rep.drawableTableIndex;
+    *stamp = rep.drawableTableStamp;
+    *X = (int)rep.drawableX;
+    *Y = (int)rep.drawableY;
+    *W = (int)rep.drawableWidth;
+    *H = (int)rep.drawableHeight;
+    *numClipRects = rep.numClipRects;
+    total_rects = *numClipRects;
+
+    *backX = rep.backX;
+    *backY = rep.backY;
+    *numBackClipRects = rep.numBackClipRects;
+    total_rects += *numBackClipRects;
+
+#if 0
+    /* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
+     * backwards compatibility (Because of the >> 2 shift) but the fix
+     * enables multi-threaded apps to work.
+     */
+    if (rep.length !=  ((((SIZEOF(xXF86DRIGetDrawableInfoReply) - 
+                      SIZEOF(xGenericReply) + 
+                      total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
+        _XEatData(dpy, rep.length);
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("GetDrawableInfo... return False");
+        return False;
+    }
+#endif
+
+    if (*numClipRects) {
+       int len = sizeof(drm_clip_rect_t) * (*numClipRects);
+
+       *pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
+       if (*pClipRects) 
+         _XRead(dpy, (char*)*pClipRects, len);
+    } else {
+        *pClipRects = NULL;
+    }
+
+    if (*numBackClipRects) {
+       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
+
+       *pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
+       if (*pBackClipRects) 
+         _XRead(dpy, (char*)*pBackClipRects, len);
+    } else {
+        *pBackClipRects = NULL;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetDrawableInfo... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIGetDeviceInfo(dpy, screen, hFrameBuffer, 
+       fbOrigin, fbSize, fbStride, devPrivateSize, pDevPrivate)
+    Display* dpy;
+    int screen;
+    drm_handle_t * hFrameBuffer;
+    int* fbOrigin;
+    int* fbSize;
+    int* fbStride;
+    int* devPrivateSize;
+    void** pDevPrivate;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetDeviceInfoReply rep;
+    xXF86DRIGetDeviceInfoReq *req;
+
+    TRACE("GetDeviceInfo...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetDeviceInfo, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetDeviceInfo;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+       UnlockDisplay(dpy);
+       SyncHandle();
+        TRACE("GetDeviceInfo... return False");
+       return False;
+    }
+
+    *hFrameBuffer = rep.hFrameBufferLow;
+    if (sizeof(drm_handle_t) == 8) {
+       int shift = 32; /* var to prevent warning on next line */
+       *hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
+    }
+
+    *fbOrigin = rep.framebufferOrigin;
+    *fbSize = rep.framebufferSize;
+    *fbStride = rep.framebufferStride;
+    *devPrivateSize = rep.devPrivateSize;
+
+    if (rep.length) {
+        if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
+            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("GetDeviceInfo... return False");
+            return False;
+        }
+       _XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
+    } else {
+        *pDevPrivate = NULL;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetDeviceInfo... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIOpenFullScreen(dpy, screen, drawable)
+    Display* dpy;
+    int screen;
+    Drawable drawable;
+{
+    /* This function and the underlying X protocol are deprecated.
+     */
+    (void) dpy;
+    (void) screen;
+    (void) drawable;
+    return False;
+}
+
+PUBLIC Bool XF86DRICloseFullScreen(dpy, screen, drawable)
+    Display* dpy;
+    int screen;
+    Drawable drawable;
+{
+    /* This function and the underlying X protocol are deprecated.
+     */
+    (void) dpy;
+    (void) screen;
+    (void) drawable;
+    return True;
+}
diff --git a/src/dri_interface.h b/src/dri_interface.h
new file mode 100644 (file)
index 0000000..9d4f367
--- /dev/null
@@ -0,0 +1,478 @@
+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * (C) Copyright IBM Corporation 2004
+ * 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
+ * on 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
+ * THE COPYRIGHT HOLDERS AND/OR THEIR 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.
+ */
+
+/**
+ * \file dri_interface.h
+ *
+ * This file contains all the types and functions that define the interface
+ * between a DRI driver and driver loader.  Currently, the most common driver
+ * loader is the XFree86 libGL.so.  However, other loaders do exist, and in
+ * the future the server-side libglx.a will also be a loader.
+ * 
+ * \author Kevin E. Martin <kevin@precisioninsight.com>
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+#ifndef DRI_INTERFACE_H
+#define DRI_INTERFACE_H
+
+#include <GL/gl.h>
+#include <GL/internal/glcore.h>
+#include <drm.h>
+
+/**
+ * \name DRI interface structures
+ *
+ * The following structures define the interface between the GLX client
+ * side library and the DRI (direct rendering infrastructure).
+ */
+/*@{*/
+typedef struct __DRIdisplayRec  __DRIdisplay;
+typedef struct __DRIscreenRec   __DRIscreen;
+typedef struct __DRIcontextRec  __DRIcontext;
+typedef struct __DRIdrawableRec __DRIdrawable;
+typedef struct __DRIdriverRec   __DRIdriver;
+typedef struct __DRIframebufferRec __DRIframebuffer;
+typedef struct __DRIversionRec     __DRIversion;
+typedef struct __DRIinterfaceMethodsRec  __DRIinterfaceMethods;
+typedef unsigned long __DRIid;
+typedef void __DRInativeDisplay;
+/*@}*/
+
+
+/**
+ * \name Functions provided by the driver loader.
+ */
+/*@{*/
+/**
+ * Type of a pointer to \c glXGetScreenDriver, as returned by
+ * \c glXGetProcAddress.  This function is used to get the name of the DRI
+ * driver for the specified screen of the specified display.  The driver
+ * name is typically used with \c glXGetDriverConfig.
+ *
+ * \sa glXGetScreenDriver, glXGetProcAddress, glXGetDriverConfig
+ */
+typedef const char * (* PFNGLXGETSCREENDRIVERPROC) (__DRInativeDisplay *dpy, int scrNum);
+
+/**
+ * Type of a pointer to \c glXGetDriverConfig, as returned by
+ * \c glXGetProcAddress.  This function is used to get the XML document
+ * describing the configuration options available for the specified driver.
+ *
+ * \sa glXGetDriverConfig, glXGetProcAddress, glXGetScreenDriver
+ */
+typedef const char * (* PFNGLXGETDRIVERCONFIGPROC) (const char *driverName);
+
+/**
+ * Type of a pointer to \c glxEnableExtension, as returned by
+ * \c __DRIinterfaceMethods::getProcAddress.  This function is used to enable
+ * a GLX extension on the specified screen.
+ */
+typedef void (* PFNGLXSCRENABLEEXTENSIONPROC) ( void *psc, const char * name );
+/*@}*/
+
+
+/**
+ * \name Functions and data provided by the driver.
+ */
+/*@{*/
+
+typedef void *(CREATENEWSCREENFUNC)(__DRInativeDisplay *dpy, int scrn,
+    __DRIscreen *psc, const __GLcontextModes * modes,
+    const __DRIversion * ddx_version, const __DRIversion * dri_version,
+    const __DRIversion * drm_version, const __DRIframebuffer * frame_buffer,
+    void * pSAREA, int fd, int internal_api_version,
+    const __DRIinterfaceMethods * interface,
+    __GLcontextModes ** driver_modes);
+typedef CREATENEWSCREENFUNC* PFNCREATENEWSCREENFUNC;
+extern CREATENEWSCREENFUNC __driCreateNewScreen_20050727;
+
+
+/**
+ * XML document describing the configuration options supported by the
+ * driver.
+ */
+extern const char __driConfigOptions[];
+
+/*@}*/
+
+
+/**
+ * Stored version of some component (i.e., server-side DRI module, kernel-side
+ * DRM, etc.).
+ * 
+ * \todo
+ * There are several data structures that explicitly store a major version,
+ * minor version, and patch level.  These structures should be modified to
+ * have a \c __DRIversionRec instead.
+ */
+struct __DRIversionRec {
+    int    major;        /**< Major version number. */
+    int    minor;        /**< Minor version number. */
+    int    patch;        /**< Patch-level. */
+};
+
+
+typedef void (*__DRIfuncPtr)(void);
+
+struct __DRIinterfaceMethodsRec {
+    /**
+     * Get pointer to named function.
+     */
+    __DRIfuncPtr (*getProcAddress)( const char * proc_name );
+
+    /**
+     * Create a list of \c __GLcontextModes structures.
+     */
+    __GLcontextModes * (*createContextModes)(unsigned count,
+        size_t minimum_bytes_per_struct);
+
+    /**
+     * Destroy a list of \c __GLcontextModes structures.
+     *
+     * \todo
+     * Determine if the drivers actually need to call this.
+     */
+    void (*destroyContextModes)( __GLcontextModes * modes );
+
+    /**
+     * Get the \c __DRIscreen for a given display and screen number.
+     */
+    __DRIscreen *(*getScreen)(__DRInativeDisplay *dpy, int screenNum);
+
+
+    /**
+     * \name Client/server protocol functions.
+     *
+     * These functions implement the DRI client/server protocol for
+     * context and drawable operations.  Platforms that do not implement
+     * the wire protocol (e.g., EGL) will implement glorified no-op functions.
+     */
+    /*@{*/
+    /**
+     * Determine if the specified window ID still exists.
+     * 
+     * \note
+     * Implementations may assume that the driver will only pass an ID into
+     * this function that actually corresponds to a window.  On
+     * implementations where windows can only be destroyed by the DRI driver
+     * (e.g., EGL), this function is allowed to always return \c GL_TRUE.
+     */
+    GLboolean (*windowExists)(__DRInativeDisplay *dpy, __DRIid draw);
+
+    /**
+     * Create the server-side portion of the GL context.
+     */
+    GLboolean (* createContext)( __DRInativeDisplay *dpy, int screenNum,
+        int configID, void * contextID, drm_context_t * hw_context );
+
+    /**
+     * Destroy the server-side portion of the GL context.
+     */
+    GLboolean (* destroyContext)( __DRInativeDisplay *dpy, int screenNum,
+        __DRIid context );
+
+    /**
+     * Create the server-side portion of the drawable.
+     */
+    GLboolean (*createDrawable)( __DRInativeDisplay * ndpy, int screen,
+        __DRIid drawable, drm_drawable_t * hHWDrawable );
+
+    /**
+     * Destroy the server-side portion of the drawable.
+     */
+    GLboolean (*destroyDrawable)( __DRInativeDisplay * ndpy, int screen,
+        __DRIid drawable );
+
+    /**
+     * This function is used to get information about the position, size, and
+     * clip rects of a drawable.
+     */
+    GLboolean (* getDrawableInfo) ( __DRInativeDisplay *dpy, int scrn,
+        __DRIid draw, unsigned int * index, unsigned int * stamp,
+        int * x, int * y, int * width, int * height,
+        int * numClipRects, drm_clip_rect_t ** pClipRects,
+        int * backX, int * backY,
+        int * numBackClipRects, drm_clip_rect_t ** pBackClipRects );
+    /*@}*/
+
+
+    /**
+     * \name Timing related functions.
+     */
+    /*@{*/
+    /**
+     * Get the 64-bit unadjusted system time (UST).
+     */
+    int (*getUST)(int64_t * ust);
+
+    /**
+     * Get the media stream counter (MSC) rate.
+     * 
+     * Matching the definition in GLX_OML_sync_control, this function returns
+     * the rate of the "media stream counter".  In practical terms, this is
+     * the frame refresh rate of the display.
+     */
+    GLboolean (*getMSCRate)(__DRInativeDisplay * dpy, __DRIid drawable,
+        int32_t * numerator, int32_t * denominator);
+    /*@}*/
+};
+
+   
+/**
+ * Framebuffer information record.  Used by libGL to communicate information
+ * about the framebuffer to the driver's \c __driCreateNewScreen function.
+ * 
+ * In XFree86, most of this information is derrived from data returned by
+ * calling \c XF86DRIGetDeviceInfo.
+ *
+ * \sa XF86DRIGetDeviceInfo __DRIdisplayRec::createNewScreen
+ *     __driUtilCreateNewScreen CallCreateNewScreen
+ *
+ * \bug This structure could be better named.
+ */
+struct __DRIframebufferRec {
+    unsigned char *base;    /**< Framebuffer base address in the CPU's
+                            * address space.  This value is calculated by
+                            * calling \c drmMap on the framebuffer handle
+                            * returned by \c XF86DRIGetDeviceInfo (or a
+                            * similar function).
+                            */
+    int size;               /**< Framebuffer size, in bytes. */
+    int stride;             /**< Number of bytes from one line to the next. */
+    int width;              /**< Pixel width of the framebuffer. */
+    int height;             /**< Pixel height of the framebuffer. */
+    int dev_priv_size;      /**< Size of the driver's dev-priv structure. */
+    void *dev_priv;         /**< Pointer to the driver's dev-priv structure. */
+};
+
+
+/**
+ * Screen dependent methods.  This structure is initialized during the
+ * \c __DRIdisplayRec::createScreen call.
+ */
+struct __DRIscreenRec {
+    /**
+     * Method to destroy the private DRI screen data.
+     */
+    void (*destroyScreen)(__DRInativeDisplay *dpy, int scrn, void *screenPrivate);
+
+    /**
+     * Method to create the private DRI drawable data and initialize the
+     * drawable dependent methods.
+     */
+    void *(*createNewDrawable)(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
+                              __DRIid draw, __DRIdrawable *pdraw,
+                              int renderType, const int *attrs);
+
+    /**
+     * Method to return a pointer to the DRI drawable data.
+     */
+    __DRIdrawable *(*getDrawable)(__DRInativeDisplay *dpy, __DRIid draw,
+                                 void *drawablePrivate);
+
+    /**
+     * Opaque pointer to private per screen direct rendering data.  \c NULL
+     * if direct rendering is not supported on this screen.  Never
+     * dereferenced in libGL.
+     */
+    void *private;
+
+    /**
+     * Get the number of vertical refreshes since some point in time before
+     * this function was first called (i.e., system start up).
+     * 
+     * \since Internal API version 20030317.
+     */
+    int (*getMSC)( void *screenPrivate, int64_t *msc );
+
+    /**
+     * Opaque pointer that points back to the containing 
+     * \c __GLXscreenConfigs.  This data structure is shared with DRI drivers
+     * but \c __GLXscreenConfigs is not. However, they are needed by some GLX
+     * functions called by DRI drivers.
+     *
+     * \since Internal API version 20030813.
+     */
+    void *screenConfigs;
+
+    /**
+     * Functions associated with MESA_allocate_memory.
+     *
+     * \since Internal API version 20030815.
+     */
+    /*@{*/
+    void *(*allocateMemory)(__DRInativeDisplay *dpy, int scrn, GLsizei size,
+                           GLfloat readfreq, GLfloat writefreq,
+                           GLfloat priority);
+   
+    void (*freeMemory)(__DRInativeDisplay *dpy, int scrn, GLvoid *pointer);
+   
+    GLuint (*memoryOffset)(__DRInativeDisplay *dpy, int scrn, const GLvoid *pointer);
+    /*@}*/
+
+    /**
+     * Method to create the private DRI context data and initialize the
+     * context dependent methods.
+     *
+     * \since Internal API version 20031201.
+     */
+    void * (*createNewContext)(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
+                              int render_type,
+                              void *sharedPrivate, __DRIcontext *pctx);
+};
+
+/**
+ * Context dependent methods.  This structure is initialized during the
+ * \c __DRIscreenRec::createContext call.
+ */
+struct __DRIcontextRec {
+    /**
+     * Method to destroy the private DRI context data.
+     */
+    void (*destroyContext)(__DRInativeDisplay *dpy, int scrn, void *contextPrivate);
+
+    /**
+     * Opaque pointer to private per context direct rendering data.
+     * \c NULL if direct rendering is not supported on the display or
+     * screen used to create this context.  Never dereferenced in libGL.
+     */
+    void *private;
+
+    /**
+     * Pointer to the mode used to create this context.
+     *
+     * \since Internal API version 20040317.
+     */
+    const __GLcontextModes * mode;
+
+    /**
+     * Method to bind a DRI drawable to a DRI graphics context.
+     *
+     * \since Internal API version 20050727.
+     */
+    GLboolean (*bindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
+                        __DRIid read, __DRIcontext *ctx);
+
+    /**
+     * Method to unbind a DRI drawable from a DRI graphics context.
+     *
+     * \since Internal API version 20050727.
+     */
+    GLboolean (*unbindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
+                          __DRIid read, __DRIcontext *ctx);
+};
+
+/**
+ * Drawable dependent methods.  This structure is initialized during the
+ * \c __DRIscreenRec::createDrawable call.  \c createDrawable is not called
+ * by libGL at this time.  It's currently used via the dri_util.c utility code
+ * instead.
+ */
+struct __DRIdrawableRec {
+    /**
+     * Method to destroy the private DRI drawable data.
+     */
+    void (*destroyDrawable)(__DRInativeDisplay *dpy, void *drawablePrivate);
+
+    /**
+     * Method to swap the front and back buffers.
+     */
+    void (*swapBuffers)(__DRInativeDisplay *dpy, void *drawablePrivate);
+
+    /**
+     * Opaque pointer to private per drawable direct rendering data.
+     * \c NULL if direct rendering is not supported on the display or
+     * screen used to create this drawable.  Never dereferenced in libGL.
+     */
+    void *private;
+
+    /**
+     * Get the number of completed swap buffers for this drawable.
+     *
+     * \since Internal API version 20030317.
+     */
+    int (*getSBC)(__DRInativeDisplay *dpy, void *drawablePrivate, int64_t *sbc );
+
+    /**
+     * Wait for the SBC to be greater than or equal target_sbc.
+     *
+     * \since Internal API version 20030317.
+     */
+    int (*waitForSBC)( __DRInativeDisplay * dpy, void *drawablePriv,
+                      int64_t target_sbc,
+                      int64_t * msc, int64_t * sbc );
+
+    /**
+     * Wait for the MSC to equal target_msc, or, if that has already passed,
+     * the next time (MSC % divisor) is equal to remainder.  If divisor is
+     * zero, the function will return as soon as MSC is greater than or equal
+     * to target_msc.
+     * 
+     * \since Internal API version 20030317.
+     */
+    int (*waitForMSC)( __DRInativeDisplay * dpy, void *drawablePriv,
+                      int64_t target_msc, int64_t divisor, int64_t remainder,
+                      int64_t * msc, int64_t * sbc );
+
+    /**
+     * Like \c swapBuffers, but does NOT have an implicit \c glFlush.  Once
+     * rendering is complete, waits until MSC is equal to target_msc, or
+     * if that has already passed, waits until (MSC % divisor) is equal
+     * to remainder.  If divisor is zero, the swap will happen as soon as
+     * MSC is greater than or equal to target_msc.
+     * 
+     * \since Internal API version 20030317.
+     */
+    int64_t (*swapBuffersMSC)(__DRInativeDisplay *dpy, void *drawablePrivate,
+                             int64_t target_msc,
+                             int64_t divisor, int64_t remainder);
+
+    /**
+     * Enable or disable frame usage tracking.
+     * 
+     * \since Internal API version 20030317.
+     */
+    int (*frameTracking)(__DRInativeDisplay *dpy, void *drawablePrivate, GLboolean enable);
+
+    /**
+     * Retrieve frame usage information.
+     * 
+     * \since Internal API version 20030317.
+     */
+    int (*queryFrameTracking)(__DRInativeDisplay *dpy, void *drawablePrivate,
+                             int64_t * sbc, int64_t * missedFrames,
+                             float * lastMissedUsage, float * usage );
+
+    /**
+     * Used by drivers that implement the GLX_SGI_swap_control or
+     * GLX_MESA_swap_control extension.
+     *
+     * \since Internal API version 20030317.
+     */
+    unsigned swap_interval;
+};
+
+#endif
diff --git a/src/va.c b/src/va.c
new file mode 100644 (file)
index 0000000..63db75a
--- /dev/null
+++ b/src/va.c
@@ -0,0 +1,740 @@
+/*
+ * @COPYRIGHT@ Intel Confidential - Unreleased Software
+ */
+
+#include "X11/Xlib.h"
+#include "va.h"
+#include "va_backend.h"
+
+#include "assert.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <unistd.h>
+#include <xf86dri.h>
+
+#define DEFAULT_DRIVER_DIR     "/usr/X11R6/lib/modules/dri"
+#define DRIVER_EXTENSION       "_drv_video.so"
+#define DRIVER_INIT_FUNC       "__vaDriverInit_0_18"
+
+#define CTX(dpy) ((VADriverContextP) dpy );
+#define ASSERT_CONTEXT(dpy) assert( vaDbgContextIsValid(dpy) )
+#define ASSERT         assert
+#define CHECK_VTABLE(s, ctx, func) if (!va_checkVtable(ctx->vtable.va##func, #func)) s = VA_STATUS_ERROR_UNKNOWN;
+#define CHECK_MAXIMUM(s, ctx, var) if (!va_checkMaximum(ctx->max_##var, #var)) s = VA_STATUS_ERROR_UNKNOWN;
+
+#define TRACE(func) if (va_debug_trace) va_infoMessage("[TR] %s\n", #func);
+
+static VADriverContextP pDriverContexts = NULL;
+static int va_debug_trace = 0;
+
+static Bool vaDbgContextIsValid(VADriverContextP arg_ctx)
+{
+  VADriverContextP ctx = pDriverContexts;
+  
+  while (ctx)
+  {
+      if (ctx == arg_ctx)
+      {
+          return True;
+      }
+      ctx = ctx->pNext;
+  }
+  return False;
+}
+
+VADisplay vaGetDisplay (
+    NativeDisplay native_dpy    /* implementation specific */
+)
+{
+  VADisplay dpy = NULL;
+  VADriverContextP ctx = pDriverContexts;
+  
+  while (ctx)
+  {
+      if (ctx->x11_dpy == (Display *)native_dpy)
+      {
+          dpy = (VADisplay) ctx;
+          break;
+      }
+      ctx = ctx->pNext;
+  }
+  
+  if (!dpy)
+  {
+      /* create new entry */
+      ctx = (VADriverContextP) calloc(1, sizeof(struct VADriverContext));
+      ctx->pNext = pDriverContexts;
+      ctx->x11_dpy = (Display *) native_dpy;
+      pDriverContexts = ctx;
+      dpy = (VADisplay) ctx;
+  }
+  
+  return dpy;
+}
+
+static void va_errorMessage(const char *msg, ...)
+{
+    va_list args;
+
+    fprintf(stderr, "libva error: ");
+    va_start(args, msg);
+    vfprintf(stderr, msg, args);
+    va_end(args);
+}
+
+static void va_infoMessage(const char *msg, ...)
+{
+    va_list args;
+
+    fprintf(stderr, "libva: ");
+    va_start(args, msg);
+    vfprintf(stderr, msg, args);
+    va_end(args);
+}
+
+static Bool va_checkVtable(void *ptr, char *function)
+{
+    if (!ptr)
+    {
+        va_errorMessage("No valid vtable entry for va%s\n", function);
+        return False;
+    }
+    return True;
+}
+
+static Bool va_checkMaximum(int value, char *variable)
+{
+    if (!value)
+    {
+        va_errorMessage("Failed to define max_%s in init\n", variable);
+        return False;
+    }
+    return True;
+}
+
+static VAStatus va_getDriverName(VADriverContextP ctx, char **driver_name)
+{
+    VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
+    int direct_capable;
+    int driver_major;
+    int driver_minor;
+    int driver_patch;
+    Bool result = True;
+    
+    *driver_name = NULL;
+    if (geteuid() == getuid())
+    {
+        /* don't allow setuid apps to use LIBVA_DRIVER_NAME */
+        if (getenv("LIBVA_DRIVER_NAME"))
+        {
+            /* For easier debugging */
+            *driver_name = strdup(getenv("LIBVA_DRIVER_NAME"));
+            return VA_STATUS_SUCCESS;
+        }
+    }
+    if (result)
+    {
+        result = XF86DRIQueryDirectRenderingCapable(ctx->x11_dpy, ctx->x11_screen, &direct_capable);
+        if (!result)
+        {
+            va_errorMessage("XF86DRIQueryDirectRenderingCapable failed\n");
+        }
+    }
+    if (result)
+    {
+        result = direct_capable;
+        if (!result)
+        {
+            va_errorMessage("XF86DRIQueryDirectRenderingCapable returned false\n");
+        }
+    }
+    if (result)
+    {
+        result = XF86DRIGetClientDriverName(ctx->x11_dpy, ctx->x11_screen, &driver_major, &driver_minor,
+                                            &driver_patch, driver_name);
+        if (!result)
+        {
+            va_errorMessage("XF86DRIGetClientDriverName returned false\n");
+        }
+    }
+    if (result)
+    {
+        vaStatus = VA_STATUS_SUCCESS;
+        va_infoMessage("XF86DRIGetClientDriverName: %d.%d.%d %s (screen %d)\n",
+            driver_major, driver_minor, driver_patch, *driver_name, ctx->x11_screen);
+    }
+
+    return vaStatus;
+}
+
+static VAStatus va_openDriver(VADriverContextP ctx, char *driver_name)
+{
+    VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
+    char *search_path;
+    char *saveptr;
+    char *driver_dir;
+    
+    if (geteuid() == getuid())
+    {
+        /* don't allow setuid apps to use LIBVA_DRIVERS_PATH */
+        search_path = getenv("LIBVA_DRIVERS_PATH");
+        if (!search_path)
+        {
+            search_path = getenv("LIBGL_DRIVERS_PATH");
+        }
+    }
+    if (!search_path)
+    {
+        search_path = DEFAULT_DRIVER_DIR;
+    }
+
+    search_path = strdup(search_path);
+    driver_dir = strtok_r(search_path, ":", &saveptr);
+    while(driver_dir)
+    {
+        void *handle = NULL;
+        char *driver_path = (char *) malloc( strlen(driver_dir) +
+                                             strlen(driver_name) +
+                                             strlen(DRIVER_EXTENSION) + 2 );
+        strcpy( driver_path, driver_dir );
+        strcat( driver_path, "/" );
+        strcat( driver_path, driver_name );
+        strcat( driver_path, DRIVER_EXTENSION );
+        
+        va_infoMessage("Trying to open %s\n", driver_path);
+
+        handle = dlopen( driver_path, RTLD_NOW | RTLD_GLOBAL );
+        if (!handle)
+        {
+            /* Don't give errors for non-existing files */
+            if (0 == access( driver_path, F_OK))
+            {  
+                va_errorMessage("dlopen of %s failed: %s\n", driver_path, dlerror());
+            }
+        }
+        else
+        {
+            VADriverInit init_func;
+            init_func = (VADriverInit) dlsym(handle, DRIVER_INIT_FUNC);
+            if (!init_func)
+            {
+                va_errorMessage("%s has no function %s\n", driver_path, DRIVER_INIT_FUNC);
+                dlclose(handle);
+            }
+            else
+            {
+                vaStatus = (*init_func)(ctx);
+
+                if (VA_STATUS_SUCCESS == vaStatus)
+                {
+                    CHECK_MAXIMUM(vaStatus, ctx, profiles);
+                    CHECK_MAXIMUM(vaStatus, ctx, entrypoints);
+                    CHECK_MAXIMUM(vaStatus, ctx, 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, GetConfigAttributes);
+                    CHECK_VTABLE(vaStatus, ctx, CreateSurfaces);
+                    CHECK_VTABLE(vaStatus, ctx, DestroySurface);
+                    CHECK_VTABLE(vaStatus, ctx, CreateContext);
+                    CHECK_VTABLE(vaStatus, ctx, DestroyContext);
+                    CHECK_VTABLE(vaStatus, ctx, CreateBuffer);
+                    CHECK_VTABLE(vaStatus, ctx, BufferData);
+                    CHECK_VTABLE(vaStatus, ctx, BufferSetNumElements);
+                    CHECK_VTABLE(vaStatus, ctx, MapBuffer);
+                    CHECK_VTABLE(vaStatus, ctx, UnmapBuffer);
+                    CHECK_VTABLE(vaStatus, ctx, DestroyBuffer);
+                    CHECK_VTABLE(vaStatus, ctx, BeginPicture);
+                    CHECK_VTABLE(vaStatus, ctx, RenderPicture);
+                    CHECK_VTABLE(vaStatus, ctx, EndPicture);
+                    CHECK_VTABLE(vaStatus, ctx, SyncSurface);
+                    CHECK_VTABLE(vaStatus, ctx, QuerySurfaceStatus);
+                    CHECK_VTABLE(vaStatus, ctx, PutSurface);
+                    CHECK_VTABLE(vaStatus, ctx, DbgCopySurfaceToBuffer);
+                }
+                if (VA_STATUS_SUCCESS != vaStatus)
+                {
+                    va_errorMessage("%s init failed\n", driver_path);
+                    dlclose(handle);
+                }
+                if (VA_STATUS_SUCCESS == vaStatus)
+                {
+                    ctx->handle = handle;
+                }
+                free(driver_path);
+                break;
+            }
+        }
+        free(driver_path);
+        
+        driver_dir = strtok_r(NULL, ":", &saveptr);
+    }
+    
+    free(search_path);    
+    
+    return vaStatus;
+}
+
+
+/*
+ * Returns a short english description of error_status
+ */
+const char *vaErrorStr(VAStatus error_status)
+{
+    switch(error_status)
+    {
+        case VA_STATUS_SUCCESS:
+            return "success (no error)";
+        case VA_STATUS_ERROR_ALLOCATION_FAILED:
+            return "resource allocation failed";
+        case VA_STATUS_ERROR_INVALID_CONFIG:
+            return "invalid VAConfigID";
+        case VA_STATUS_ERROR_INVALID_CONTEXT:
+            return "invalid VAContextID";
+        case VA_STATUS_ERROR_INVALID_SURFACE:
+            return "invalid VASurfaceID";
+        case VA_STATUS_ERROR_INVALID_BUFFER:
+            return "invalid VABufferID";
+        case VA_STATUS_ERROR_ATTR_NOT_SUPPORTED:
+            return "attribute not supported";
+        case VA_STATUS_ERROR_MAX_NUM_EXCEEDED:
+            return "list argument exceeds maximum number";
+        case VA_STATUS_ERROR_UNSUPPORTED_PROFILE:
+            return "the requested VAProfile is not supported";
+        case VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT:
+            return "the requested VAEntryPoint is not supported";
+        case VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT:
+            return "the requested RT Format is not supported";
+        case VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE:
+            return "the requested VABufferType is not supported";
+        case VA_STATUS_ERROR_UNKNOWN:
+            return "unknown libva error";
+    }
+    return "unknwon libva error / description missing";
+}
+      
+VAStatus vaInitialize (
+    VADisplay dpy,
+    int *major_version,         /* out */
+    int *minor_version          /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  char *driver_name = NULL;
+  VAStatus vaStatus;
+  
+  ASSERT_CONTEXT(ctx);
+
+  va_debug_trace = (getenv("LIBVA_DEBUG_TRACE") != NULL);
+
+  vaStatus = va_getDriverName(ctx, &driver_name);
+  va_infoMessage("va_getDriverName() returns %d\n", vaStatus);
+  
+  if (VA_STATUS_SUCCESS == vaStatus)
+  {
+      vaStatus = va_openDriver(ctx, driver_name);
+      va_infoMessage("va_openDriver() returns %d\n", vaStatus);
+      
+      *major_version = ctx->version_major;
+      *minor_version = ctx->version_minor;
+  }
+
+  if (driver_name)
+  {
+      XFree(driver_name);
+  }
+  return vaStatus;
+}
+
+
+/*
+ * After this call, all library internal resources will be cleaned up
+ */ 
+VAStatus vaTerminate (
+    VADisplay dpy
+)
+{
+  VAStatus vaStatus = VA_STATUS_SUCCESS;
+  VADriverContextP old_ctx = CTX(dpy);
+  ASSERT_CONTEXT(old_ctx);
+
+  if (old_ctx->handle)
+  {
+      vaStatus = old_ctx->vtable.vaTerminate(old_ctx);
+      dlclose(old_ctx->handle);
+      old_ctx->handle = NULL;
+  }
+
+  if (VA_STATUS_SUCCESS == vaStatus)
+  {
+      VADriverContextP *ctx = &pDriverContexts;
+
+      /* Throw away old_ctx */
+      while (*ctx)
+      {
+          if (*ctx == old_ctx)
+          {
+              *ctx = old_ctx->pNext;
+              old_ctx->pNext = NULL;
+              break;
+          }
+          ctx = &((*ctx)->pNext);
+      }
+      free(old_ctx);
+  }
+  return vaStatus;
+}
+
+/* Get maximum number of profiles supported by the implementation */
+int vaMaxNumProfiles (
+    VADisplay dpy
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+  
+  return ctx->max_profiles;
+}
+
+/* Get maximum number of entrypoints supported by the implementation */
+int vaMaxNumEntrypoints (
+    VADisplay dpy
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+  
+  return ctx->max_entrypoints;
+}
+
+/* Get maximum number of attributs supported by the implementation */
+int vaMaxNumConfigAttributes (
+    VADisplay dpy
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+  
+  return ctx->max_attributes;
+}
+
+
+VAStatus vaQueryConfigEntrypoints (
+    VADisplay dpy,
+    VAProfile profile,
+    VAEntrypoint *entrypoints, /* out */
+    int *num_entrypoints       /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaQueryConfigEntrypoints);
+  return ctx->vtable.vaQueryConfigEntrypoints ( ctx, profile, entrypoints, num_entrypoints);
+}
+
+VAStatus vaQueryConfigAttributes (
+    VADisplay dpy,
+    VAProfile profile,
+    VAEntrypoint entrypoint,
+    VAConfigAttrib *attrib_list, /* in/out */
+    int num_attribs
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaQueryConfigAttributes);
+  return ctx->vtable.vaQueryConfigAttributes ( ctx, profile, entrypoint, attrib_list, num_attribs );
+}
+
+VAStatus vaQueryConfigProfiles (
+    VADisplay dpy,
+    VAProfile *profile_list,   /* out */
+    int *num_profiles          /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaQueryConfigProfiles);
+  return ctx->vtable.vaQueryConfigProfiles ( ctx, profile_list, num_profiles );
+}
+
+VAStatus vaCreateConfig (
+    VADisplay dpy,
+    VAProfile profile, 
+    VAEntrypoint entrypoint, 
+    VAConfigAttrib *attrib_list,
+    int num_attribs,
+    VAConfigID *config_id /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaCreateConfig);
+  return ctx->vtable.vaCreateConfig ( ctx, profile, entrypoint, attrib_list, num_attribs, config_id );
+}
+
+VAStatus vaGetConfigAttributes (
+    VADisplay dpy,
+    VAConfigID config_id, 
+    VAProfile *profile,        /* out */
+    VAEntrypoint *entrypoint,  /* out */
+    VAConfigAttrib *attrib_list,/* out */
+    int *num_attribs           /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaGetConfigAttributes);
+  return ctx->vtable.vaGetConfigAttributes( ctx, config_id, profile, entrypoint, attrib_list, num_attribs);
+}
+
+VAStatus vaCreateSurfaces (
+    VADisplay dpy,
+    int width,
+    int height,
+    int format,
+    int num_surfaces,
+    VASurface *surfaces        /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaCreateSurfaces);
+  return ctx->vtable.vaCreateSurfaces( ctx, width, height, format, num_surfaces, surfaces );
+}
+
+VAStatus vaDestroySurface (
+    VADisplay dpy,
+    VASurface *surface_list,
+    int num_surfaces
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaDestroySurface);
+  return ctx->vtable.vaDestroySurface( ctx, surface_list, num_surfaces );
+}
+
+VAStatus vaCreateContext (
+    VADisplay dpy,
+    VAConfigID config_id,
+    int picture_width,
+    int picture_height,
+    int flag,
+    VASurface *render_targets,
+    int num_render_targets,
+    VAContext *context         /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaCreateContext);
+  return ctx->vtable.vaCreateContext( ctx, config_id, picture_width, picture_height,
+                                      flag, render_targets, num_render_targets, context );
+}
+
+VAStatus vaDestroyContext (
+    VADisplay dpy,
+    VAContext *context
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaDestroyContext);
+  return ctx->vtable.vaDestroyContext( ctx, context );
+}
+
+VAStatus vaCreateBuffer (
+    VADisplay dpy,
+    VABufferType type, /* in */
+    VABufferID *buf_id /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaCreateBuffer);
+  return ctx->vtable.vaCreateBuffer( ctx, type, buf_id);
+}
+
+VAStatus vaBufferData (
+    VADisplay dpy,
+    VABufferID buf_id, /* in */
+    unsigned int size, /* in */
+    unsigned int num_elements, /* in */
+    void *data         /* in */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaBufferData);
+  return ctx->vtable.vaBufferData( ctx, buf_id, size, num_elements, data);
+}
+
+VAStatus vaBufferSetNumElements (
+    VADisplay dpy,
+    VABufferID buf_id, /* in */
+    unsigned int num_elements /* in */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaBufferSetNumElements);
+  return ctx->vtable.vaBufferSetNumElements( ctx, buf_id, num_elements );
+}
+
+
+VAStatus vaMapBuffer (
+    VADisplay dpy,
+    VABufferID buf_id, /* in */
+    void **pbuf        /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaMapBuffer);
+  return ctx->vtable.vaMapBuffer( ctx, buf_id, pbuf );
+}
+
+VAStatus vaUnmapBuffer (
+    VADisplay dpy,
+    VABufferID buf_id  /* in */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaUnmapBuffer);
+  return ctx->vtable.vaUnmapBuffer( ctx, buf_id );
+}
+
+VAStatus vaDestroyBuffer (
+    VADisplay dpy,
+    VABufferID buffer_id
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaDestroyBuffer);
+  return ctx->vtable.vaDestroyBuffer( ctx, buffer_id );
+}
+
+VAStatus vaBeginPicture (
+    VADisplay dpy,
+    VAContext *context,
+    VASurface *render_target
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaBeginPicture);
+  return ctx->vtable.vaBeginPicture( ctx, context, render_target );
+}
+
+VAStatus vaRenderPicture (
+    VADisplay dpy,
+    VAContext *context,
+    VABufferID *buffers,
+    int num_buffers
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaRenderPicture);
+  return ctx->vtable.vaRenderPicture( ctx, context, buffers, num_buffers );
+}
+
+VAStatus vaEndPicture (
+    VADisplay dpy,
+    VAContext *context
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaEndPicture);
+  return ctx->vtable.vaEndPicture( ctx, context );
+}
+
+VAStatus vaSyncSurface (
+    VADisplay dpy,
+    VAContext *context,
+    VASurface *render_target
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaSyncSurface);
+  return ctx->vtable.vaSyncSurface( ctx, context, render_target );
+}
+
+VAStatus vaQuerySurfaceStatus (
+    VADisplay dpy,
+    VAContext *context,
+    VASurface *render_target,
+    VASurfaceStatus *status    /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaQuerySurfaceStatus);
+  return ctx->vtable.vaQuerySurfaceStatus( ctx, context, render_target, status );
+}
+
+VAStatus vaPutSurface (
+    VADisplay dpy,
+    VASurface *surface,
+    Drawable draw, /* X Drawable */
+    short srcx,
+    short srcy,
+    unsigned short srcw,
+    unsigned short srch,
+    short destx,
+    short desty,
+    unsigned short destw,
+    unsigned short desth,
+    int flags /* de-interlacing flags */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaPutSurface);
+  return ctx->vtable.vaPutSurface( ctx, surface, draw, srcx, srcy, srcw, srch,
+                                   destx, desty, destw, desth, flags );
+}
+
+VAStatus vaDbgCopySurfaceToBuffer(VADisplay dpy,
+    VASurface *surface,
+    void **buffer, /* out */
+    unsigned int *stride /* out */
+)
+{
+  VADriverContextP ctx = CTX(dpy);
+  ASSERT_CONTEXT(ctx);
+
+  TRACE(vaDbgCopySurfaceToBuffer);
+  return ctx->vtable.vaDbgCopySurfaceToBuffer( ctx, surface, buffer, stride );
+}
+
diff --git a/src/va.h b/src/va.h
new file mode 100755 (executable)
index 0000000..71b0981
--- /dev/null
+++ b/src/va.h
@@ -0,0 +1,1076 @@
+/*
+ * Video Decode Acceleration API Specification
+ *
+ * Rev. 0.18
+ * <jonathan.bian@intel.com>
+ *
+ * Revision History:
+ * rev 0.10 (12/10/06 Jonathan Bian) - Initial draft
+ * rev 0.11 (12/15/06 Jonathan Bian) - Fixed some errors
+ * rev 0.12 (02/05/07 Jonathan Bian) - Added VC-1 data structures for slice level decode
+ * rev 0.13 (02/28/07 Jonathan Bian) - Added GetDisplay()
+ * rev 0.14 (04/13/07 Jonathan Bian) - Fixed MPEG-2 PictureParameter struct, cleaned up a few funcs.
+ * rev 0.15 (04/20/07 Jonathan Bian) - Overhauled buffer management  
+ * rev 0.16 (05/02/07 Jonathan Bian) - Added error codes and fixed some issues with configuration 
+ * rev 0.17 (05/07/07 Jonathan Bian) - Added H.264/AVC data structures for slice level decode.
+ * rev 0.18 (05/14/07 Jonathan Bian) - Added data structures for MPEG-4 slice level decode 
+ *                                     and MPEG-2 motion compensation.
+ *
+ * Acknowledgements:
+ *  Thanks to Waldo Bastian for many valuable feedbacks.
+ */
+
+#ifndef _VA_H_
+#define _VA_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 
+Overview 
+
+This is a decode only interface currently.  The basic steps are:
+
+- Negotiate a mutually acceptable configuration with the server to lock
+  down profile, entrypoints, and other attributes that will not change on 
+  a frame-by-frame basis.
+- Create a decode context which represents a "virtualized" hardware decode 
+  device
+- Get and fill decode buffers with picture level, slice level and macroblock 
+  level data (depending on entrypoints)
+- Pass the decode buffers to the server to decode the current frame
+
+Initialization & Configuration Management 
+
+- Find out supported profiles
+- Find out entrypoints for a given profile
+- Find out configuration attributes for a given profile/entrypoint pair
+- Create a configuration for use by the decoder
+
+*/
+
+typedef void* VADisplay;       /* window system dependent */
+
+typedef int VAStatus;  /* Return status type from functions */
+/* Values for the return status */
+#define VA_STATUS_SUCCESS                      0x00000000
+#define VA_STATUS_ERROR_ALLOCATION_FAILED      0x00000001
+#define VA_STATUS_ERROR_INVALID_CONFIG         0x00000002
+#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_MAX_NUM_EXCEEDED       0x00000007
+#define VA_STATUS_ERROR_UNSUPPORTED_PROFILE            0x00000008
+#define VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT 0x00000009
+#define VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT  0x0000000a
+#define VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE 0x0000000b
+#define VA_STATUS_ERROR_UNKNOWN                        0xFFFFFFFF
+
+/*
+ * Returns a short english description of error_status
+ */
+const char *vaErrorStr(VAStatus error_status);
+
+/*
+ * Initialization:
+ * A display must be obtained by calling vaGetDisplay() before calling
+ * vaInitialize() and other functions. This connects the API to the 
+ * native window system.
+ * For X Windows, native_dpy would be from XOpenDisplay()
+ */
+typedef void* NativeDisplay;   /* window system dependent */
+
+VADisplay vaGetDisplay (
+    NativeDisplay native_dpy   /* implementation specific */
+);
+
+VAStatus vaInitialize (
+    VADisplay dpy,
+    int *major_version,         /* out */
+    int *minor_version          /* out */
+);
+
+/*
+ * After this call, all library internal resources will be cleaned up
+ */ 
+VAStatus vaTerminate (
+    VADisplay dpy
+);
+
+/* Currently defined profiles */
+typedef enum
+{
+    VAProfileMPEG2Simple               = 0,
+    VAProfileMPEG2Main                 = 1,
+    VAProfileMPEG4Simple               = 2,
+    VAProfileMPEG4AdvancedSimple       = 3,
+    VAProfileMPEG4Main                 = 4,
+    VAProfileH264Baseline              = 5,
+    VAProfileH264Main                  = 6,
+    VAProfileH264High                  = 7,
+    VAProfileVC1Simple                 = 8,
+    VAProfileVC1Main                   = 9,
+    VAProfileVC1Advanced               = 10,
+} VAProfile;
+
+/* Currently defined entrypoints */
+typedef enum
+{
+    VAEntrypointVLD            = 1,
+    VAEntrypointIZZ            = 2,
+    VAEntrypointIDCT           = 3,
+    VAEntrypointMoComp         = 4,
+    VAEntrypointDeblocking     = 5,
+} VAEntrypoint;
+
+/* Currently defined configuration attribute types */
+typedef enum
+{
+    VAConfigAttribRTFormat             = 0,
+    VAConfigAttribSpatialResidual      = 1,
+    VAConfigAttribSpatialClipping      = 2,
+    VAConfigAttribIntraResidual                = 3,
+    VAConfigAttribEncryption           = 4,
+} VAConfigAttribType;
+
+/*
+ * Configuration attributes
+ * If there is more than one value for an attribute, a default
+ * value will be assigned to the attribute if the client does not
+ * specify the attribute when creating a configuration
+ */
+typedef struct _VAConfigAttrib {
+    VAConfigAttribType type;
+    unsigned int value; /* OR'd flags (bits) for this attribute */
+} VAConfigAttrib;
+
+/* attribute value for VAConfigAttribRTFormat */
+#define VA_RT_FORMAT_YUV420    0x00000001      
+#define VA_RT_FORMAT_YUV422    0x00000002
+#define VA_RT_FORMAT_YUV444    0x00000004
+
+/*
+ * if an attribute is not applicable for a given
+ * profile/entrypoint pair, then set the value to the following 
+ */
+#define VA_ATTRIB_NOT_SUPPORTED 0x80000000
+
+/* Get maximum number of profiles supported by the implementation */
+int vaMaxNumProfiles (
+    VADisplay dpy
+);
+
+/* Get maximum number of entrypoints supported by the implementation */
+int vaMaxNumEntrypoints (
+    VADisplay dpy
+);
+
+/* Get maximum number of attributs supported by the implementation */
+int vaMaxNumConfigAttributes (
+    VADisplay dpy
+);
+
+/* 
+ * Query supported profiles 
+ * The caller must provide a "profile_list" array that can hold at
+ * least vaMaxNumProfile() entries. The actual number of profiles
+ * returned in "profile_list" is returned in "num_profile".
+ */
+VAStatus vaQueryConfigProfiles (
+    VADisplay dpy,
+    VAProfile *profile_list,   /* out */
+    int *num_profiles          /* out */
+);
+
+/* 
+ * Query supported entrypoints for a given profile 
+ * The caller must provide an "entrypoint_list" array that can hold at
+ * least vaMaxNumEntrypoints() entries. The actual number of entrypoints 
+ * returned in "entrypoint_list" is returned in "num_entrypoints".
+ */
+VAStatus vaQueryConfigEntrypoints (
+    VADisplay dpy,
+    VAProfile profile,
+    VAEntrypoint *entrypoint_list,     /* out */
+    int *num_entrypoints               /* out */
+);
+
+/* 
+ * Query 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 (
+    VADisplay dpy,
+    VAProfile profile,
+    VAEntrypoint entrypoint,
+    VAConfigAttrib *attrib_list, /* in/out */
+    int num_attribs
+);
+
+typedef int VAConfigID;
+
+/* 
+ * Create a configuration for the decode pipeline 
+ * it passes in the attribute list that specifies the attributes it cares 
+ * about, with the rest taking default values.  
+ */
+VAStatus vaCreateConfig (
+    VADisplay dpy,
+    VAProfile profile, 
+    VAEntrypoint entrypoint, 
+    VAConfigAttrib *attrib_list,
+    int num_attribs,
+    VAConfigID *config_id /* out */
+);
+
+/* 
+ * Get 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 (
+    VADisplay dpy,
+    VAConfigID config_id, 
+    VAProfile *profile,        /* out */
+    VAEntrypoint *entrypoint,  /* out */
+    VAConfigAttrib *attrib_list,/* out */
+    int *num_attribs           /* out */
+);
+
+
+/*
+ * Context 
+ *
+ * Context represents a "virtual" video decode pipeline
+ */
+
+/* generic context ID type, can be re-typed for specific implementation */
+typedef int VAContextID;
+
+/* generic surface ID type, can be re-typed for specific implementation */
+typedef int VASurfaceID;
+
+typedef struct _VAContext
+{
+    VAContextID                context_id; /* to identify this context */
+    VAConfigID         config_id;
+    unsigned short     picture_width;
+    unsigned short     picture_height;
+    VASurfaceID                *render_targets;
+    int                        num_render_targets;     
+    int                flags;
+    void               *privData;       
+} VAContext;
+
+/*
+    flags - Any combination of the following:
+      VA_PROGRESSIVE (only progressive frame pictures in the sequence when set)
+*/
+#define VA_PROGRESSIVE 0x1
+
+/*
+
+Surface Management 
+
+Surfaces are render targets for a given context. The data in the surfaces 
+are not accessible to the client and the internal data format of
+the surface is implementatin specific. 
+
+Question: Is there a need to know the data format (fourcc) or just 
+differentiate between 420/422/444 is sufficient?
+
+*/
+
+typedef struct _VASurface
+{
+    VASurfaceID                surface_id; /* uniquely identify this surface */
+    VAContextID                context_id; /* which context does this surface belong */
+    unsigned short     width;
+    unsigned short     height;
+    int                        format; /* 420/422/444 */
+    void               *privData; /* private to the library */
+} VASurface;
+
+/* 
+ * Surfaces will be bound to a context when the context is created. Once
+ * a surface is bound to a given context, it can not be used to create
+ * another context. The association is removed when the context is destroyed
+ */
+
+/* Surface Functions */
+VAStatus vaCreateSurfaces (
+    VADisplay dpy,
+    int width,
+    int height,
+    int format,
+    int num_surfaces,
+    VASurface *surfaces        /* out */
+);
+
+/*
+ * surfaces can only be destroyed after the context associated has been 
+ * destroyed
+ */
+VAStatus vaDestroySurface (
+    VADisplay dpy,
+    VASurface *surface_list,
+    int num_surfaces
+);
+
+VAStatus vaCreateContext (
+    VADisplay dpy,
+    VAConfigID config_id,
+    int picture_width,
+    int picture_height,
+    int flag,
+    VASurface *render_targets,
+    int num_render_targets,
+    VAContext *context         /* out */
+);
+
+VAStatus vaDestroyContext (
+    VADisplay dpy,
+    VAContext *context
+);
+
+/*
+ *
+ *     Buffers 
+ *     Buffers are used to pass various types of data from the
+ *     client to the server. The server maintains a data store
+ *     for each buffer created, and the client idenfies a buffer
+ *     through a unique buffer id assigned by the server.
+ *
+ */
+
+typedef int VABufferID;
+
+typedef enum
+{
+    VAPictureParameterBufferType       = 0,
+    VAPictureBitPlaneBufferType                = 1,
+    VAIQMatrixBufferType               = 2,
+    VABitPlaneBufferType               = 3,
+    VASliceGroupMapBufferType          = 4,
+    VASliceParameterBufferType         = 5,
+    VASliceDataBufferType              = 6,
+    VAMacroblockParameterBufferType    = 7,
+    VAResidualDataBufferType           = 8,
+    VADeblockingParameterBufferType    = 9,
+} VABufferType;
+
+/****************************
+ * MPEG-2 data structures
+ ****************************/
+/* MPEG-2 Picture Parameter Buffer */
+typedef struct _VAPictureParameterBufferMPEG2
+{
+    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 int picture_coding_extension;
+    };
+} VAPictureParameterBufferMPEG2;
+
+/* MPEG-2 Inverse Quantization Matrix Buffer */
+typedef struct _VAIQMatrixBufferMPEG2
+{
+    int load_intra_quantiser_matrix;
+    int load_non_intra_quantiser_matrix;
+    int load_chroma_intra_quantiser_matrix;
+    int load_chroma_non_intra_quantiser_matrix;
+    unsigned char intra_quantiser_matrix[64];
+    unsigned char non_intra_quantiser_matrix[64];
+    unsigned char chroma_intra_quantiser_matrix[64];
+    unsigned char chroma_non_intra_quantiser_matrix[64];
+} VAIQMatrixBufferMPEG2;
+
+/* 
+ * There will be cases where the bitstream buffer will not have enough room to hold
+ * the data for the entire slice, and the following flags will be used in the slice
+ * parameter to signal to the server for the possible cases.
+ * If a slice parameter buffer and slice data buffer pair is sent to the server with 
+ * the slice data partially in the slice data buffer (BEGIN and MIDDLE cases below), 
+ * then a slice parameter and data buffer needs to be sent again to complete this slice. 
+ */
+#define VA_SLICE_DATA_FLAG_ALL         0x00    /* whole slice is in the buffer */
+#define VA_SLICE_DATA_FLAG_BEGIN       0x01    /* The beginning of the slice is in the buffer but the end if not */
+#define VA_SLICE_DATA_FLAG_MIDDLE      0x02    /* Neither beginning nor end of the slice is in the buffer */
+#define VA_SLICE_DATA_FLAG_END         0x04    /* end of the slice is in the buffer */
+
+/* MPEG-2 Slice Parameter Buffer */
+typedef struct _VASliceParameterBufferMPEG2
+{
+    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;
+
+/* MPEG-2 Macroblock Parameter Buffer */
+typedef struct _VAMacroblockParameterBufferMPEG2
+{
+    unsigned short macroblock_address;
+    /* 
+     * macroblock_address (in raster scan order)
+     * top-left: 0
+     * bottom-right: picture-height-in-mb*picture-width-in-mb - 1
+     */
+    unsigned char macroblock_type;  /* see definition below */
+    union {
+        struct {
+            unsigned char frame_motion_type            : 2; 
+            unsigned char field_motion_type            : 2; 
+            unsigned char dct_type                     : 1; 
+        };
+        unsigned char macroblock_modes;
+    };
+    unsigned char motion_vertical_field_select; 
+    /* 
+     * motion_vertical_field_select:
+     * see section 6.3.17.2 in the spec
+     * only the lower 4 bits are used
+     * bit 0: first vector forward
+     * bit 1: first vector backward
+     * bit 2: second vector forward
+     * bit 3: second vector backward
+     */
+    short PMV[2][2][2]; /* see Table 7-7 in the spec */
+    unsigned short coded_block_pattern;
+    /* 
+     * The bitplanes for coded_block_pattern are described 
+     * in Figure 6.10-12 in the spec
+     */
+} VAMacroblockParameterBufferMPEG2;
+
+/* 
+ * OR'd flags for macroblock_type (section 6.3.17.1 in the spec)
+ */
+#define VA_MB_TYPE_MOTION_FORWARD      0x02
+#define VA_MB_TYPE_MOTION_BACKWARD     0x04
+#define VA_MB_TYPE_MOTION_PATTERN      0x08
+#define VA_MB_TYPE_MOTION_INTRA                0x10
+
+/* 
+ * MPEG-2 Residual Data Buffer 
+ * For each macroblock, there wil be 64 shorts (16-bit) in the 
+ * residual data buffer
+ */
+
+/****************************
+ * MPEG-4 Part 2 data structures
+ ****************************/
+/* MPEG-4 Picture Parameter Buffer */
+typedef struct _VAPictureParameterBufferMPEG4
+{
+    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;
+
+/* MPEG-4 Inverse Quantization Matrix Buffer */
+typedef struct _VAIQMatrixBufferMPEG4
+{
+    int load_intra_quant_mat;
+    int load_non_intra_quant_mat;
+    unsigned char intra_quant_mat[64];
+    unsigned char non_intra_quant_mat[64];
+} VAIQMatrixBufferMPEG4;
+
+/* MPEG-4 Slice Parameter Buffer */
+typedef struct _VASliceParameterBufferMPEG4
+{
+    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 macroblock_number;
+    int quant_scale;
+} VASliceParameterBufferMPEG4;
+
+/*
+ VC-1 data structures
+*/
+/* VC-1 Picture Parameter Buffer */
+typedef struct _VAPictureParameterBufferVC1
+{
+    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;
+
+    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 conditional_overlap_flag; /* ENTRY_POINT_LAYER::CONDOVER */
+    unsigned char fast_uvmc_flag;      /* ENTRY_POINT_LAYER::FASTUVMC */
+    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::RNDCTRL */
+    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 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 foward_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 reference_distance_flag : 1;/* PICTURE_LAYER::REFDIST_FLAG */
+            unsigned char reference_distance   : 1;/* 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 {
+            unsigned char mv_mode      : 2;    /* PICTURE_LAYER::MVMODE */
+            unsigned char mv_mode2     : 2;    /* 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 half_qp      : 1;    /* PICTURE_LAYER::HALFQP */
+            unsigned char pic_quantizer_scale : 1;/* PICTURE_LAYER::PQUANT */
+            unsigned char pic_quantizer_type : 1;/* PICTURE_LAYER::PQUANTIZER */
+            unsigned char dq_frame     : 1;    /* VOPDQUANT::DQUANTFRM */
+            unsigned char dq_profile   : 1;    /* VOPDQUANT::DQPROFILE */
+            unsigned char dq_binary_level : 1;         /* VOPDQUANT::DQBILEVEL */
+            unsigned char alt_pic_quantizer : 5;/* VOPDQUANT::ALTPQUANT */
+        };
+        unsigned short 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;
+
+/* VC-1 Bitplane Buffer 
+There will be at most three bitplanes coded in any picture header. To send 
+the bitplane data more efficiently, each byte is divided in two nibbles, with
+each nibble carrying three bitplanes for one macroblock.  The following table
+shows the bitplane data arrangement within each nibble based on the picture
+type.
+
+Picture Type   Bit3            Bit2            Bit1            Bit0
+I or BI                                OVERFLAGS       ACPRED          FIELDTX
+P                              MYTYPEMB        SKIPMB          DIRECTMB
+B                              FORWARDMB       SKIPMB          DIRECTMB
+
+Within each byte, the lower nibble is for the first MB and the upper nibble is 
+for the second MB.  E.g. the lower nibble of the first byte in the bitplane
+buffer is for Macroblock #1 and the upper nibble of the first byte is for 
+Macroblock #2 in the first row.
+*/
+
+/* VC-1 Slice Parameter Buffer */
+typedef struct _VASliceParameterBufferVC1
+{
+    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;
+} VASliceParameterBufferVC1;
+
+/* VC-1 Slice Data Buffer */
+/* 
+This is simplely a buffer containing raw bit-stream bytes 
+*/
+
+/****************************
+ * H.264/AVC data structures
+ ****************************/
+
+typedef struct _VAPictureH264
+{
+    VASurfaceID picture_id;
+    unsigned int flags;
+    unsigned int TopFieldOrderCnt;
+    unsigned int BottomFieldOrderCnt;
+} VAPictureH264;
+/* flags in VAPictureH264 could be OR of the following */
+#define VA_PICTURE_H264_INVALID                        0x00000001
+#define VA_PICTURE_H264_TOP_FIELD              0x00000002
+#define VA_PICTURE_H264_BOTTOM_FIELD           0x00000004
+#define VA_PICTURE_H264_SHORT_TERM_REFERENCE   0x00000008
+#define VA_PICTURE_H264_LONG_TERM_REFERENCE    0x00000010
+#define VA_PICTURE_H264_USED_AS_REFERENCE      0x00000020
+
+/* H.264 Picture Parameter Buffer */
+typedef struct _VAPictureParameterBufferH264
+{
+    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 seq_fields;
+    };
+    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;
+    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 field_pic_flag               : 1;
+        };
+        unsigned char pic_fields;
+    };
+    unsigned short frame_num;
+} VAPictureParameterBufferH264;
+
+/* H.264 Inverse Quantization Matrix Buffer */
+typedef struct _VAIQMatrixBufferH264
+{
+    unsigned char ScalingList4x4[6][16];
+    unsigned char ScalingList8x8[2][64];
+} VAIQMatrixBufferH264;
+
+/* 
+ * H.264 Slice Group Map Buffer 
+ * When VAPictureParameterBufferH264::num_slice_group_minus1 is not equal to 0,
+ * A slice group map buffer should be sent for each picture if required. The buffer
+ * is sent only when there is a change in the mapping values.
+ * The slice group map buffer map "map units" to slice groups as specified in 
+ * section 8.2.2 of the H.264 spec. The buffer will contain one byte for each macroblock 
+ * in raster scan order
+ */ 
+
+/* H.264 Slice Parameter Buffer */
+typedef struct _VASliceParameterBufferH264
+{
+    unsigned int slice_data_size;/* number of bytes in the slice data buffer for this slice */
+    unsigned int slice_data_offset;/* the offset to first byte of slice data */
+    unsigned int slice_data_flag; /* see VA_SLICE_DATA_FLAG_XXX defintions */
+    unsigned short slice_data_bit_offset; /* bit offset in the first byte of valid data */
+    unsigned short first_mb_in_slice;
+    unsigned char slice_type;
+    unsigned char direct_spatial_mv_pred_flag;
+    unsigned char num_ref_idx_10_active_minus1;
+    unsigned char num_ref_idx_11_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;
+} VASliceParameterBufferH264;
+
+/* Buffer functions */
+
+/*
+ * Creates a buffer for storing a certain type of data, no data store allocated
+ */
+VAStatus vaCreateBuffer (
+    VADisplay dpy,
+    VABufferType type, /* in */
+    VABufferID *buf_id /* out */
+);
+
+/*
+ * Create data store for the buffer and initalize with "data".
+ * if "data" is null, then the contents of the buffer data store
+ * are undefined.
+ * Basically there are two ways to get buffer data to the server side. One is 
+ * to call vaBufferData() with a non-null "data", which results the data being
+ * copied to the data store on the server side.  A different method that 
+ * eliminates this copy is to pass null as "data" when calling vaBufferData(),
+ * and then use vaMapBuffer() to map the data store from the server side to the
+ * client address space for access.
+ */
+VAStatus vaBufferData (
+    VADisplay dpy,
+    VABufferID buf_id, /* in */
+    unsigned int size, /* in */
+    unsigned int num_elements, /* in */
+    void *data         /* in */
+);
+
+/*
+ * Convey to the server how many valid elements are in the buffer. 
+ * e.g. if multiple slice parameters are being held in a single buffer,
+ * this will communicate to the server the number of slice parameters
+ * that are valid in the buffer.
+ */
+VAStatus vaBufferSetNumElements (
+    VADisplay dpy,
+    VABufferID buf_id, /* in */
+    unsigned int num_elements /* in */
+);
+
+/*
+ * Map data store of the buffer into the client's address space
+ * vaBufferData() needs to be called with "data" set to NULL before
+ * calling vaMapBuffer()
+ */
+VAStatus vaMapBuffer (
+    VADisplay dpy,
+    VABufferID buf_id, /* in */
+    void **pbuf        /* out */
+);
+
+/*
+ * After client making changes to a mapped data store, it needs to
+ * "Unmap" it to let the server know that the data is ready to be
+ * consumed by the server
+ */
+VAStatus vaUnmapBuffer (
+    VADisplay dpy,
+    VABufferID buf_id  /* in */
+);
+
+/*
+ * After this call, the buffer is deleted and this buffer_id is no longer valid
+ */
+VAStatus vaDestroyBuffer (
+    VADisplay dpy,
+    VABufferID buffer_id
+);
+
+/*
+Render (Decode) Pictures
+
+A picture represents either a frame or a field.
+
+The Begin/Render/End sequence sends the decode buffers to the server
+*/
+
+/*
+ * Get ready to decode a picture to a target surface
+ */
+VAStatus vaBeginPicture (
+    VADisplay dpy,
+    VAContext *context,
+    VASurface *render_target
+);
+
+/* 
+ * Send decode buffers to the server.
+ */
+VAStatus vaRenderPicture (
+    VADisplay dpy,
+    VAContext *context,
+    VABufferID *buffers,
+    int num_buffers
+);
+
+/* 
+ * Make the end of rendering for a picture. 
+ * The server should start processing all pending operations for this 
+ * surface. This call is non-blocking. The client can start another 
+ * Begin/Render/End sequence on a different render target.
+ */
+VAStatus vaEndPicture (
+    VADisplay dpy,
+    VAContext *context
+);
+
+/*
+
+Synchronization 
+
+*/
+
+/* 
+ * This function blocks until all pending operations on the render target
+ * have been completed.  Upon return it is safe to use the render target for a 
+ * different picture. 
+ */
+VAStatus vaSyncSurface (
+    VADisplay dpy,
+    VAContext *context,
+    VASurface *render_target
+);
+
+typedef enum
+{
+    VASurfaceRendering = 0,
+    VASurfaceReady     = 1,
+} VASurfaceStatus;
+
+/*
+ * Find out any pending ops on the render target 
+ */
+VAStatus vaQuerySurfaceStatus (
+    VADisplay dpy,
+    VAContext *context,
+    VASurface *render_target,
+    VASurfaceStatus *status    /* out */
+);
+
+/*
+ * Copies the surface to a buffer
+ * The stride of the surface will be stored in *stride
+ * Caller should free the returned buffer with free() when done. 
+ */
+VAStatus vaDbgCopySurfaceToBuffer(VADisplay dpy,
+    VASurface *surface,
+    void **buffer, /* out */
+    unsigned int *stride /* out */
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VA_H_ */
+
+#if 0
+/*****************************************************************************/ 
+
+Sample Program (w/ pseudo code)
+
+Mostly to demonstrate program flow with no error handling ...
+
+/*****************************************************************************/
+
+       /* MPEG-2 VLD decode for a 720x480 frame */
+
+       int major_ver, minor_ver;
+       vaInitialize(dpy, &major_ver, &minor_ver);
+
+       int max_num_profiles, max_num_entrypoints, max_num_attribs;
+       max_num_profiles = vaMaxNumProfiles(dpy);
+       max_num_entrypoints = vaMaxNumProfiles(dpy);
+       max_num_attribs = vaMaxNumProfiles(dpy);
+
+       /* find out whether MPEG2 MP is supported */
+       VAProfile *profiles = malloc(sizeof(VAProfile)*max_num_profiles);
+       int num_profiles;
+       vaQueryConfigProfiles(dpy, profiles, &profiles);
+       /*
+        * traverse "profiles" to locate the one that matches VAProfileMPEG2Main
+         */ 
+
+       /* now get the available entrypoints for MPEG2 MP */
+       VAEntrypoint *entrypoints = malloc(sizeof(VAEntrypoint)*max_num_entrypoints);
+       int num_entrypoints;
+       vaQueryConfigEntrypoints(dpy, VAProfileMPEG2Main, entrypoints, &num_entrypoints);
+
+       /* traverse "entrypoints" to see whether VLD is there */
+
+       /* Assuming finding VLD, find out the format for the render target */
+       VAConfigAttrib attrib;
+       attrib.type = VAConfigAttribRTFormat;
+       vaQueryConfigAttributes(dpy, VAProfileMPEG2Main, VAEntrypointVLD,
+                                &attrib, 1);
+
+       if (attrib.value & VA_RT_FORMAT_YUV420)
+               /* Found desired RT format, keep going */ 
+
+       VAConfigID config_id;
+       vaCreateConfig(dpy, VAProfileMPEG2Main, VAEntrypointVLD, &attrib, 1,
+                       &config_id);
+
+       /* 
+         * create surfaces for the current target as well as reference frames
+        * we can get by with 4 surfaces for MPEG-2
+        */
+       VASurface surfaces[4];
+       vaCreateSurfaces(dpy, 720, 480, VA_RT_FORMAT_YUV420, 4, surfaces);
+
+       /* 
+         * Create a context for this decode pipe
+        */
+       VAContext context;
+       vaCreateContext(dpy, config_id, 720, 480, VA_PROGRESSIVE, surfaces,
+                        4, &context);
+
+       /* Create a picture parameter buffer for this frame */
+       VABufferID picture_buf;
+       VAPictureParameterBufferMPEG2 *picture_param;
+       vaCreateBuffer(dpy, VAPictureParameterBufferType, &picture_buf);
+       vaBufferData(dpy, picture_buf, sizeof(VAPictureParameterBufferMPEG2), NULL);
+       vaMapBuffer(dpy, picture_buf, &picture_param);
+       picture_param->horizontal_size = 720;
+       picture_param->vertical_size = 480;
+       picture_param->picture_coding_type = 1; /* I-frame */   
+       /* fill in picture_coding_extension fields here */
+       vaUnmapBuffer(dpy, picture_buf);
+
+
+       /* Create an IQ matrix buffer for this frame */
+       VABufferID iq_buf;
+       VAIQMatrixBufferMPEG2 *iq_matrix;
+       vaCreateBuffer(dpy, VAIQMatrixBufferType, &iq_buf);
+       vaBufferData(dpy, iq_buf, sizeof(VAIQMatrixBufferMPEG2), NULL);
+       vaMapBuffer(dpy, iq_buf, &iq_matrix);
+       /* fill values for IQ_matrix here */
+       vaUnmapBuffer(dpy, iq_buf);
+
+       /* send the picture and IQ matrix buffers to the server */
+       vaBeginPicture(dpy, context, &surfaces[0]);
+
+       vaRenderPicture(dpy, context, &picture_buf, 1);
+       vaRenderPicture(dpy, context, &iq_buf, 1);
+
+       /* 
+         * Send slices in this frame to the server.
+         * For MPEG-2, each slice is one row of macroblocks, and
+         * we have 30 slices for a 720x480 frame 
+         */
+       for (int i = 1; i <= 30; i++) {
+
+               /* Create a slice parameter buffer */
+               VABufferID slice_param_buf;
+               VASliceParameterBufferMPEG2 *slice_param;
+               vaCreateBuffer(dpy, VASliceParameterBufferType, &slice_param_buf);
+               vaBufferData(dpy, slice_param_buf, sizeof(VASliceParameterBufferMPEG2), NULL);
+               vaMapBuffer(dpy, slice_param_buf, &slice_param);
+               slice_param->slice_data_offset = 0;
+               /* Let's say all slices in this bit-stream has 64-bit header */
+               slice_param->macroblock_offset = 64; 
+               slice_param->vertical_position = i;
+               /* set up the rest based on what is in the slice header ... */
+               vaUnmapBuffer(dpy, slice_param_buf);
+
+               /* send the slice parameter buffer */
+               vaRenderPicture(dpy, context, &slice_param_buf, 1);
+
+               /* Create a slice data buffer */
+               unsigned char *slice_data;
+               VABufferID slice_data_buf;
+               vaCreateBuffer(dpy, VASliceDataBufferType, slice_data_buf);
+               vaBufferData(dpy, slice_data_buf, x /* decoder figure out how big */, NULL);
+               vaMapBuffer(dpy, slice_data_buf, &slice_data);
+               /* decoder fill in slice_data */
+               vaUnmapBuffer(dpy, slice_data_buf);
+
+               /* send the slice data buffer */
+               vaRenderPicture(dpy, context, &slice_data_buf, 1);
+       }
+
+       /* all slices have been sent, mark the end for this frame */
+       vaEndPicture(dpy, context);
+#endif
diff --git a/src/va_backend.h b/src/va_backend.h
new file mode 100755 (executable)
index 0000000..7e7bda7
--- /dev/null
@@ -0,0 +1,200 @@
+/*
+ * Video Decode Acceleration -Backend API
+ *
+ * @COPYRIGHT@ Intel Confidential - Unreleased Software
+ */
+
+#ifndef _VA_BACKEND_H_
+#define _VA_BACKEND_H_
+
+#include "va.h"
+#include "va_x11.h"
+
+#include <stdlib.h>
+
+typedef struct VADriverContext *VADriverContextP;
+
+struct VADriverContext
+{
+    VADriverContextP pNext;
+    Display *x11_dpy;
+    int x11_screen;
+    int version_major;
+    int version_minor;
+    int max_profiles;
+    int max_entrypoints;
+    int max_attributes;
+    void *handle;                      /* dlopen handle */
+    void *pDriverData;
+    struct
+    {
+    VAStatus (*vaTerminate) ( VADriverContextP ctx );
+
+    VAStatus (*vaQueryConfigProfiles) (
+               VADriverContextP ctx,
+               VAProfile *profile_list,        /* out */
+               int *num_profiles                       /* out */
+       );
+
+    VAStatus (*vaQueryConfigEntrypoints) (
+               VADriverContextP ctx,
+               VAProfile profile,
+               VAEntrypoint  *entrypoint_list, /* out */
+               int *num_entrypoints                    /* out */
+       );
+
+       VAStatus (*vaQueryConfigAttributes) (
+               VADriverContextP ctx,
+               VAProfile profile,
+               VAEntrypoint entrypoint,
+               VAConfigAttrib *attrib_list,    /* in/out */
+               int num_attribs
+       );
+
+       VAStatus (*vaCreateConfig) (
+               VADriverContextP ctx,
+               VAProfile profile, 
+               VAEntrypoint entrypoint, 
+               VAConfigAttrib *attrib_list,
+               int num_attribs,
+               VAConfigID *config_id           /* out */
+       );
+
+       VAStatus (*vaGetConfigAttributes) (
+               VADriverContextP ctx,
+               VAConfigID config_id, 
+               VAProfile *profile,             /* out */
+               VAEntrypoint *entrypoint,       /* out */
+               VAConfigAttrib *attrib_list,    /* out */
+               int *num_attribs                /* out */
+       );
+
+       VAStatus (*vaCreateSurfaces) (
+               VADriverContextP ctx,
+               int width,
+               int height,
+               int format,
+               int num_surfaces,
+               VASurface *surfaces             /* out */
+       );
+
+       VAStatus (*vaDestroySurface) (
+               VADriverContextP ctx,
+               VASurface *surface_list,
+               int num_surfaces
+       );
+
+       VAStatus (*vaCreateContext) (
+               VADriverContextP ctx,
+               VAConfigID config_id,
+               int picture_width,
+               int picture_height,
+               int flag,
+               VASurface *render_targets,
+               int num_render_targets,
+               VAContext *context              /* out */
+       );
+
+       VAStatus (*vaDestroyContext) (
+               VADriverContextP ctx,
+               VAContext *context
+       );
+
+       VAStatus (*vaCreateBuffer) (
+               VADriverContextP ctx,
+               VABufferType type,  /* in */
+               VABufferID *buf_desc    /* out */
+       );
+
+       VAStatus (*vaBufferData) (
+               VADriverContextP ctx,
+               VABufferID buf_id,      /* in */
+        unsigned int size,     /* in */
+        unsigned int num_elements,     /* in */
+        void *data             /* in */
+       );
+
+       VAStatus (*vaBufferSetNumElements) (
+               VADriverContextP ctx,
+               VABufferID buf_id,      /* in */
+        unsigned int num_elements      /* in */
+       );
+
+       VAStatus (*vaMapBuffer) (
+               VADriverContextP ctx,
+               VABufferID buf_id,      /* in */
+               void **pbuf         /* out */
+       );
+
+       VAStatus (*vaUnmapBuffer) (
+               VADriverContextP ctx,
+               VABufferID buf_id       /* in */
+       );
+
+       VAStatus (*vaDestroyBuffer) (
+               VADriverContextP ctx,
+               VABufferID buffer_id
+       );
+
+       VAStatus (*vaBeginPicture) (
+               VADriverContextP ctx,
+               VAContext *context,
+               VASurface *render_target
+       );
+
+       VAStatus (*vaRenderPicture) (
+               VADriverContextP ctx,
+               VAContext *context,
+               VABufferID *buffers,
+               int num_buffers
+       );
+
+       VAStatus (*vaEndPicture) (
+               VADriverContextP ctx,
+               VAContext *context
+       );
+
+       VAStatus (*vaSyncSurface) (
+               VADriverContextP ctx,
+               VAContext *context,
+               VASurface *render_target
+       );
+
+       VAStatus (*vaQuerySurfaceStatus) (
+               VADriverContextP ctx,
+               VAContext *context,
+               VASurface *render_target,
+               VASurfaceStatus *status /* out */
+       );
+
+       VAStatus (*vaPutSurface) (
+               VADriverContextP ctx,
+               VASurface *surface,
+               Drawable draw, /* X Drawable */
+               short srcx,
+               short srcy,
+               unsigned short srcw,
+               unsigned short srch,
+               short destx,
+               short desty,
+               unsigned short destw,
+               unsigned short desth,
+               int flags /* de-interlacing flags */
+       );
+
+       VAStatus (*vaDbgCopySurfaceToBuffer) (
+               VADriverContextP ctx,
+               VASurface *surface,
+               void **buffer, /* out */
+               unsigned int *stride /* out */
+       );
+
+    } vtable;
+};
+
+typedef VAStatus (*VADriverInit) (
+    VADriverContextP driver_context
+);
+
+
+#endif /* _VA_BACKEND_H_ */
diff --git a/src/va_x11.h b/src/va_x11.h
new file mode 100755 (executable)
index 0000000..60c29b2
--- /dev/null
@@ -0,0 +1,54 @@
+/*
+ * Video Decode Acceleration API, X11 specific functions
+ *
+ * Rev. 0.15
+ * <jonathan.bian@intel.com>
+ *
+ * Revision History:
+ * rev 0.1 (12/10/06 Jonathan Bian) - Initial draft
+ * rev 0.11 (12/15/06 Jonathan Bian) - Fixed some errors
+ * rev 0.12 (02/05/07 Jonathan Bian) - Added VC-1 data structures
+ * rev 0.13 (02/28/07 Jonathan Bian) - Added GetDisplay()
+ * rev 0.14 (04/13/07 Jonathan Bian) - Fixed MPEG-2 PictureParameter struct, cleaned up a few funcs.
+ * rev 0.15 (04/20/07 Jonathan Bian) - Overhauled buffer management  
+ *
+ */
+
+#ifndef _VA_X11_H_
+#define _VA_X11_H_
+
+#include "va.h"
+#include <X11/Xlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Output rendering
+ * Following is the rendering interface for X windows, 
+ * to get the decode output surface to a X drawable
+ * It basically performs a de-interlacing (if needed), 
+ * color space conversion and scaling to the destination
+ * rectangle
+ */
+VAStatus vaPutSurface (
+    VADisplay dpy,
+    VASurface *surface,
+    Drawable draw, /* X Drawable */
+    short srcx,
+    short srcy,
+    unsigned short srcw,
+    unsigned short srch,
+    short destx,
+    short desty,
+    unsigned short destw,
+    unsigned short desth,
+    int flags /* de-interlacing flags */
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VA_X11_H_ */
diff --git a/src/xf86dri.h b/src/xf86dri.h
new file mode 100644 (file)
index 0000000..6984427
--- /dev/null
@@ -0,0 +1,122 @@
+/* $XFree86: xc/lib/GL/dri/xf86dri.h,v 1.8 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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.
+
+**************************************************************************/
+
+/**
+ * \file xf86dri.h
+ * Protocol numbers and function prototypes for DRI X protocol.
+ *
+ * \author Kevin E. Martin <martin@valinux.com>
+ * \author Jens Owen <jens@tungstengraphics.com>
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ */
+
+#ifndef _XF86DRI_H_
+#define _XF86DRI_H_
+
+#include <X11/Xfuncproto.h>
+#include <xf86drm.h>
+
+#define X_XF86DRIQueryVersion                  0
+#define X_XF86DRIQueryDirectRenderingCapable   1
+#define X_XF86DRIOpenConnection                        2
+#define X_XF86DRICloseConnection               3
+#define X_XF86DRIGetClientDriverName           4
+#define X_XF86DRICreateContext                 5
+#define X_XF86DRIDestroyContext                        6
+#define X_XF86DRICreateDrawable                        7
+#define X_XF86DRIDestroyDrawable               8
+#define X_XF86DRIGetDrawableInfo               9
+#define X_XF86DRIGetDeviceInfo                 10
+#define X_XF86DRIAuthConnection                 11
+#define X_XF86DRIOpenFullScreen                 12   /* Deprecated */
+#define X_XF86DRICloseFullScreen                13   /* Deprecated */
+
+#define XF86DRINumberEvents            0
+
+#define XF86DRIClientNotLocal          0
+#define XF86DRIOperationNotSupported   1
+#define XF86DRINumberErrors            (XF86DRIOperationNotSupported + 1)
+
+#ifndef _XF86DRI_SERVER_
+
+#include "dri_interface.h"
+
+_XFUNCPROTOBEGIN
+
+Bool XF86DRIQueryExtension( Display *dpy, int *event_base, int *error_base );
+
+Bool XF86DRIQueryVersion( Display *dpy, int *majorVersion, int *minorVersion,
+    int *patchVersion );
+
+Bool XF86DRIQueryDirectRenderingCapable( Display *dpy, int screen,
+    Bool *isCapable );
+
+Bool XF86DRIOpenConnection( Display *dpy, int screen, drm_handle_t *hSAREA,
+    char **busIDString );
+
+Bool XF86DRIAuthConnection( Display *dpy, int screen, drm_magic_t magic );
+
+Bool XF86DRICloseConnection( Display *dpy, int screen );
+
+Bool XF86DRIGetClientDriverName( Display *dpy, int screen,
+    int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
+    int *ddxDriverPatchVersion, char **clientDriverName );
+
+Bool XF86DRICreateContext( Display *dpy, int screen, Visual *visual,
+    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+
+Bool XF86DRICreateContextWithConfig( Display *dpy, int screen, int configID,
+    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+
+extern GLboolean XF86DRIDestroyContext( __DRInativeDisplay *dpy, int screen,
+    __DRIid context_id );
+
+extern GLboolean XF86DRICreateDrawable( __DRInativeDisplay *dpy, int screen,
+    __DRIid drawable, drm_drawable_t *hHWDrawable );
+
+extern GLboolean XF86DRIDestroyDrawable( __DRInativeDisplay *dpy, int screen, 
+    __DRIid drawable);
+
+Bool XF86DRIGetDrawableInfo( Display *dpy, int screen, Drawable drawable,
+    unsigned int *index, unsigned int *stamp, 
+    int *X, int *Y, int *W, int *H,
+    int *numClipRects, drm_clip_rect_t ** pClipRects,
+    int *backX, int *backY,
+    int *numBackClipRects, drm_clip_rect_t **pBackClipRects );
+
+Bool XF86DRIGetDeviceInfo( Display *dpy, int screen,
+    drm_handle_t *hFrameBuffer, int *fbOrigin, int *fbSize,
+    int *fbStride, int *devPrivateSize, void **pDevPrivate );
+
+_XFUNCPROTOEND
+
+#endif /* _XF86DRI_SERVER_ */
+
+#endif /* _XF86DRI_H_ */
+
diff --git a/src/xf86dristr.h b/src/xf86dristr.h
new file mode 100644 (file)
index 0000000..ac05b18
--- /dev/null
@@ -0,0 +1,343 @@
+/* $XFree86: xc/lib/GL/dri/xf86dristr.h,v 1.10 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <martin@valinux.com>
+ *   Jens Owen <jens@tungstengraphics.com>
+ *   Rickard E. (Rik) Fiath <faith@valinux.com>
+ *
+ */
+
+#ifndef _XF86DRISTR_H_
+#define _XF86DRISTR_H_
+
+#include "xf86dri.h"
+
+#define XF86DRINAME "XFree86-DRI"
+
+/* The DRI version number.  This was originally set to be the same of the
+ * XFree86 version number.  However, this version is really indepedent of
+ * the XFree86 version.
+ *
+ * Version History:
+ *    4.0.0: Original
+ *    4.0.1: Patch to bump clipstamp when windows are destroyed, 28 May 02
+ *    4.1.0: Add transition from single to multi in DRMInfo rec, 24 Jun 02
+ */
+#define XF86DRI_MAJOR_VERSION  4
+#define XF86DRI_MINOR_VERSION  1
+#define XF86DRI_PATCH_VERSION  0
+
+typedef struct _XF86DRIQueryVersion {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRIQueryVersion */
+    CARD16     length B16;
+} xXF86DRIQueryVersionReq;
+#define sz_xXF86DRIQueryVersionReq     4
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    CARD16     majorVersion B16;       /* major version of DRI protocol */
+    CARD16     minorVersion B16;       /* minor version of DRI protocol */
+    CARD32     patchVersion B32;       /* patch version of DRI protocol */
+    CARD32     pad3 B32;
+    CARD32     pad4 B32;
+    CARD32     pad5 B32;
+    CARD32     pad6 B32;
+} xXF86DRIQueryVersionReply;
+#define sz_xXF86DRIQueryVersionReply   32
+
+typedef struct _XF86DRIQueryDirectRenderingCapable {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* X_DRIQueryDirectRenderingCapable */
+    CARD16     length B16;
+    CARD32     screen B32;
+} xXF86DRIQueryDirectRenderingCapableReq;
+#define sz_xXF86DRIQueryDirectRenderingCapableReq      8
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    BOOL       isCapable;
+    BOOL       pad2;
+    BOOL       pad3;
+    BOOL       pad4;
+    CARD32     pad5 B32;
+    CARD32     pad6 B32;
+    CARD32     pad7 B32;
+    CARD32     pad8 B32;
+    CARD32     pad9 B32;
+} xXF86DRIQueryDirectRenderingCapableReply;
+#define sz_xXF86DRIQueryDirectRenderingCapableReply    32
+
+typedef struct _XF86DRIOpenConnection {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRIOpenConnection */
+    CARD16     length B16;
+    CARD32     screen B32;
+} xXF86DRIOpenConnectionReq;
+#define sz_xXF86DRIOpenConnectionReq   8
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    CARD32     hSAREALow B32;
+    CARD32     hSAREAHigh B32;
+    CARD32     busIdStringLength B32;
+    CARD32     pad6 B32;
+    CARD32     pad7 B32;
+    CARD32     pad8 B32;
+} xXF86DRIOpenConnectionReply;
+#define sz_xXF86DRIOpenConnectionReply 32
+
+typedef struct _XF86DRIAuthConnection {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRICloseConnection */
+    CARD16     length B16;
+    CARD32     screen B32;
+    CARD32      magic B32;
+} xXF86DRIAuthConnectionReq;
+#define sz_xXF86DRIAuthConnectionReq   12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      authenticated B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+} xXF86DRIAuthConnectionReply;
+#define zx_xXF86DRIAuthConnectionReply  32
+
+typedef struct _XF86DRICloseConnection {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRICloseConnection */
+    CARD16     length B16;
+    CARD32     screen B32;
+} xXF86DRICloseConnectionReq;
+#define sz_xXF86DRICloseConnectionReq  8
+
+typedef struct _XF86DRIGetClientDriverName {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRIGetClientDriverName */
+    CARD16     length B16;
+    CARD32     screen B32;
+} xXF86DRIGetClientDriverNameReq;
+#define sz_xXF86DRIGetClientDriverNameReq      8
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    CARD32     ddxDriverMajorVersion B32;
+    CARD32     ddxDriverMinorVersion B32;
+    CARD32     ddxDriverPatchVersion B32;
+    CARD32     clientDriverNameLength B32;
+    CARD32     pad5 B32;
+    CARD32     pad6 B32;
+} xXF86DRIGetClientDriverNameReply;
+#define sz_xXF86DRIGetClientDriverNameReply    32
+
+typedef struct _XF86DRICreateContext {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRICreateContext */
+    CARD16     length B16;
+    CARD32     screen B32;
+    CARD32     visual B32;
+    CARD32     context B32;
+} xXF86DRICreateContextReq;
+#define sz_xXF86DRICreateContextReq    16
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    CARD32     hHWContext B32;
+    CARD32     pad2 B32;
+    CARD32     pad3 B32;
+    CARD32     pad4 B32;
+    CARD32     pad5 B32;
+    CARD32     pad6 B32;
+} xXF86DRICreateContextReply;
+#define sz_xXF86DRICreateContextReply  32
+
+typedef struct _XF86DRIDestroyContext {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRIDestroyContext */
+    CARD16     length B16;
+    CARD32     screen B32;
+    CARD32     context B32;
+} xXF86DRIDestroyContextReq;
+#define sz_xXF86DRIDestroyContextReq   12
+
+typedef struct _XF86DRICreateDrawable {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRICreateDrawable */
+    CARD16     length B16;
+    CARD32     screen B32;
+    CARD32     drawable B32;
+} xXF86DRICreateDrawableReq;
+#define sz_xXF86DRICreateDrawableReq   12
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    CARD32     hHWDrawable B32;
+    CARD32     pad2 B32;
+    CARD32     pad3 B32;
+    CARD32     pad4 B32;
+    CARD32     pad5 B32;
+    CARD32     pad6 B32;
+} xXF86DRICreateDrawableReply;
+#define sz_xXF86DRICreateDrawableReply 32
+
+typedef struct _XF86DRIDestroyDrawable {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRIDestroyDrawable */
+    CARD16     length B16;
+    CARD32     screen B32;
+    CARD32     drawable B32;
+} xXF86DRIDestroyDrawableReq;
+#define sz_xXF86DRIDestroyDrawableReq  12
+
+typedef struct _XF86DRIGetDrawableInfo {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRIGetDrawableInfo */
+    CARD16     length B16;
+    CARD32     screen B32;
+    CARD32     drawable B32;
+} xXF86DRIGetDrawableInfoReq;
+#define sz_xXF86DRIGetDrawableInfoReq  12
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    CARD32     drawableTableIndex B32;
+    CARD32     drawableTableStamp B32;
+    INT16      drawableX B16;
+    INT16      drawableY B16;
+    INT16      drawableWidth B16;
+    INT16      drawableHeight B16;
+    CARD32     numClipRects B32;
+    INT16       backX B16;
+    INT16       backY B16;
+    CARD32      numBackClipRects B32;
+} xXF86DRIGetDrawableInfoReply;
+
+#define sz_xXF86DRIGetDrawableInfoReply        36
+
+
+typedef struct _XF86DRIGetDeviceInfo {
+    CARD8      reqType;                /* always DRIReqCode */
+    CARD8      driReqType;             /* always X_DRIGetDeviceInfo */
+    CARD16     length B16;
+    CARD32     screen B32;
+} xXF86DRIGetDeviceInfoReq;
+#define sz_xXF86DRIGetDeviceInfoReq    8
+
+typedef struct {
+    BYTE       type;                   /* X_Reply */
+    BOOL       pad1;
+    CARD16     sequenceNumber B16;
+    CARD32     length B32;
+    CARD32     hFrameBufferLow B32;
+    CARD32     hFrameBufferHigh B32;
+    CARD32     framebufferOrigin B32;
+    CARD32     framebufferSize B32;
+    CARD32     framebufferStride B32;
+    CARD32     devPrivateSize B32;
+} xXF86DRIGetDeviceInfoReply;
+#define sz_xXF86DRIGetDeviceInfoReply  32
+
+typedef struct _XF86DRIOpenFullScreen {
+    CARD8       reqType;       /* always DRIReqCode */
+    CARD8       driReqType;    /* always X_DRIOpenFullScreen */
+    CARD16      length B16;
+    CARD32      screen B32;
+    CARD32      drawable B32;
+} xXF86DRIOpenFullScreenReq;
+#define sz_xXF86DRIOpenFullScreenReq    12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      isFullScreen B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+} xXF86DRIOpenFullScreenReply;
+#define sz_xXF86DRIOpenFullScreenReply  32
+
+typedef struct _XF86DRICloseFullScreen {
+    CARD8       reqType;       /* always DRIReqCode */
+    CARD8       driReqType;    /* always X_DRICloseFullScreen */
+    CARD16      length B16;
+    CARD32      screen B32;
+    CARD32      drawable B32;
+} xXF86DRICloseFullScreenReq;
+#define sz_xXF86DRICloseFullScreenReq   12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+    CARD32      pad7 B32;
+} xXF86DRICloseFullScreenReply;
+#define sz_xXF86DRICloseFullScreenReply  32
+
+
+#endif /* _XF86DRISTR_H_ */
diff --git a/test/Makefile.am b/test/Makefile.am
new file mode 100644 (file)
index 0000000..dc6afce
--- /dev/null
@@ -0,0 +1,13 @@
+#  @COPYRIGHT@ Intel Confidential - Unreleased Software
+
+check_PROGRAMS = test
+testdir = $(bindir)
+
+# This gives better backtraces when running valgrind:
+# test_LDADD = ../src/libva.la ../../psb-video/src/psb_drv_video.la
+test_LDADD = ../src/libva.la
+
+AM_CFLAGS = -I$(top_srcdir)/../../include/external/ -I$(top_srcdir)/src
+test_SOURCES = test.c
+
+TESTS = $(check_PROGRAMS)
\ No newline at end of file
diff --git a/test/test.c b/test/test.c
new file mode 100644 (file)
index 0000000..2e08737
--- /dev/null
@@ -0,0 +1,132 @@
+/*
+ * @COPYRIGHT@ Intel Confidential - Unreleased Software
+ */
+
+#include "va.h"
+#include "X11/Xlib.h"
+
+#include "assert.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <dlfcn.h>
+
+#define ASSERT assert
+
+int main(int argc, const char* argv[])
+{
+  Display *dpy;
+  VADisplay va_dpy;
+  VAStatus va_status;
+  int major_version, minor_version; 
+   
+  dpy = XOpenDisplay(NULL);
+  ASSERT( dpy );
+  printf("XOpenDisplay: dpy = %08x\n", dpy);
+  
+  va_dpy = vaGetDisplay(dpy);
+  ASSERT( va_dpy );  
+  printf("vaGetDisplay: va_dpy = %08x\n", va_dpy);
+  
+  va_status = vaInitialize(va_dpy, &major_version, &minor_version);
+  ASSERT( VA_STATUS_SUCCESS == va_status );
+  printf("vaInitialize: major = %d minor = %d\n", major_version, minor_version);
+
+  {
+      VASurface surfaces[21];
+      int i;
+      
+      surfaces[20].surface_id = -1;
+      va_status = vaCreateSurfaces(va_dpy, 720, 480, VA_RT_FORMAT_YUV420, 20, surfaces);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+      ASSERT( -1 == surfaces[20].surface_id ); /* bounds check */
+      for(i = 0; i < 20; i++)
+      {
+          printf("Surface %d surface_id = %08x\n", i, surfaces[i].surface_id);
+      }
+      Window win = XCreateSimpleWindow(dpy, RootWindow(dpy, 0), 0, 0, 720, 480, 0, 0, WhitePixel(dpy, 0));
+      printf("Window = %08x\n", win); 
+      XMapWindow(dpy, win);
+      XSync(dpy, False);
+      
+      vaPutSurface(va_dpy, &(surfaces[0]), win, 0, 0, 720, 480, 0, 0, 720, 480, 0); 
+
+      sleep(10);
+      va_status = vaDestroySurface(va_dpy, surfaces, 20);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+  }
+  
+  {
+      int num_profiles;
+      int i;
+      VAProfile *profiles = malloc(vaMaxNumProfiles(va_dpy) * sizeof(VAProfile));
+      ASSERT(profiles);
+      printf("vaMaxNumProfiles = %d\n", vaMaxNumProfiles(va_dpy));
+      
+      va_status = vaQueryConfigProfiles(va_dpy, profiles, &num_profiles);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+      
+      printf("vaQueryConfigProfiles reports %d profiles\n", num_profiles);
+      for(i = 0; i < num_profiles; i++)
+      {
+          printf("Profile %d\n", profiles[i]);
+      }
+  }
+
+  {
+      VASurface surfaces[20];
+      VAContext context;
+      VAConfigAttrib attrib;
+      VAConfigID config_id;
+      int i;
+
+      attrib.type = VAConfigAttribRTFormat;
+      va_status = vaQueryConfigAttributes(va_dpy, VAProfileMPEG2Main, VAEntrypointVLD,
+                                &attrib, 1);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+
+      ASSERT(attrib.value & VA_RT_FORMAT_YUV420);
+      /* Found desired RT format, keep going */ 
+
+      va_status = vaCreateConfig(va_dpy, VAProfileMPEG2Main, VAEntrypointVLD, &attrib, 1,
+                       &config_id);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+
+      va_status = vaCreateSurfaces(va_dpy, 720, 480, VA_RT_FORMAT_YUV420, 20, surfaces);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+
+      va_status = vaCreateContext(va_dpy, config_id, 720, 480, 0 /* flag */, surfaces, 20, &context);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+
+      va_status = vaDestroyContext(va_dpy, &context);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+
+      va_status = vaDestroySurface(va_dpy, surfaces, 20);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+  }
+
+  {
+      VABufferID picture_buf[3];
+      va_status = vaCreateBuffer(va_dpy, VAPictureParameterBufferType, &picture_buf[0]);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+      va_status = vaCreateBuffer(va_dpy, VAPictureParameterBufferType, &picture_buf[1]);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+      va_status = vaCreateBuffer(va_dpy, VAPictureParameterBufferType, &picture_buf[2]);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+
+      va_status = vaDestroyBuffer(va_dpy, picture_buf[0]);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+      va_status = vaDestroyBuffer(va_dpy, picture_buf[2]);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+      va_status = vaDestroyBuffer(va_dpy, picture_buf[1]);
+      ASSERT( VA_STATUS_SUCCESS == va_status );
+  }
+
+  va_status = vaTerminate(va_dpy);
+  ASSERT( VA_STATUS_SUCCESS == va_status );
+  printf("vaTerminate\n");
+
+  XCloseDisplay(dpy);
+
+  return 0;
+}