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