--- /dev/null
+*~
+Makefile.in
+Makefile
--- /dev/null
+# @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
--- /dev/null
+#! /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 "$@"
--- /dev/null
+# @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])
--- /dev/null
+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
--- /dev/null
+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
+
--- /dev/null
+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.
+
--- /dev/null
+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.
--- /dev/null
+usr/bin
+usr/sbin
--- /dev/null
+libva-dev_0.18-1_i386.deb libdevel extra
+libva1_0.18-1_i386.deb libs extra
--- /dev/null
+usr/lib
+usr/include
--- /dev/null
+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
--- /dev/null
+shlibs:Depends=libc6 (>= 2.5-5)
--- /dev/null
+debian/tmp/usr/lib/libva.so.*
--- /dev/null
+shlibs:Depends=libc6 (>= 2.5-5), libx11-6, libxext6
--- /dev/null
+#!/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
--- /dev/null
+# @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
+
--- /dev/null
+/*
+ * @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;
+}
+
--- /dev/null
+/*
+ * @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_ */
--- /dev/null
+/*
+ * @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;
+}
--- /dev/null
+/*
+ * @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_ */
--- /dev/null
+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}
--- /dev/null
+# @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
--- /dev/null
+/* $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;
+}
--- /dev/null
+/*
+ * 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
--- /dev/null
+/*
+ * @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 );
+}
+
--- /dev/null
+/*
+ * 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
--- /dev/null
+/*
+ * 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_ */
--- /dev/null
+/*
+ * 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_ */
--- /dev/null
+/* $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_ */
+
--- /dev/null
+/* $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_ */
--- /dev/null
+# @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
--- /dev/null
+/*
+ * @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;
+}
projects / platform / upstream / libva.git / commitdiff