KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote branch 'vdpau/pipe-video' into pipe-video 

Conflicts:
	src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.c
	src/gallium/drivers/softpipe/sp_video_context.c
	src/gallium/include/pipe/p_format.h
	src/gallium/state_trackers/xorg/xvmc/context.c
	src/gallium/tests/unit/SConscript
This commit is contained in:
Christian König 2011-01-10 23:41:08 +01:00
parent b725bbebae 2b296ec77c
commit 9032d2a13e
99 changed files with 3350 additions and 4079 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
configs/autoconf.in
View File

@ -157,6 +157,12 @@ DRI_DRIVER_SEARCH_DIR = @DRI_DRIVER_SEARCH_DIR@
# EGL driver install directory
EGL_DRIVER_INSTALL_DIR = @EGL_DRIVER_INSTALL_DIR@
# VDPAU library install directory
VDPAU_LIB_INSTALL_DIR=@VDPAU_LIB_INSTALL_DIR@
# VA library install directory
VA_LIB_INSTALL_DIR=@VA_LIB_INSTALL_DIR@
# Xorg driver install directory (for xorg state-tracker)
XORG_DRIVER_INSTALL_DIR = @XORG_DRIVER_INSTALL_DIR@

10
configs/linux-dri
View File

@ -57,12 +57,12 @@ SRC_DIRS := glx egl $(SRC_DIRS)
EGL_DRIVERS_DIRS = glx
DRIVER_DIRS = dri
GALLIUM_WINSYS_DIRS = sw sw/xlib drm/vmware drm/intel drm/i965
GALLIUM_TARGET_DIRS =
GALLIUM_STATE_TRACKERS_DIRS = egl
DRI_DIRS = i810 i915 i965 mach64 mga r128 r200 r300 radeon \
savage sis tdfx unichrome swrast
GALLIUM_WINSYS_DIRS = sw sw/xlib drm/vmware drm/intel drm/i965
GALLIUM_TARGET_DIRS = egl-swrast
GALLIUM_STATE_TRACKERS_DIRS = egl vdpau
DRI_DIRS = r300 radeon swrast
INTEL_LIBS = `pkg-config --libs libdrm_intel`
INTEL_CFLAGS = `pkg-config --cflags libdrm_intel`

2
configs/linux-dri-x86-64
View File

@ -20,5 +20,5 @@ EXTRA_LIB_PATH=-L/usr/X11R6/lib64
# the new interface. i810 are missing because there is no x86-64
# system where they could *ever* be used.
#
DRI_DIRS = i915 i965 mach64 mga r128 r200 r300 radeon savage tdfx unichrome
DRI_DIRS = swrast

55
configure.ac
View File

@ -1426,13 +1426,27 @@ yes)
AC_MSG_ERROR([cannot build vega state tracker without --enable-openvg])
fi
;;
xorg/xvmc)
# Check for libXvMC?
xorg/xvmc)
# Check for xvmc?
if test "x$enable_gallium_g3dvl" != xyes; then
AC_MSG_ERROR([cannot build XvMC state tracker without --enable-gallium-g3dvl])
fi
HAVE_ST_XVMC="yes"
;;
vdpau)
# Check for libvdpau?
if test "x$enable_gallium_g3dvl" != xyes; then
AC_MSG_ERROR([cannot build vdpau state tracker without --enable-gallium-g3dvl])
fi
HAVE_ST_VDPAU="yes"
;;
va)
# Check for libva?
if test "x$enable_gallium_g3dvl" != xyes; then
AC_MSG_ERROR([cannot build va state tracker without --enable-gallium-g3dvl])
fi
HAVE_ST_VA="yes"
;;
esac
if test -n "$tracker"; then
@ -1580,7 +1594,7 @@ dnl
dnl Gallium helper functions
dnl
gallium_check_st() {
if test "x$HAVE_ST_DRI" = xyes || test "x$HAVE_ST_XORG" = xyes || test "x$HAVE_ST_XVMC" = xyes; then
if test "x$HAVE_ST_DRI" = xyes || test "x$HAVE_ST_XORG" = xyes || test "x$HAVE_ST_XVMC" = xyes || test "x$HAVE_ST_VDPAU" = xyes || test "x$HAVE_ST_VA" = xyes; then
GALLIUM_WINSYS_DIRS="$GALLIUM_WINSYS_DIRS $1"
fi
if test "x$HAVE_ST_DRI" = xyes && test "x$2" != x; then
@ -1589,9 +1603,15 @@ gallium_check_st() {
if test "x$HAVE_ST_XORG" = xyes && test "x$3" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $3"
fi
if test "x$HAVE_ST_XVMC" = xyes && test "x$5" != x; then
if test "x$HAVE_ST_XVMC" = xyes && test "x$4" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $4"
fi
if test "x$HAVE_ST_VDPAU" = xyes && test "x$5" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $5"
fi
if test "x$HAVE_ST_VA" = xyes && test "x$6" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $6"
fi
}
@ -1678,7 +1698,7 @@ AC_ARG_ENABLE([gallium-r600],
if test "x$enable_gallium_r600" = xyes; then
if test "x$HAVE_LIBDRM_RADEON" = xyes; then
GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS r600"
gallium_check_st "r600/drm" "dri-r600" "xvmc-r600"
gallium_check_st "r600/drm" "dri-r600" "xvmc-r600" "va-r600"
else
AC_MSG_ERROR([libdrm_radeon is missing, cannot build gallium-r600])
fi
@ -1708,13 +1728,36 @@ AC_ARG_ENABLE([gallium-g3dvl],
if test "x$enable_gallium_g3dvl" = xyes; then
case "$mesa_driver" in
xlib)
if test "x$HAVE_ST_VDPAU" = xyes; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS vdpau-softpipe"
fi
if test "x$HAVE_ST_XVMC" = xyes; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS xvmc-softpipe"
;;
fi
if test "x$HAVE_ST_VA" = xyes; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS va-softpipe"
fi
;;
dri)
GALLIUM_WINSYS_DIRS="$GALLIUM_WINSYS_DIRS g3dvl/dri"
;;
esac
fi
dnl Directory for VDPAU libs
AC_ARG_WITH([vdpau-libdir],
[AS_HELP_STRING([--with-vdpau-libdir=DIR],
[directory for the VDPAU libraries @<:@default=${libdir}/vdpau@:>@])],
[VDPAU_LIB_INSTALL_DIR="$withval"],
[VDPAU_LIB_INSTALL_DIR='${libdir}/vdpau'])
AC_SUBST([VDPAU_LIB_INSTALL_DIR])
dnl Directory for VA libs
AC_ARG_WITH([va-libdir],
[AS_HELP_STRING([--with-va-libdir=DIR],
[directory for the VA libraries @<:@default=${libdir}/va@:>@])],
[VA_LIB_INSTALL_DIR="$withval"],
[VA_LIB_INSTALL_DIR='${libdir}/va'])
AC_SUBST([VA_LIB_INSTALL_DIR])
dnl
dnl Gallium swrast configuration

47
src/gallium/auxiliary/vl/vl_bitstream_parser.c
View File

@ -29,17 +29,58 @@
#include <assert.h>
#include <limits.h>
#include <util/u_memory.h>
#include <stdio.h>
inline void endian_swap_ushort(unsigned short *x)
{
x[0] = (x[0]>>8) |
(x[0]<<8);
}
inline void endian_swap_uint(unsigned int *x)
{
x[0] = (x[0]>>24) |
((x[0]<<8) & 0x00FF0000) |
((x[0]>>8) & 0x0000FF00) |
(x[0]<<24);
}
inline void endian_swap_ulonglong(unsigned long long *x)
{
x[0] = (x[0]>>56) |
((x[0]<<40) & 0x00FF000000000000) |
((x[0]<<24) & 0x0000FF0000000000) |
((x[0]<<8) & 0x000000FF00000000) |
((x[0]>>8) & 0x00000000FF000000) |
((x[0]>>24) & 0x0000000000FF0000) |
((x[0]>>40) & 0x000000000000FF00) |
(x[0]<<56);
}
static unsigned
grab_bits(unsigned cursor, unsigned how_many_bits, unsigned bitstream_elt)
{
unsigned excess_bits = sizeof(unsigned) * CHAR_BIT - how_many_bits - cursor;
unsigned excess_bits = sizeof(unsigned) * CHAR_BIT - how_many_bits;
assert(cursor < sizeof(unsigned) * CHAR_BIT);
assert(how_many_bits > 0 && how_many_bits <= sizeof(unsigned) * CHAR_BIT);
assert(cursor + how_many_bits <= sizeof(unsigned) * CHAR_BIT);
return (bitstream_elt << excess_bits) >> (excess_bits + cursor);
#ifndef PIPE_ARCH_BIG_ENDIAN
switch (sizeof(unsigned)) {
case 2:
endian_swap_ushort(&bitstream_elt);
break;
case 4:
endian_swap_uint(&bitstream_elt);
break;
case 8:
endian_swap_ulonglong(&bitstream_elt);
break;
}
#endif // !PIPE_ARCH_BIG_ENDIAN
return (bitstream_elt << cursor) >> (excess_bits);
}
static unsigned

4
src/gallium/auxiliary/vl/vl_bitstream_parser.h
View File

@ -39,6 +39,10 @@ struct vl_bitstream_parser
unsigned cursor;
};
inline void endian_swap_ushort(unsigned short *x);
inline void endian_swap_uint(unsigned int *x);
inline void endian_swap_ulonglong(unsigned long long *x);
bool vl_bitstream_parser_init(struct vl_bitstream_parser *parser,
unsigned num_bitstreams,
const void **bitstreams,

6
src/gallium/auxiliary/vl/vl_compositor.c
View File

@ -32,6 +32,7 @@
#include <util/u_inlines.h>
#include <util/u_memory.h>
#include <util/u_keymap.h>
#include <util/u_draw.h>
#include <util/u_sampler.h>
#include <tgsi/tgsi_ureg.h>
#include "vl_csc.h"
@ -557,6 +558,7 @@ static void draw_layers(struct vl_compositor *c,
c->pipe->bind_fs_state(c->pipe, frag_shaders[i]);
c->pipe->set_fragment_sampler_views(c->pipe, 1, &surface_view);
util_draw_arrays(c->pipe, PIPE_PRIM_TRIANGLES, i * 6, 6);
if (delete_view) {
@ -629,8 +631,8 @@ void vl_compositor_set_csc_matrix(struct vl_compositor *compositor, const float
pipe_buffer_map(compositor->pipe, compositor->fs_const_buf,
PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD,
&buf_transfer),
mat,
sizeof(struct fragment_shader_consts)
mat,
sizeof(struct fragment_shader_consts)
);
pipe_buffer_unmap(compositor->pipe, buf_transfer);

2
src/gallium/auxiliary/vl/vl_mpeg12_mc_renderer.c
View File

@ -35,6 +35,7 @@
#include <util/u_memory.h>
#include <util/u_keymap.h>
#include <util/u_sampler.h>
#include <util/u_draw.h>
#include <tgsi/tgsi_ureg.h>
#define DEFAULT_BUF_ALIGNMENT 1
@ -636,7 +637,6 @@ get_motion_vectors(struct pipe_mpeg12_macroblock *mb, struct vertex2s mv[4])
case PIPE_MPEG12_MACROBLOCK_TYPE_BI:
{
if (mb->mo_type == PIPE_MPEG12_MOTION_TYPE_FRAME) {
mv[2].x = mb->pmv[0][1][0];
mv[2].y = mb->pmv[0][1][1];

17
src/gallium/drivers/softpipe/sp_video_context.c
View File

@ -179,6 +179,7 @@ sp_mpeg12_is_format_supported(struct pipe_video_context *vpipe,
if (geom & PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO)
return FALSE;
return ctx->pipe->screen->is_format_supported(ctx->pipe->screen, format, PIPE_TEXTURE_2D,
0, usage, geom);
}
@ -209,11 +210,10 @@ sp_mpeg12_decode_macroblocks(struct pipe_video_context *vpipe,
}
static void
sp_mpeg12_surface_fill(struct pipe_video_context *vpipe,
sp_mpeg12_clear_render_target(struct pipe_video_context *vpipe,
struct pipe_surface *dst,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height,
unsigned value)
unsigned width, unsigned height)
{
struct sp_mpeg12_context *ctx = (struct sp_mpeg12_context*)vpipe;
float rgba[4] = { 0, 0, 0, 0 };
@ -228,7 +228,7 @@ sp_mpeg12_surface_fill(struct pipe_video_context *vpipe,
}
static void
sp_mpeg12_surface_copy(struct pipe_video_context *vpipe,
sp_mpeg12_resource_copy_region(struct pipe_video_context *vpipe,
struct pipe_surface *dst,
unsigned dstx, unsigned dsty,
struct pipe_surface *src,
@ -462,14 +462,16 @@ init_pipe_state(struct sp_mpeg12_context *ctx)
rast.line_width = 1;
rast.point_smooth = 0;
rast.point_quad_rasterization = 0;
rast.point_size = 1;
rast.point_size_per_vertex = 1;
rast.offset_units = 1;
rast.offset_scale = 1;
rast.gl_rasterization_rules = 1;
ctx->rast = ctx->pipe->create_rasterizer_state(ctx->pipe, &rast);
ctx->pipe->bind_rasterizer_state(ctx->pipe, ctx->rast);
memset(&blend, 0, sizeof blend);
blend.independent_blend_enable = 0;
blend.rt[0].blend_enable = 0;
blend.rt[0].rgb_func = PIPE_BLEND_ADD;
@ -538,14 +540,15 @@ sp_mpeg12_create(struct pipe_context *pipe, enum pipe_video_profile profile,
ctx->base.height = height;
ctx->base.screen = pipe->screen;
ctx->base.destroy = sp_mpeg12_destroy;
ctx->base.get_param = sp_mpeg12_get_param;
ctx->base.is_format_supported = sp_mpeg12_is_format_supported;
ctx->base.create_surface = sp_mpeg12_create_surface;
ctx->base.decode_macroblocks = sp_mpeg12_decode_macroblocks;
ctx->base.render_picture = sp_mpeg12_render_picture;
ctx->base.surface_fill = sp_mpeg12_surface_fill;
ctx->base.surface_copy = sp_mpeg12_surface_copy;
ctx->base.clear_render_target = sp_mpeg12_clear_render_target;
ctx->base.resource_copy_region = sp_mpeg12_resource_copy_region;
ctx->base.get_transfer = sp_mpeg12_get_transfer;
ctx->base.transfer_destroy = sp_mpeg12_transfer_destroy;
ctx->base.transfer_map = sp_mpeg12_transfer_map;

3
src/gallium/include/pipe/p_defines.h
View File

@ -506,6 +506,7 @@ enum pipe_video_codec
enum pipe_video_profile
{
PIPE_VIDEO_PROFILE_UNKNOWN,
PIPE_VIDEO_PROFILE_MPEG1,
PIPE_VIDEO_PROFILE_MPEG2_SIMPLE,
PIPE_VIDEO_PROFILE_MPEG2_MAIN,
@ -519,6 +520,7 @@ enum pipe_video_profile
PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH
};
/**
* Composite query types
*/
@ -533,6 +535,7 @@ struct pipe_query_data_timestamp_disjoint
boolean disjoint;
};
#ifdef __cplusplus
}
#endif

4
src/gallium/include/pipe/p_screen.h
View File

@ -92,14 +92,14 @@ struct pipe_screen {
*/
int (*get_shader_param)( struct pipe_screen *, unsigned shader, enum pipe_shader_cap param );
struct pipe_context * (*context_create)( struct pipe_screen *,
void *priv );
struct pipe_context * (*context_create)( struct pipe_screen *, void *priv );
struct pipe_video_context * (*video_context_create)( struct pipe_screen *screen,
enum pipe_video_profile profile,
enum pipe_video_chroma_format chroma_format,
unsigned width, unsigned height, void *priv );
/**
* Check if the given pipe_format is supported as a texture or
* drawing surface.

18
src/gallium/include/pipe/p_video_context.h
View File

@ -105,17 +105,19 @@ struct pipe_video_context
struct pipe_video_rect *dst_area,
struct pipe_fence_handle **fence);
void (*surface_fill)(struct pipe_video_context *vpipe,
void (*clear_render_target)(struct pipe_video_context *vpipe,
struct pipe_surface *dst,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height,
unsigned value);
const float *rgba,
unsigned width, unsigned height);
void (*surface_copy)(struct pipe_video_context *vpipe,
struct pipe_surface *dst,
unsigned dstx, unsigned dsty,
struct pipe_surface *src,
unsigned srcx, unsigned srcy,
void (*resource_copy_region)(struct pipe_video_context *vpipe,
struct pipe_resource *dst,
struct pipe_subresource subdst,
unsigned dstx, unsigned dsty, unsigned dstz,
struct pipe_resource *src,
struct pipe_subresource subsrc,
unsigned srcx, unsigned srcy, unsigned srcz,
unsigned width, unsigned height);
struct pipe_transfer *(*get_transfer)(struct pipe_video_context *vpipe,

1
src/gallium/include/pipe/p_video_state.h
View File

@ -74,6 +74,7 @@ enum pipe_mpeg12_dct_type
PIPE_MPEG12_DCT_TYPE_FRAME
};
struct pipe_macroblock
{
enum pipe_video_codec codec;

28
src/gallium/state_trackers/va/Makefile Normal file
View File

@ -0,0 +1,28 @@
TOP = ../../../..
include $(TOP)/configs/current
LIBNAME = vatracker
VA_MAJOR = 0
VA_MINOR = 3
LIBRARY_DEFINES = -DVER_MAJOR=$(VA_MAJOR) -DVER_MINOR=$(VA_MINOR) $(STATE_TRACKER_DEFINES)
LIBRARY_INCLUDES = \
$(shell pkg-config --cflags-only-I va) \
-I$(TOP)/src/gallium/winsys/g3dvl
C_SOURCES = htab.c \
ftab.c \
va_context.c \
va_image.c \
va_subpicture.c \
va_buffer.c \
va_config.c \
va_picture.c \
va_surface.c \
va_display.c
include ../../Makefile.template

136
src/gallium/state_trackers/va/ftab.c Normal file
View File

@ -0,0 +1,136 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <assert.h>
#include <va/va.h>
#include <va/va_backend.h>
#include "va_private.h"
struct VADriverVTable vlVaGetVtable();
static struct VADriverVTable vtable =
{
&vlVaTerminate, /* VAStatus (*vaTerminate) ( VADriverContextP ctx ); */
&vlVaQueryConfigProfiles, /* VAStatus (*vaQueryConfigProfiles) ( VADriverContextP ctx, VAProfile *profile_list,int *num_profiles); */
&vlVaQueryConfigEntrypoints, /* VAStatus (*vaQueryConfigEntrypoints) ( VADriverContextP ctx, VAProfile profile, VAEntrypoint *entrypoint_list, int *num_entrypoints ); */
&vlVaGetConfigAttributes, /* VAStatus (*vaGetConfigAttributes) ( VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint, VAConfigAttrib *attrib_list, int num_attribs ); */
&vlVaCreateConfig, /* VAStatus (*vaCreateConfig) ( VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint, VAConfigAttrib *attrib_list, int num_attribs, VAConfigID *config_id); */
&vlVaDestroyConfig, /* VAStatus (*vaDestroyConfig) ( VADriverContextP ctx, VAConfigID config_id); */
&vlVaQueryConfigAttributes, /* VAStatus (*vaQueryConfigAttributes) ( VADriverContextP ctx, VAConfigID config_id, VAProfile *profile, VAEntrypoint *entrypoint, VAConfigAttrib *attrib_list, int *num_attribs); */
&vlVaCreateSurfaces, /* VAStatus (*vaCreateSurfaces) ( VADriverContextP ctx,int width,int height,int format,int num_surfaces,VASurfaceID *surfaces); */
&vlVaDestroySurfaces, /* VAStatus (*vaDestroySurfaces) ( VADriverContextP ctx, VASurfaceID *surface_list, int num_surfaces ); */
&vlVaCreateContext, /* VAStatus (*vaCreateContext) (VADriverContextP ctx,VAConfigID config_id,int picture_width,int picture_height,int flag,VASurfaceID *render_targets,int num_render_targets,VAContextID *context); */
&vlVaDestroyContext, /* VAStatus (*vaDestroyContext) (VADriverContextP ctx,VAContextID context); */
&vlVaCreateBuffer, /* VAStatus (*vaCreateBuffer) (VADriverContextP ctx,VAContextID context,VABufferType type,unsigned int size,unsigned int num_elements,void *data,VABufferID *buf_id); */
&vlVaBufferSetNumElements, /* VAStatus (*vaBufferSetNumElements) (VADriverContextP ctx,VABufferID buf_id,unsigned int num_elements); */
&vlVaMapBuffer, /* VAStatus (*vaMapBuffer) (VADriverContextP ctx,VABufferID buf_id,void **pbuf); */
&vlVaUnmapBuffer, /* VAStatus (*vaUnmapBuffer) (VADriverContextP ctx,VABufferID buf_id); */
&vlVaDestroyBuffer, /* VAStatus (*vaDestroyBuffer) (VADriverContextP ctx,VABufferID buffer_id); */
&vlVaBeginPicture, /* VAStatus (*vaBeginPicture) (VADriverContextP ctx,VAContextID context,VASurfaceID render_target); */
&vlVaRenderPicture, /* VAStatus (*vaRenderPicture) (VADriverContextP ctx,VAContextID context,VABufferID *buffers,int num_buffers); */
&vlVaEndPicture, /* VAStatus (*vaEndPicture) (VADriverContextP ctx,VAContextID context); */
&vlVaSyncSurface, /* VAStatus (*vaSyncSurface) (VADriverContextP ctx,VASurfaceID render_target); */
&vlVaQuerySurfaceStatus, /* VAStatus (*vaQuerySurfaceStatus) (VADriverContextP ctx,VASurfaceID render_target,VASurfaceStatus *status); */
&vlVaPutSurface, /* VAStatus (*vaPutSurface) (
VADriverContextP ctx,
VASurfaceID surface,
void* draw,
short srcx,
short srcy,
unsigned short srcw,
unsigned short srch,
short destx,
short desty,
unsigned short destw,
unsigned short desth,
VARectangle *cliprects,
unsigned int number_cliprects,
unsigned int flags); */
&vlVaQueryImageFormats, /* VAStatus (*vaQueryImageFormats) ( VADriverContextP ctx, VAImageFormat *format_list,int *num_formats); */
&vlVaCreateImage, /* VAStatus (*vaCreateImage) (VADriverContextP ctx,VAImageFormat *format,int width,int height,VAImage *image); */
&vlVaDeriveImage, /* VAStatus (*vaDeriveImage) (VADriverContextP ctx,VASurfaceID surface,VAImage *image); */
&vlVaDestroyImage, /* VAStatus (*vaDestroyImage) (VADriverContextP ctx,VAImageID image); */
&vlVaSetImagePalette, /* VAStatus (*vaSetImagePalette) (VADriverContextP ctx,VAImageID image, unsigned char *palette); */
&vlVaGetImage, /* VAStatus (*vaGetImage) (VADriverContextP ctx,VASurfaceID surface,int x,int y,unsigned int width,unsigned int height,VAImageID image); */
&vlVaPutImage, /* VAStatus (*vaPutImage) (
VADriverContextP ctx,
VASurfaceID surface,
VAImageID image,
int src_x,
int src_y,
unsigned int src_width,
unsigned int src_height,
int dest_x,
int dest_y,
unsigned int dest_width,
unsigned int dest_height
); */
&vlVaQuerySubpictureFormats, /* VAStatus (*vaQuerySubpictureFormats) (VADriverContextP ctx,VAImageFormat *format_list,unsigned int *flags,unsigned int *num_formats); */
&vlVaCreateSubpicture, /* VAStatus (*vaCreateSubpicture) (VADriverContextP ctx,VAImageID image,VASubpictureID *subpicture); */
&vlVaDestroySubpicture, /* VAStatus (*vaDestroySubpicture) (VADriverContextP ctx,VASubpictureID subpicture); */
&vlVaSubpictureImage, /* VAStatus (*vaSetSubpictureImage) (VADriverContextP ctx,VASubpictureID subpicture,VAImageID image); */
&vlVaSetSubpictureChromakey, /* VAStatus (*vaSetSubpictureChromakey) (VADriverContextP ctx,VASubpictureID subpicture,unsigned int chromakey_min,unsigned int chromakey_max,unsigned int chromakey_mask); */
&vlVaSetSubpictureGlobalAlpha, /* VAStatus (*vaSetSubpictureGlobalAlpha) (VADriverContextP ctx,VASubpictureID subpicture,float global_alpha); */
&vlVaAssociateSubpicture, /* VAStatus (*vaAssociateSubpicture) (
VADriverContextP ctx,
VASubpictureID subpicture,
VASurfaceID *target_surfaces,
int num_surfaces,
short src_x,
short src_y,
unsigned short src_width,
unsigned short src_height,
short dest_x,
short dest_y,
unsigned short dest_width,
unsigned short dest_height,
unsigned int flags); */
&vlVaDeassociateSubpicture, /* VAStatus (*vaDeassociateSubpicture) (VADriverContextP ctx,VASubpictureID subpicture,VASurfaceID *target_surfaces,int num_surfaces); */
&vlVaQueryDisplayAttributes, /* VAStatus (*vaQueryDisplayAttributes) (VADriverContextP ctx,VADisplayAttribute *attr_list,int *num_attributes); */
&vlVaGetDisplayAttributes, /* VAStatus (*vaGetDisplayAttributes) (VADriverContextP ctx,VADisplayAttribute *attr_list,int num_attributes); */
&vlVaSetDisplayAttributes, /* VAStatus (*vaSetDisplayAttributes) (VADriverContextP ctx,VADisplayAttribute *attr_list,int num_attributes); */
&vlVaBufferInfo, /* VAStatus (*vaBufferInfo) (VADriverContextP ctx,VAContextID context,VABufferID buf_id,VABufferType *type,unsigned int *size,unsigned int *num_elements); */
&vlVaLockSurface, /* VAStatus (*vaLockSurface) (
VADriverContextP ctx,
VASurfaceID surface,
unsigned int *fourcc,
unsigned int *luma_stride,
unsigned int *chroma_u_stride,
unsigned int *chroma_v_stride,
unsigned int *luma_offset,
unsigned int *chroma_u_offset,
unsigned int *chroma_v_offset,
unsigned int *buffer_name,
void **buffer); */
&vlVaUnlockSurface, /* VAStatus (*vaUnlockSurface) (VADriverContextP ctx,VASurfaceID surface); */
NULL /* struct VADriverVTableGLX *glx; "Optional" */
};
struct VADriverVTable vlVaGetVtable()
{
return vtable;
}

99
src/gallium/state_trackers/va/htab.c Normal file
View File

@ -0,0 +1,99 @@
/**************************************************************************
*
* Copyright 2010 Younes Manton.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <util/u_handle_table.h>
#include <os/os_thread.h>
#include "va_private.h"
boolean vlCreateHTAB(void);
void vlDestroyHTAB(void);
vlHandle vlAddDataHTAB(void *data);
void* vlGetDataHTAB(vlHandle handle);
#ifdef VL_HANDLES
static struct handle_table *htab = NULL;
pipe_static_mutex(htab_lock);
#endif
boolean vlCreateHTAB(void)
{
#ifdef VL_HANDLES
boolean ret;
/* Make sure handle table handles match VDPAU handles. */
assert(sizeof(unsigned) <= sizeof(vlHandle));
pipe_mutex_lock(htab_lock);
if (!htab)
htab = handle_table_create();
ret = htab != NULL;
pipe_mutex_unlock(htab_lock);
return ret;
#else
return TRUE;
#endif
}
void vlDestroyHTAB(void)
{
#ifdef VL_HANDLES
pipe_mutex_lock(htab_lock);
if (htab) {
handle_table_destroy(htab);
htab = NULL;
}
pipe_mutex_unlock(htab_lock);
#endif
}
vlHandle vlAddDataHTAB(void *data)
{
assert(data);
#ifdef VL_HANDLES
vlHandle handle = 0;
pipe_mutex_lock(htab_lock);
if (htab)
handle = handle_table_add(htab, data);
pipe_mutex_unlock(htab_lock);
return handle;
#else
return (vlHandle)data;
#endif
}
void* vlGetDataHTAB(vlHandle handle)
{
assert(handle);
#ifdef VL_HANDLES
void *data = NULL;
pipe_mutex_lock(htab_lock);
if (htab)
data = handle_table_get(htab, handle);
pipe_mutex_unlock(htab_lock);
return data;
#else
return (void*)handle;
#endif
}

96
src/gallium/state_trackers/va/va_buffer.c Normal file
View File

@ -0,0 +1,96 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <va/va.h>
#include <va/va_backend.h>
#include "va_private.h"
VAStatus vlVaCreateBuffer( VADriverContextP ctx,
VAContextID context,
VABufferType type,
unsigned int size,
unsigned int num_elements,
void *data,
VABufferID *buf_id)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaBufferSetNumElements( VADriverContextP ctx,
VABufferID buf_id,
unsigned int num_elements)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaMapBuffer( VADriverContextP ctx,
VABufferID buf_id,
void **pbuff)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaUnmapBuffer( VADriverContextP ctx,
VABufferID buf_id)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaDestroyBuffer( VADriverContextP ctx,
VABufferID buffer_id)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaBufferInfo( VADriverContextP ctx,
VAContextID context,
VABufferID buf_id,
VABufferType *type,
unsigned int *size,
unsigned int *num_elements)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}

131
src/gallium/state_trackers/va/va_config.c Normal file
View File

@ -0,0 +1,131 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <va/va.h>
#include <va/va_backend.h>
#include <util/u_debug.h>
#include "va_private.h"
VAStatus vlVaQueryConfigProfiles( VADriverContextP ctx,
VAProfile *profile_list,
int *num_profiles)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
int i = 0;
profile_list[i++] = VAProfileMPEG2Simple;
*num_profiles = i;
return VA_STATUS_SUCCESS;
}
VAStatus vlVaQueryConfigEntrypoints( VADriverContextP ctx,
VAProfile profile,
VAEntrypoint *entrypoint_list,
int *num_entrypoints)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
VAStatus vaStatus = VA_STATUS_SUCCESS;
switch (profile) {
case VAProfileMPEG2Simple:
case VAProfileMPEG2Main:
VA_INFO("Using profile %08x\n",profile);
*num_entrypoints = 1;
entrypoint_list[0] = VAEntrypointMoComp;
break;
case VAProfileH264Baseline:
case VAProfileH264Main:
case VAProfileH264High:
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
*num_entrypoints = 0;
break;
default:
VA_ERROR("Unsupported profile %08x\n",profile);
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
*num_entrypoints = 0;
break;
}
return vaStatus;
}
VAStatus vlVaGetConfigAttributes( VADriverContextP ctx,
VAProfile profile,
VAEntrypoint entrypoint,
VAConfigAttrib *attrib_list,
int num_attribs)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaCreateConfig( VADriverContextP ctx,
VAProfile profile,
VAEntrypoint entrypoint,
VAConfigAttrib *attrib_list,
int num_attribs,
VAConfigID *config_id)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaDestroyConfig( VADriverContextP ctx,
VAConfigID config_id)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaQueryConfigAttributes( VADriverContextP ctx,
VAConfigID config_id,
VAProfile *profile,
VAEntrypoint *entrypoint,
VAConfigAttrib *attrib_list,
int *num_attribs)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}

107
src/gallium/state_trackers/va/va_context.c Normal file
View File

@ -0,0 +1,107 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <pipe/p_compiler.h>
#include <pipe/p_video_context.h>
#include <pipe/p_screen.h>
#include <vl_winsys.h>
#include <util/u_debug.h>
#include <util/u_memory.h>
#include <va/va.h>
#include <va/va_backend.h>
#include "va_private.h"
//struct VADriverVTable vlVaGetVtable();
PUBLIC
VAStatus __vaDriverInit_0_31 (VADriverContextP ctx)
{
vlVaDriverContextPriv *driver_context = NULL;
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
/* Create private driver context */
driver_context = CALLOC(1,sizeof(vlVaDriverContextPriv));
if (!driver_context)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
driver_context->vscreen = vl_screen_create(ctx->native_dpy, ctx->x11_screen);
if (!driver_context->vscreen)
{
FREE(driver_context);
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
ctx->str_vendor = "mesa gallium vaapi";
ctx->vtable = vlVaGetVtable();
ctx->max_attributes = 1;
ctx->max_display_attributes = 1;
ctx->max_entrypoints = VA_MAX_ENTRYPOINTS;
ctx->max_image_formats = VA_MAX_IMAGE_FORMATS_SUPPORTED;
ctx->max_profiles = 1;
ctx->max_subpic_formats = VA_MAX_SUBPIC_FORMATS_SUPPORTED;
ctx->version_major = 3;
ctx->version_minor = 1;
ctx->pDriverData = (void *)driver_context;
VA_INFO("vl_screen_pointer %p\n",ctx->native_dpy);
return VA_STATUS_SUCCESS;
}
VAStatus vlVaCreateContext( VADriverContextP ctx,
VAConfigID config_id,
int picture_width,
int picture_height,
int flag,
VASurfaceID *render_targets,
int num_render_targets,
VAContextID *conext)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaDestroyContext( VADriverContextP ctx,
VAContextID context)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaTerminate( VADriverContextP ctx)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}

90
src/gallium/tests/unit/pipe_barrier_test.c → src/gallium/state_trackers/va/va_display.c
View File

@ -1,6 +1,6 @@
/**************************************************************************
*
* Copyright 2009-2010 VMware, Inc.
* Copyright 2010 Thomas Balling Sørensen.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
@ -18,69 +18,53 @@
* 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 VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* IN NO EVENT SHALL TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/*
* Test case for pipe_barrier.
*
* The test succeeds if no thread exits before all the other threads reach
* the barrier.
*/
#include <va/va.h>
#include <va/va_backend.h>
#include "va_private.h"
#include <stdio.h>
#include "os/os_thread.h"
#include "os/os_time.h"
#define NUM_THREADS 10
static pipe_thread threads[NUM_THREADS];
static pipe_barrier barrier;
static int thread_ids[NUM_THREADS];
static PIPE_THREAD_ROUTINE(thread_function, thread_data)
VAStatus vlVaQueryDisplayAttributes( VADriverContextP ctx,
VADisplayAttribute *attr_list,
int *num_attributes)
{
int thread_id = *((int *) thread_data);
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
printf("thread %d starting\n", thread_id);
os_time_sleep(thread_id * 1000 * 1000);
printf("thread %d before barrier\n", thread_id);
pipe_barrier_wait(&barrier);
printf("thread %d exiting\n", thread_id);
if (!(attr_list && num_attributes))
return VA_STATUS_ERROR_UNKNOWN;
return NULL;
*num_attributes = 0;
return VA_STATUS_SUCCESS;
}
VAStatus vlVaGetDisplayAttributes( VADriverContextP ctx,
VADisplayAttribute *attr_list,
int num_attributes)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaSetDisplayAttributes( VADriverContextP ctx,
VADisplayAttribute *attr_list,
int num_attributes)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
int main()
{
int i;
printf("pipe_barrier_test starting\n");
pipe_barrier_init(&barrier, NUM_THREADS);
for (i = 0; i < NUM_THREADS; i++) {
thread_ids[i] = i;
threads[i] = pipe_thread_create(thread_function, (void *) &thread_ids[i]);
}
for (i = 0; i < NUM_THREADS; i++ ) {
pipe_thread_wait(threads[i]);
}
pipe_barrier_destroy(&barrier);
printf("pipe_barrier_test exiting\n");
return 0;
}

178
src/gallium/state_trackers/va/va_image.c Normal file
View File

@ -0,0 +1,178 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <util/u_memory.h>
#include <util/u_format.h>
#include <util/u_debug.h>
#include <pipe/p_format.h>
#include <va/va.h>
#include <va/va_backend.h>
#include "va_private.h"
typedef struct {
enum pipe_format pipe_format;
VAImageFormat va_format;
} va_image_formats_supported_t;
static const va_image_formats_supported_t va_image_formats_supported[VA_MAX_IMAGE_FORMATS_SUPPORTED] =
{
{ PIPE_FORMAT_B8G8R8A8_UNORM,
{ VA_FOURCC('B','G','R','A'), VA_LSB_FIRST, 32, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 }},
{ PIPE_FORMAT_R8G8B8A8_UNORM,
{ VA_FOURCC_RGBA, VA_LSB_FIRST, 32, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 }}
};
boolean vlCreateHTAB(void);
void vlDestroyHTAB(void);
vlHandle vlAddDataHTAB(void *data);
void* vlGetDataHTAB(vlHandle handle);
VAStatus
vlVaQueryImageFormats ( VADriverContextP ctx,
VAImageFormat *format_list,
int *num_formats)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
if (!(format_list && num_formats))
return VA_STATUS_ERROR_UNKNOWN;
int n = 0;
num_formats[0] = VA_MAX_IMAGE_FORMATS_SUPPORTED;
/* Query supported formats */
for (n = 0; n < VA_MAX_IMAGE_FORMATS_SUPPORTED; n++)
{
format_list[n] = va_image_formats_supported[n].va_format;
}
return VA_STATUS_SUCCESS;
}
VAStatus vlVaCreateImage( VADriverContextP ctx,
VAImageFormat *format,
int width,
int height,
VAImage *image)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
if(!format)
return VA_STATUS_ERROR_UNKNOWN;
if (!(width && height))
return VA_STATUS_ERROR_INVALID_IMAGE_FORMAT;
if (!vlCreateHTAB())
return VA_STATUS_ERROR_UNKNOWN;
switch (format->fourcc) {
case VA_FOURCC('B','G','R','A'):
VA_INFO("Creating BGRA image of size %dx%d\n",width,height);
break;
case VA_FOURCC_RGBA:
VA_INFO("Creating RGBA image of size %dx%d\n",width,height);
break;
default:
VA_ERROR("Couldn't create image of type %0x08\n",format->fourcc);
return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
break;
}
VA_INFO("Image %p created successfully\n",format);
return VA_STATUS_SUCCESS;
}
VAStatus vlVaDeriveImage( VADriverContextP ctx,
VASurfaceID surface,
VAImage *image)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaDestroyImage( VADriverContextP ctx,
VAImageID image)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaSetImagePalette( VADriverContextP ctx,
VAImageID image,
unsigned char *palette)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaGetImage( VADriverContextP ctx,
VASurfaceID surface,
int x,
int y,
unsigned int width,
unsigned int height,
VAImageID image)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaPutImage( VADriverContextP ctx,
VASurfaceID surface,
VAImageID image,
int src_x,
int src_y,
unsigned int src_width,
unsigned int src_height,
int dest_x,
int dest_y,
unsigned int dest_width,
unsigned int dest_height)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}

61
src/gallium/state_trackers/va/va_picture.c Normal file
View File

@ -0,0 +1,61 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <va/va.h>
#include <va/va_backend.h>
#include <util/u_debug.h>
#include "va_private.h"
VAStatus vlVaBeginPicture( VADriverContextP ctx,
VAContextID context,
VASurfaceID render_target)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaRenderPicture( VADriverContextP ctx,
VAContextID context,
VABufferID *buffers,
int num_buffers)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaEndPicture( VADriverContextP ctx,
VAContextID context)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}

159
src/gallium/state_trackers/va/va_private.h Normal file
View File

@ -0,0 +1,159 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#ifndef VA_PRIVATE_H
#define VA_PRIVATE_H
#include <va/va.h>
#include <va/va_backend.h>
#include <pipe/p_format.h>
#include <pipe/p_state.h>
#define VA_DEBUG(_str,...) debug_printf("[Gallium VA backend]: " _str,__VA_ARGS__)
#define VA_INFO(_str,...) VA_DEBUG("INFO: " _str,__VA_ARGS__)
#define VA_WARNING(_str,...) VA_DEBUG("WARNING: " _str,__VA_ARGS__)
#define VA_ERROR(_str,...) VA_DEBUG("ERROR: " _str,__VA_ARGS__)
#define VA_MAX_IMAGE_FORMATS_SUPPORTED 2
#define VA_MAX_SUBPIC_FORMATS_SUPPORTED 2
#define VA_MAX_ENTRYPOINTS 1
#define VL_HANDLES
typedef unsigned int vlHandle;
typedef struct {
struct vl_screen *vscreen;
struct pipe_surface *backbuffer;
} vlVaDriverContextPriv;
typedef struct {
unsigned int width;
unsigned int height;
enum pipe_video_chroma_format format;
VADriverContextP ctx;
} vlVaSurfacePriv;
// Public functions:
VAStatus __vaDriverInit_0_31 (VADriverContextP ctx);
// Private functions:
struct VADriverVTable vlVaGetVtable();
// Vtable functions:
VAStatus vlVaTerminate (VADriverContextP ctx);
VAStatus vlVaQueryConfigProfiles (VADriverContextP ctx, VAProfile *profile_list,int *num_profiles);
VAStatus vlVaQueryConfigEntrypoints (VADriverContextP ctx, VAProfile profile, VAEntrypoint *entrypoint_list, int *num_entrypoints);
VAStatus vlVaGetConfigAttributes (VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint, VAConfigAttrib *attrib_list, int num_attribs);
VAStatus vlVaCreateConfig (VADriverContextP ctx, VAProfile profile, VAEntrypoint entrypoint, VAConfigAttrib *attrib_list, int num_attribs, VAConfigID *config_id);
VAStatus vlVaDestroyConfig (VADriverContextP ctx, VAConfigID config_id);
VAStatus vlVaQueryConfigAttributes (VADriverContextP ctx, VAConfigID config_id, VAProfile *profile, VAEntrypoint *entrypoint, VAConfigAttrib *attrib_list, int *num_attribs);
VAStatus vlVaCreateSurfaces (VADriverContextP ctx,int width,int height,int format,int num_surfaces,VASurfaceID *surfaces);
VAStatus vlVaDestroySurfaces (VADriverContextP ctx, VASurfaceID *surface_list, int num_surfaces);
VAStatus vlVaCreateContext (VADriverContextP ctx,VAConfigID config_id,int picture_width,int picture_height,int flag,VASurfaceID *render_targets,int num_render_targets,VAContextID *context);
VAStatus vlVaDestroyContext (VADriverContextP ctx,VAContextID context);
VAStatus vlVaCreateBuffer (VADriverContextP ctx,VAContextID context,VABufferType type,unsigned int size,unsigned int num_elements,void *data,VABufferID *buf_id);
VAStatus vlVaBufferSetNumElements (VADriverContextP ctx,VABufferID buf_id,unsigned int num_elements);
VAStatus vlVaMapBuffer (VADriverContextP ctx,VABufferID buf_id,void **pbuf);
VAStatus vlVaUnmapBuffer (VADriverContextP ctx,VABufferID buf_id);
VAStatus vlVaDestroyBuffer (VADriverContextP ctx,VABufferID buffer_id);
VAStatus vlVaBeginPicture (VADriverContextP ctx,VAContextID context,VASurfaceID render_target);
VAStatus vlVaRenderPicture (VADriverContextP ctx,VAContextID context,VABufferID *buffers,int num_buffers);
VAStatus vlVaEndPicture (VADriverContextP ctx,VAContextID context);
VAStatus vlVaSyncSurface (VADriverContextP ctx,VASurfaceID render_target);
VAStatus vlVaQuerySurfaceStatus (VADriverContextP ctx,VASurfaceID render_target,VASurfaceStatus *status);
VAStatus vlVaPutSurface (VADriverContextP ctx,
VASurfaceID surface,
void* draw,
short srcx,
short srcy,
unsigned short srcw,
unsigned short srch,
short destx,
short desty,
unsigned short destw,
unsigned short desth,
VARectangle *cliprects,
unsigned int number_cliprects,
unsigned int flags);
VAStatus vlVaQueryImageFormats (VADriverContextP ctx,VAImageFormat *format_list,int *num_formats);
VAStatus vlVaQuerySubpictureFormats(VADriverContextP ctx,VAImageFormat *format_list,unsigned int *flags,unsigned int *num_formats);
VAStatus vlVaCreateImage(VADriverContextP ctx,VAImageFormat *format,int width,int height,VAImage *image);
VAStatus vlVaDeriveImage(VADriverContextP ctx,VASurfaceID surface,VAImage *image);
VAStatus vlVaDestroyImage(VADriverContextP ctx,VAImageID image);
VAStatus vlVaSetImagePalette(VADriverContextP ctx,VAImageID image, unsigned char *palette);
VAStatus vlVaGetImage(VADriverContextP ctx,VASurfaceID surface,int x,int y,unsigned int width,unsigned int height,VAImageID image);
VAStatus vlVaPutImage(VADriverContextP ctx,
VASurfaceID surface,
VAImageID image,
int src_x,
int src_y,
unsigned int src_width,
unsigned int src_height,
int dest_x,
int dest_y,
unsigned int dest_width,
unsigned int dest_height);
VAStatus vlVaQuerySubpictureFormats(VADriverContextP ctx,VAImageFormat *format_list,unsigned int *flags,unsigned int *num_formats);
VAStatus vlVaCreateSubpicture(VADriverContextP ctx,VAImageID image,VASubpictureID *subpicture);
VAStatus vlVaDestroySubpicture(VADriverContextP ctx,VASubpictureID subpicture);
VAStatus vlVaSubpictureImage(VADriverContextP ctx,VASubpictureID subpicture,VAImageID image);
VAStatus vlVaSetSubpictureChromakey(VADriverContextP ctx,VASubpictureID subpicture,unsigned int chromakey_min,unsigned int chromakey_max,unsigned int chromakey_mask);
VAStatus vlVaSetSubpictureGlobalAlpha(VADriverContextP ctx,VASubpictureID subpicture,float global_alpha);
VAStatus vlVaAssociateSubpicture(VADriverContextP ctx,
VASubpictureID subpicture,
VASurfaceID *target_surfaces,
int num_surfaces,
short src_x,
short src_y,
unsigned short src_width,
unsigned short src_height,
short dest_x,
short dest_y,
unsigned short dest_width,
unsigned short dest_height,
unsigned int flags);
VAStatus vlVaDeassociateSubpicture(VADriverContextP ctx,VASubpictureID subpicture,VASurfaceID *target_surfaces,int num_surfaces);
VAStatus vlVaQueryDisplayAttributes(VADriverContextP ctx,VADisplayAttribute *attr_list,int *num_attributes);
VAStatus vlVaGetDisplayAttributes(VADriverContextP ctx,VADisplayAttribute *attr_list,int num_attributes);
VAStatus vlVaSetDisplayAttributes(VADriverContextP ctx,VADisplayAttribute *attr_list,int num_attributes);
VAStatus vlVaBufferInfo(VADriverContextP ctx,VAContextID context,VABufferID buf_id,VABufferType *type,unsigned int *size,unsigned int *num_elements);
VAStatus vlVaLockSurface(VADriverContextP ctx,
VASurfaceID surface,
unsigned int *fourcc,
unsigned int *luma_stride,
unsigned int *chroma_u_stride,
unsigned int *chroma_v_stride,
unsigned int *luma_offset,
unsigned int *chroma_u_offset,
unsigned int *chroma_v_offset,
unsigned int *buffer_name,
void **buffer);
VAStatus vlVaUnlockSurface(VADriverContextP ctx,VASurfaceID surface);
#endif //VA_PRIVATE_H

157
src/gallium/state_trackers/va/va_subpicture.c Normal file
View File

@ -0,0 +1,157 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <va/va.h>
#include <va/va_backend.h>
#include <pipe/p_format.h>
#include "va_private.h"
typedef struct {
enum pipe_format pipe_format;
VAImageFormat va_format;
unsigned int va_flags;
} va_subpicture_formats_supported_t;
static const va_subpicture_formats_supported_t va_subpicture_formats_supported[VA_MAX_SUBPIC_FORMATS_SUPPORTED + 1] =
{
{ PIPE_FORMAT_B8G8R8A8_UNORM,
{ VA_FOURCC('B','G','R','A'), VA_LSB_FIRST, 32, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 },
0 },
{ PIPE_FORMAT_R8G8B8A8_UNORM,
{ VA_FOURCC_RGBA, VA_LSB_FIRST, 32, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 },
0 }
};
VAStatus
vlVaQuerySubpictureFormats( VADriverContextP ctx,
VAImageFormat *format_list,
unsigned int *flags,
unsigned int *num_formats)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
if (!(format_list && flags && num_formats))
return VA_STATUS_ERROR_UNKNOWN;
num_formats[0] = VA_MAX_SUBPIC_FORMATS_SUPPORTED;
int n = 0;
/* Query supported formats */
for (n = 0; n < VA_MAX_SUBPIC_FORMATS_SUPPORTED ; n++)
{
const va_subpicture_formats_supported_t * const format_map = &va_subpicture_formats_supported[n];
flags[n] = format_map->va_flags;
format_list[n] = format_map->va_format;
}
return VA_STATUS_SUCCESS;
}
VAStatus vlVaCreateSubpicture( VADriverContextP ctx,
VAImageID image,
VASubpictureID *subpicture)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaDestroySubpicture( VADriverContextP ctx,
VASubpictureID subpicture)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaSubpictureImage( VADriverContextP ctx,
VASubpictureID subpicture,
VAImageID image)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaSetSubpictureChromakey( VADriverContextP ctx,
VASubpictureID subpicture,
unsigned int chromakey_min,
unsigned int chromakey_max,
unsigned int chromakey_mask)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaSetSubpictureGlobalAlpha( VADriverContextP ctx,
VASubpictureID subpicture,
float global_alpha)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaAssociateSubpicture( VADriverContextP ctx,
VASubpictureID subpicture,
VASurfaceID *target_surfaces,
int num_surfaces,
short src_x,
short src_y,
unsigned short src_width,
unsigned short src_height,
short dest_x,
short dest_y,
unsigned short dest_width,
unsigned short dest_height,
unsigned int flags)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaDeassociateSubpicture( VADriverContextP ctx,
VASubpictureID subpicture,
VASurfaceID *target_surfaces,
int num_surfaces)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}

167
src/gallium/state_trackers/va/va_surface.c Normal file
View File

@ -0,0 +1,167 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen & Orasanu Lucian.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <va/va.h>
#include <va/va_backend.h>
#include <util/u_debug.h>
#include <util/u_memory.h>
#include "va_private.h"
boolean vlCreateHTAB(void);
void vlDestroyHTAB(void);
vlHandle vlAddDataHTAB(void *data);
void* vlGetDataHTAB(vlHandle handle);
static enum pipe_video_chroma_format VaRTFormatToPipe(unsigned int va_type)
{
switch (va_type) {
case VA_RT_FORMAT_YUV420:
return PIPE_VIDEO_CHROMA_FORMAT_420;
case VA_RT_FORMAT_YUV422:
return PIPE_VIDEO_CHROMA_FORMAT_422;
case VA_RT_FORMAT_YUV444:
return PIPE_VIDEO_CHROMA_FORMAT_444;
default:
assert(0);
}
return -1;
}
VAStatus vlVaCreateSurfaces( VADriverContextP ctx,
int width,
int height,
int format,
int num_surfaces,
VASurfaceID *surfaces)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
/* We only support one format */
if (VA_RT_FORMAT_YUV420 != format)
return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
if (!(width && height))
return VA_STATUS_ERROR_INVALID_IMAGE_FORMAT;
if (!vlCreateHTAB())
return VA_STATUS_ERROR_UNKNOWN;
vlVaSurfacePriv *va_surface = (vlVaSurfacePriv *)CALLOC(num_surfaces,sizeof(vlVaSurfacePriv));
if (!va_surface)
return VA_STATUS_ERROR_ALLOCATION_FAILED;
int n = 0;
for (n = 0; n < num_surfaces; n++)
{
va_surface[n].width = width;
va_surface[n].height = height;
va_surface[n].format = VaRTFormatToPipe(format);
va_surface[n].ctx = ctx;
surfaces[n] = (VASurfaceID *)vlAddDataHTAB((void *)(va_surface + n));
}
return VA_STATUS_SUCCESS;
}
VAStatus vlVaDestroySurfaces( VADriverContextP ctx,
VASurfaceID *surface_list,
int num_surfaces)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaSyncSurface( VADriverContextP ctx,
VASurfaceID render_target)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaQuerySurfaceStatus( VADriverContextP ctx,
VASurfaceID render_target,
VASurfaceStatus *status)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaPutSurface( VADriverContextP ctx,
VASurfaceID surface,
void* draw,
short srcx,
short srcy,
unsigned short srcw,
unsigned short srch,
short destx,
short desty,
unsigned short destw,
unsigned short desth,
VARectangle *cliprects,
unsigned int number_cliprects,
unsigned int flags)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaLockSurface( VADriverContextP ctx,
VASurfaceID surface,
unsigned int *fourcc,
unsigned int *luma_stride,
unsigned int *chroma_u_stride,
unsigned int *chroma_v_stride,
unsigned int *luma_offset,
unsigned int *chroma_u_offset,
unsigned int *chroma_v_offset,
unsigned int *buffer_name,
void **buffer)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}
VAStatus vlVaUnlockSurface( VADriverContextP ctx,
VASurfaceID surface)
{
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
return VA_STATUS_ERROR_UNIMPLEMENTED;
}

16
src/gallium/state_trackers/vdpau/Makefile
View File

@ -3,6 +3,10 @@ include $(TOP)/configs/current
LIBNAME = vdpautracker
VDPAU_MAJOR = 1
VDPAU_MINOR = 0
LIBRARY_DEFINES = -DVER_MAJOR=$(VDPAU_MAJOR) -DVER_MINOR=$(VDPAU_MINOR) $(STATE_TRACKER_DEFINES)
LIBRARY_INCLUDES = \
$(shell pkg-config --cflags-only-I vdpau) \
-I$(TOP)/src/gallium/winsys/g3dvl
@ -10,6 +14,16 @@ LIBRARY_INCLUDES = \
C_SOURCES = htab.c \
ftab.c \
device.c \
query.c
query.c \
surface.c \
decode.c \
presentation.c \
bitmap.c \
mpeg2_bitstream_parser.c \
output.c \
preemption.c \
mixer.c
include ../../Makefile.template

75
src/gallium/state_trackers/vdpau/bitmap.c Normal file
View File

@ -0,0 +1,75 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <vdpau/vdpau.h>
#include "vdpau_private.h"
#include <util/u_debug.h>
VdpStatus
vlVdpBitmapSurfaceCreate( VdpDevice device,
VdpRGBAFormat rgba_format,
uint32_t width, uint32_t height,
VdpBool frequently_accessed,
VdpBitmapSurface *surface)
{
debug_printf("[VDPAU] Creating a bitmap surface\n");
if (!surface)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpBitmapSurfaceDestroy ( VdpBitmapSurface surface )
{
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpBitmapSurfaceGetParameters ( VdpBitmapSurface surface,
VdpRGBAFormat *rgba_format,
uint32_t *width, uint32_t *height,
VdpBool *frequently_accessed)
{
if (!(rgba_format && width && height && frequently_accessed))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpBitmapSurfacePutBitsNative ( VdpBitmapSurface surface,
void const *const *source_data,
uint32_t const *source_pitches,
VdpRect const *destination_rect )
{
if (!(source_data && source_pitches && destination_rect))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}

0
src/gallium/state_trackers/vdpau/color.c Normal file
View File

309
src/gallium/state_trackers/vdpau/decode.c Normal file
View File

@ -0,0 +1,309 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "vdpau_private.h"
#include "mpeg2_bitstream_parser.h"
#include <util/u_memory.h>
#include <util/u_math.h>
#include <pipe/p_video_context.h>
#include <util/u_debug.h>
VdpStatus
vlVdpDecoderCreate ( VdpDevice device,
VdpDecoderProfile profile,
uint32_t width, uint32_t height,
uint32_t max_references,
VdpDecoder *decoder
)
{
enum pipe_video_profile p_profile = PIPE_VIDEO_PROFILE_UNKNOWN;
VdpStatus ret = VDP_STATUS_OK;
vlVdpDecoder *vldecoder = NULL;
debug_printf("[VDPAU] Creating decoder\n");
if (!decoder)
return VDP_STATUS_INVALID_POINTER;
if (!(width && height))
return VDP_STATUS_INVALID_VALUE;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev) {
ret = VDP_STATUS_INVALID_HANDLE;
goto inv_device;
}
vldecoder = CALLOC(1,sizeof(vlVdpDecoder));
if (!vldecoder) {
ret = VDP_STATUS_RESOURCES;
goto no_decoder;
}
p_profile = ProfileToPipe(profile);
if (p_profile == PIPE_VIDEO_PROFILE_UNKNOWN) {
ret = VDP_STATUS_INVALID_DECODER_PROFILE;
goto inv_profile;
}
// TODO: Define max_references. Used mainly for H264
vldecoder->profile = p_profile;
vldecoder->height = height;
vldecoder->width = width;
vldecoder->device = dev;
vldecoder->vctx = NULL;
*decoder = vlAddDataHTAB(vldecoder);
if (*decoder == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
debug_printf("[VDPAU] Decoder created succesfully\n");
return VDP_STATUS_OK;
no_handle:
FREE(vldecoder);
inv_profile:
no_screen:
no_decoder:
inv_device:
return ret;
}
VdpStatus
vlVdpDecoderDestroy (VdpDecoder decoder
)
{
debug_printf("[VDPAU] Destroying decoder\n");
vlVdpDecoder *vldecoder;
vldecoder = (vlVdpDecoder *)vlGetDataHTAB(decoder);
if (!vldecoder) {
return VDP_STATUS_INVALID_HANDLE;
}
if (vldecoder->vctx)
{
if (vldecoder->vctx->vscreen)
vl_screen_destroy(vldecoder->vctx->vscreen);
}
if (vldecoder->vctx)
vl_video_destroy(vldecoder->vctx);
FREE(vldecoder);
return VDP_STATUS_OK;
}
VdpStatus
vlVdpCreateSurfaceTarget (vlVdpDecoder *vldecoder,
vlVdpSurface *vlsurf
)
{
struct pipe_resource tmplt;
struct pipe_resource *surf_tex;
struct pipe_video_context *vctx;
debug_printf("[VDPAU] Creating surface\n");
if(!(vldecoder && vlsurf))
return VDP_STATUS_INVALID_POINTER;
vctx = vldecoder->vctx->vpipe;
memset(&tmplt, 0, sizeof(struct pipe_resource));
tmplt.target = PIPE_TEXTURE_2D;
tmplt.format = vctx->get_param(vctx,PIPE_CAP_DECODE_TARGET_PREFERRED_FORMAT);
tmplt.last_level = 0;
if (vctx->is_format_supported(vctx, tmplt.format,
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO)) {
tmplt.width0 = vlsurf->width;
tmplt.height0 = vlsurf->height;
}
else {
assert(vctx->is_format_supported(vctx, tmplt.format,
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_SQUARE));
tmplt.width0 = util_next_power_of_two(vlsurf->width);
tmplt.height0 = util_next_power_of_two(vlsurf->height);
}
tmplt.depth0 = 1;
tmplt.usage = PIPE_USAGE_DEFAULT;
tmplt.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
tmplt.flags = 0;
surf_tex = vctx->screen->resource_create(vctx->screen, &tmplt);
vlsurf->psurface = vctx->screen->get_tex_surface(vctx->screen, surf_tex, 0, 0, 0,
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET);
pipe_resource_reference(&surf_tex, NULL);
if (!vlsurf->psurface)
return VDP_STATUS_RESOURCES;
debug_printf("[VDPAU] Done creating surface\n");
return VDP_STATUS_OK;
}
VdpStatus
vlVdpDecoderRenderMpeg2 (vlVdpDecoder *vldecoder,
vlVdpSurface *vlsurf,
VdpPictureInfoMPEG1Or2 *picture_info,
uint32_t bitstream_buffer_count,
VdpBitstreamBuffer const *bitstream_buffers
)
{
struct pipe_video_context *vpipe;
vlVdpSurface *t_vdp_surf;
vlVdpSurface *p_vdp_surf;
vlVdpSurface *f_vdp_surf;
struct pipe_surface *t_surf;
struct pipe_surface *p_surf;
struct pipe_surface *f_surf;
uint32_t num_macroblocks;
struct pipe_mpeg12_macroblock *pipe_macroblocks;
VdpStatus ret;
debug_printf("[VDPAU] Decoding MPEG2\n");
t_vdp_surf = vlsurf;
/* if surfaces equals VDP_STATUS_INVALID_HANDLE, they are not used */
if (picture_info->backward_reference == VDP_INVALID_HANDLE)
p_vdp_surf = NULL;
else {
p_vdp_surf = (vlVdpSurface *)vlGetDataHTAB(picture_info->backward_reference);
if (!p_vdp_surf)
return VDP_STATUS_INVALID_HANDLE;
}
if (picture_info->forward_reference == VDP_INVALID_HANDLE)
f_vdp_surf = NULL;
else {
f_vdp_surf = (vlVdpSurface *)vlGetDataHTAB(picture_info->forward_reference);
if (!f_vdp_surf)
return VDP_STATUS_INVALID_HANDLE;
}
if (f_vdp_surf == VDP_INVALID_HANDLE) f_vdp_surf = NULL;
ret = vlVdpCreateSurfaceTarget(vldecoder,t_vdp_surf);
vpipe = vldecoder->vctx->vpipe;
if (vlVdpMPEG2BitstreamToMacroblock(vpipe->screen, bitstream_buffers, bitstream_buffer_count,
&num_macroblocks, &pipe_macroblocks))
{
debug_printf("[VDPAU] Error in frame-header. Skipping.\n");
ret = VDP_STATUS_OK;
goto skip_frame;
}
vpipe->set_decode_target(vpipe,t_surf);
vpipe->decode_macroblocks(vpipe, p_surf, f_surf, num_macroblocks, (struct pipe_macroblock *)pipe_macroblocks, NULL);
skip_frame:
return ret;
}
VdpStatus
vlVdpDecoderRender (VdpDecoder decoder,
VdpVideoSurface target,
VdpPictureInfo const *picture_info,
uint32_t bitstream_buffer_count,
VdpBitstreamBuffer const *bitstream_buffers
)
{
vlVdpDecoder *vldecoder;
vlVdpSurface *vlsurf;
struct vl_screen *vscreen;
VdpStatus ret;
debug_printf("[VDPAU] Decoding\n");
if (!(picture_info && bitstream_buffers))
return VDP_STATUS_INVALID_POINTER;
vldecoder = (vlVdpDecoder *)vlGetDataHTAB(decoder);
if (!vldecoder)
return VDP_STATUS_INVALID_HANDLE;
vlsurf = (vlVdpSurface *)vlGetDataHTAB(target);
if (!vlsurf)
return VDP_STATUS_INVALID_HANDLE;
if (vlsurf->device != vldecoder->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
/* Test doesn't make sence */
/*if (vlsurf->chroma_format != vldecoder->chroma_format)
return VDP_STATUS_INVALID_CHROMA_TYPE;*/
vscreen = vl_screen_create(vldecoder->device->display, vldecoder->device->screen);
if (!vscreen)
return VDP_STATUS_RESOURCES;
vldecoder->vctx = vl_video_create(vscreen, vldecoder->profile, vlsurf->chroma_format, vldecoder->width, vldecoder->height);
if (!vldecoder->vctx)
return VDP_STATUS_RESOURCES;
// TODO: Right now only mpeg2 is supported.
switch (vldecoder->vctx->vpipe->profile) {
case PIPE_VIDEO_PROFILE_MPEG2_SIMPLE:
case PIPE_VIDEO_PROFILE_MPEG2_MAIN:
ret = vlVdpDecoderRenderMpeg2(vldecoder,vlsurf,(VdpPictureInfoMPEG1Or2 *)picture_info,
bitstream_buffer_count,bitstream_buffers);
break;
default:
return VDP_STATUS_INVALID_DECODER_PROFILE;
}
assert(0);
return ret;
}
VdpStatus
vlVdpGenerateCSCMatrix(
VdpProcamp *procamp,
VdpColorStandard standard,
VdpCSCMatrix *csc_matrix)
{
debug_printf("[VDPAU] Generating CSCMatrix\n");
if (!(csc_matrix && procamp))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_OK;
}

114
src/gallium/state_trackers/vdpau/device.c
View File

@ -1,6 +1,6 @@
/**************************************************************************
*
* Copyright 2010 Younes Manton.
* Copyright 2010 Younes Manton og Thomas Balling Sørensen.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
@ -25,19 +25,19 @@
*
**************************************************************************/
#include <vdpau/vdpau_x11.h>
#include <pipe/p_compiler.h>
#include <pipe/p_video_context.h>
#include <vl_winsys.h>
#include <util/u_memory.h>
#include <util/u_debug.h>
#include "vdpau_private.h"
VdpDeviceCreateX11 vdp_imp_device_create_x11;
PUBLIC VdpStatus
vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device, VdpGetProcAddress **get_proc_address)
{
VdpStatus ret;
vlVdpDevice *dev;
vlVdpDevice *dev = NULL;
if (!(display && device && get_proc_address))
return VDP_STATUS_INVALID_POINTER;
@ -53,17 +53,29 @@ vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device, VdpGe
goto no_dev;
}
dev->display = display;
dev->screen = screen;
dev->vscreen = vl_screen_create(display, screen);
if (!dev->vscreen)
{
ret = VDP_STATUS_RESOURCES;
goto no_vscreen;
}
*device = vlAddDataHTAB(dev);
if (*device == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
*get_proc_address = &vlVdpGetProcAddress;
debug_printf("[VDPAU] Device created succesfully\n");
return VDP_STATUS_OK;
no_handle:
/* Destroy vscreen */
no_vscreen:
FREE(dev);
no_dev:
vlDestroyHTAB();
@ -71,18 +83,59 @@ no_htab:
return ret;
}
VdpStatus vlVdpDeviceDestroy(VdpDevice device)
PUBLIC VdpStatus
vlVdpPresentationQueueTargetCreateX11(VdpDevice device, Drawable drawable,VdpPresentationQueueTarget *target)
{
VdpStatus ret;
vlVdpPresentationQueueTarget *pqt = NULL;
debug_printf("[VDPAU] Creating PresentationQueueTarget\n");
if (!drawable)
return VDP_STATUS_INVALID_HANDLE;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
pqt = CALLOC(1, sizeof(vlVdpPresentationQueue));
if (!pqt)
return VDP_STATUS_RESOURCES;
pqt->device = dev;
pqt->drawable = drawable;
*target = vlAddDataHTAB(pqt);
if (*target == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
return VDP_STATUS_OK;
no_handle:
FREE(dev);
return ret;
}
VdpStatus
vlVdpDeviceDestroy(VdpDevice device)
{
debug_printf("[VDPAU] Destroying destroy\n");
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
FREE(dev);
vlDestroyHTAB();
debug_printf("[VDPAU] Device destroyed succesfully\n");
return VDP_STATUS_OK;
}
VdpStatus vlVdpGetProcAddress(VdpDevice device, VdpFuncId function_id, void **function_pointer)
VdpStatus
vlVdpGetProcAddress(VdpDevice device, VdpFuncId function_id, void **function_pointer)
{
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
@ -96,3 +149,50 @@ VdpStatus vlVdpGetProcAddress(VdpDevice device, VdpFuncId function_id, void **fu
return VDP_STATUS_OK;
}
#define _ERROR_TYPE(TYPE,STRING) \
case TYPE: \
return STRING; \
break
char const *
vlVdpGetErrorString (
VdpStatus status)
{
switch (status)
{
_ERROR_TYPE(VDP_STATUS_OK,"The operation completed successfully; no error.");
_ERROR_TYPE(VDP_STATUS_NO_IMPLEMENTATION,"No backend implementation could be loaded.");
_ERROR_TYPE(VDP_STATUS_DISPLAY_PREEMPTED,"The display was preempted, or a fatal error occurred. The application must re-initialize VDPAU.");
_ERROR_TYPE(VDP_STATUS_INVALID_HANDLE,"An invalid handle value was provided. Either the handle does not exist at all, or refers to an object of an incorrect type.");
_ERROR_TYPE(VDP_STATUS_INVALID_POINTER ,"An invalid pointer was provided. Typically, this means that a NULL pointer was provided for an 'output' parameter.");
_ERROR_TYPE(VDP_STATUS_INVALID_CHROMA_TYPE ,"An invalid/unsupported VdpChromaType value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_Y_CB_CR_FORMAT,"An invalid/unsupported VdpYCbCrFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_RGBA_FORMAT,"An invalid/unsupported VdpRGBAFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_INDEXED_FORMAT,"An invalid/unsupported VdpIndexedFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_COLOR_STANDARD,"An invalid/unsupported VdpColorStandard value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_COLOR_TABLE_FORMAT,"An invalid/unsupported VdpColorTableFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_BLEND_FACTOR,"An invalid/unsupported VdpOutputSurfaceRenderBlendFactor value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_BLEND_EQUATION,"An invalid/unsupported VdpOutputSurfaceRenderBlendEquation value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_FLAG,"An invalid/unsupported flag value/combination was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_DECODER_PROFILE,"An invalid/unsupported VdpDecoderProfile value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE,"An invalid/unsupported VdpVideoMixerFeature value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER ,"An invalid/unsupported VdpVideoMixerParameter value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE,"An invalid/unsupported VdpVideoMixerAttribute value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE,"An invalid/unsupported VdpVideoMixerPictureStructure value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_FUNC_ID,"An invalid/unsupported VdpFuncId value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_SIZE,"The size of a supplied object does not match the object it is being used with.\
For example, a VdpVideoMixer is configured to process VdpVideoSurface objects of a specific size.\
If presented with a VdpVideoSurface of a different size, this error will be raised.");
_ERROR_TYPE(VDP_STATUS_INVALID_VALUE,"An invalid/unsupported value was supplied.\
This is a catch-all error code for values of type other than those with a specific error code.");
_ERROR_TYPE(VDP_STATUS_INVALID_STRUCT_VERSION,"An invalid/unsupported structure version was specified in a versioned structure. \
This implies that the implementation is older than the header file the application was built against.");
_ERROR_TYPE(VDP_STATUS_RESOURCES,"The system does not have enough resources to complete the requested operation at this time.");
_ERROR_TYPE(VDP_STATUS_HANDLE_DEVICE_MISMATCH,"The set of handles supplied are not all related to the same VdpDevice.When performing operations \
that operate on multiple surfaces, such as VdpOutputSurfaceRenderOutputSurface or VdpVideoMixerRender, \
all supplied surfaces must have been created within the context of the same VdpDevice object. \
This error is raised if they were not.");
_ERROR_TYPE(VDP_STATUS_ERROR,"A catch-all error, used when no other error code applies.");
}
}

108
src/gallium/state_trackers/vdpau/ftab.c
View File

@ -1,6 +1,6 @@
/**************************************************************************
*
* Copyright 2010 Younes Manton.
* Copyright 2010 Younes Manton & Thomas Balling Sørensen.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
@ -30,78 +30,78 @@
static void* ftab[67] =
{
0, /* VDP_FUNC_ID_GET_ERROR_STRING */
0, /* VDP_FUNC_ID_GET_PROC_ADDRESS */
&vlVdpGetErrorString, /* VDP_FUNC_ID_GET_ERROR_STRING */
&vlVdpGetProcAddress, /* VDP_FUNC_ID_GET_PROC_ADDRESS */
&vlVdpGetApiVersion, /* VDP_FUNC_ID_GET_API_VERSION */
0,
0x55, /* DUMMY */
&vlVdpGetInformationString, /* VDP_FUNC_ID_GET_INFORMATION_STRING */
&vlVdpDeviceDestroy, /* VDP_FUNC_ID_DEVICE_DESTROY */
0, /* VDP_FUNC_ID_GENERATE_CSC_MATRIX */
&vlVdpGenerateCSCMatrix, /* VDP_FUNC_ID_GENERATE_CSC_MATRIX */
&vlVdpVideoSurfaceQueryCapabilities, /* VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES */
&vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities, /* VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES */
0, /* VDP_FUNC_ID_VIDEO_SURFACE_CREATE */
0, /* VDP_FUNC_ID_VIDEO_SURFACE_DESTROY */
0, /* VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS */
0, /* VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR */
0, /* VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR */
&vlVdpVideoSurfaceCreate, /* VDP_FUNC_ID_VIDEO_SURFACE_CREATE */
&vlVdpVideoSurfaceDestroy, /* VDP_FUNC_ID_VIDEO_SURFACE_DESTROY */
&vlVdpVideoSurfaceGetParameters, /* VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS */
&vlVdpVideoSurfaceGetBitsYCbCr, /* VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR */
&vlVdpVideoSurfacePutBitsYCbCr, /* VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR */
&vlVdpOutputSurfaceQueryCapabilities, /* VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES */
&vlVdpOutputSurfaceQueryGetPutBitsNativeCapabilities, /* VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES */
0x2, /* VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES */
&vlVdpOutputSurfaceQueryPutBitsYCbCrCapabilities, /* VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_CREATE */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR */
&vlVdpOutputSurfaceCreate, /* VDP_FUNC_ID_OUTPUT_SURFACE_CREATE */
0x3, /* VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY */
0x4, /* VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS */
0x5, /* VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE */
0x6, /* VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE */
0x7, /* VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED */
0x8, /* VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR */
&vlVdpBitmapSurfaceQueryCapabilities, /* VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES */
0, /* VDP_FUNC_ID_BITMAP_SURFACE_CREATE */
0, /* VDP_FUNC_ID_BITMAP_SURFACE_DESTROY */
0, /* VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS */
0, /* VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE */
0,
0,
0,
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE */
0, /* VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_VIDEO_SURFACE_LUMA */
&vlVdpBitmapSurfaceCreate, /* VDP_FUNC_ID_BITMAP_SURFACE_CREATE */
&vlVdpBitmapSurfaceDestroy, /* VDP_FUNC_ID_BITMAP_SURFACE_DESTROY */
&vlVdpBitmapSurfaceGetParameters, /* VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS */
&vlVdpBitmapSurfacePutBitsNative, /* VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE */
0x55, /* DUMMY */
0x55, /* DUMMY */
0x55, /* DUMMY */
0x9, /* VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE */
0x10, /* VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE */
0x11, /* VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_VIDEO_SURFACE_LUMA */
&vlVdpDecoderQueryCapabilities, /* VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES */
0, /* VDP_FUNC_ID_DECODER_CREATE */
0, /* VDP_FUNC_ID_DECODER_DESTROY */
0, /* VDP_FUNC_ID_DECODER_GET_PARAMETERS */
0, /* VDP_FUNC_ID_DECODER_RENDER */
&vlVdpDecoderCreate, /* VDP_FUNC_ID_DECODER_CREATE */
&vlVdpDecoderDestroy, /* VDP_FUNC_ID_DECODER_DESTROY */
0x12, /* VDP_FUNC_ID_DECODER_GET_PARAMETERS */
&vlVdpDecoderRender, /* VDP_FUNC_ID_DECODER_RENDER */
&vlVdpVideoMixerQueryFeatureSupport, /* VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT */
&vlVdpVideoMixerQueryParameterSupport, /* VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT */
&vlVdpVideoMixerQueryAttributeSupport, /* VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT */
&vlVdpVideoMixerQueryParameterValueRange, /* VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE */
&vlVdpVideoMixerQueryAttributeValueRange, /* VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE */
0, /* VDP_FUNC_ID_VIDEO_MIXER_CREATE */
0, /* VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES */
0, /* VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES */
0, /* VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT */
0, /* VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES */
0, /* VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES */
0, /* VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES */
0, /* VDP_FUNC_ID_VIDEO_MIXER_DESTROY */
0, /* VDP_FUNC_ID_VIDEO_MIXER_RENDER */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR */
0,
0,
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE */
0, /* VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS */
0 /* VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER */
&vlVdpVideoMixerCreate, /* VDP_FUNC_ID_VIDEO_MIXER_CREATE */
&vlVdpVideoMixerSetFeatureEnables, /* VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES */
&vlVdpVideoMixerSetAttributeValues, /* VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES */
0x16, /* VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT */
0x17, /* VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES */
0x18, /* VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES */
0x19, /* VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES */
0x20, /* VDP_FUNC_ID_VIDEO_MIXER_DESTROY */
&vlVdpVideoMixerRender, /* VDP_FUNC_ID_VIDEO_MIXER_RENDER */
&vlVdpPresentationQueueTargetDestroy, /* VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY */
&vlVdpPresentationQueueCreate, /* VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE */
&vlVdpPresentationQueueDestroy, /* VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY */
&vlVdpPresentationQueueSetBackgroundColor, /* VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR */
&vlVdpPresentationQueueGetBackgroundColor, /* VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR */
0x55, /* DUMMY */
0x55, /* DUMMY */
&vlVdpPresentationQueueGetTime, /* VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME */
&vlVdpPresentationQueueDisplay, /* VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY */
&vlVdpPresentationQueueBlockUntilSurfaceIdle, /* VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE */
&vlVdpPresentationQueueQuerySurfaceStatus, /* VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS */
&vlVdpPreemptionCallbackRegister /* VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER */
};
static void* ftab_winsys[1] =
{
0 /* VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11 */
&vlVdpPresentationQueueTargetCreateX11 /* VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11 */
};
boolean vlGetFuncFTAB(VdpFuncId function_id, void **func)

140
src/gallium/state_trackers/vdpau/mixer.c Normal file
View File

@ -0,0 +1,140 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <vdpau/vdpau.h>
#include <util/u_memory.h>
#include <util/u_debug.h>
#include "vdpau_private.h"
VdpStatus
vlVdpVideoMixerCreate (VdpDevice device,
uint32_t feature_count,
VdpVideoMixerFeature const *features,
uint32_t parameter_count,
VdpVideoMixerParameter const *parameters,
void const *const *parameter_values,
VdpVideoMixer *mixer)
{
VdpStatus ret;
vlVdpVideoMixer *vmixer = NULL;
debug_printf("[VDPAU] Creating VideoMixer\n");
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vmixer = CALLOC(1, sizeof(vlVdpVideoMixer));
if (!vmixer)
return VDP_STATUS_RESOURCES;
vmixer->device = dev;
/*
* TODO: Handle features and parameters
* */
*mixer = vlAddDataHTAB(vmixer);
if (*mixer == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
return VDP_STATUS_OK;
no_handle:
return ret;
}
VdpStatus
vlVdpVideoMixerSetFeatureEnables (
VdpVideoMixer mixer,
uint32_t feature_count,
VdpVideoMixerFeature const *features,
VdpBool const *feature_enables)
{
debug_printf("[VDPAU] Setting VideoMixer features\n");
if (!(features && feature_enables))
return VDP_STATUS_INVALID_POINTER;
vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
/*
* TODO: Set features
* */
return VDP_STATUS_OK;
}
VdpStatus vlVdpVideoMixerRender (
VdpVideoMixer mixer,
VdpOutputSurface background_surface,
VdpRect const *background_source_rect,
VdpVideoMixerPictureStructure current_picture_structure,
uint32_t video_surface_past_count,
VdpVideoSurface const *video_surface_past,
VdpVideoSurface video_surface_current,
uint32_t video_surface_future_count,
VdpVideoSurface const *video_surface_future,
VdpRect const *video_source_rect,
VdpOutputSurface destination_surface,
VdpRect const *destination_rect,
VdpRect const *destination_video_rect,
uint32_t layer_count,
VdpLayer const *layers)
{
if (!(background_source_rect && video_surface_past && video_surface_future && video_source_rect && destination_rect && destination_video_rect && layers))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpVideoMixerSetAttributeValues (
VdpVideoMixer mixer,
uint32_t attribute_count,
VdpVideoMixerAttribute const *attributes,
void const *const *attribute_values)
{
if (!(attributes && attribute_values))
return VDP_STATUS_INVALID_POINTER;
vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
/*
* TODO: Implement the function
*
* */
return VDP_STATUS_OK;
}

149
src/gallium/state_trackers/vdpau/mpeg2_bitstream_parser.c Normal file
View File

@ -0,0 +1,149 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "mpeg2_bitstream_parser.h"
int
vlVdpMPEG2NextStartCode(struct vdpMPEG2BitstreamParser *parser)
{
uint32_t integer = 0xffffff00;
uint8_t * ptr_read = parser->ptr_bitstream;
int8_t * bytes_to_end;
bytes_to_end = parser->ptr_bitstream_end - parser->ptr_bitstream;
/* Read byte after byte, until startcode is found */
while(integer != 0x00000100)
{
if (bytes_to_end <= 0)
{
parser->state = MPEG2_BITSTREAM_DONE;
parser->code = 0;
return 0;
}
integer = ( integer | *ptr_read++ ) << 8;
bytes_to_end--;
}
parser->ptr_bitstream = ptr_read;
parser->code = parser->ptr_bitstream;
/* start_code found. rewind cursor a byte */
//parser->cursor -= 8;
return 0;
}
int
vlVdpMPEG2BitstreamToMacroblock (
struct pipe_screen *screen,
VdpBitstreamBuffer const *bitstream_buffers,
uint32_t bitstream_buffer_count,
unsigned int *num_macroblocks,
struct pipe_mpeg12_macroblock **pipe_macroblocks)
{
bool b_header_done = false;
struct vdpMPEG2BitstreamParser parser;
#if(1)
FILE *fp;
if ((fp = fopen("binout", "w"))==NULL) {
printf("Cannot open file.\n");
exit(1);
}
fwrite(bitstream_buffers[0].bitstream, 1, bitstream_buffers[0].bitstream_bytes, fp);
fclose(fp);
#endif
debug_printf("[VDPAU] Starting decoding MPEG2 stream\n");
num_macroblocks[0] = 0;
memset(&parser,0,sizeof(parser));
parser.state = MPEG2_HEADER_START_CODE;
parser.ptr_bitstream = (unsigned char *)bitstream_buffers[0].bitstream;
parser.ptr_bitstream_end = parser.ptr_bitstream + bitstream_buffers[0].bitstream_bytes;
/* Main header parser loop */
while(!b_header_done)
{
switch (parser.state)
{
case MPEG2_SEEK_HEADER:
if (vlVdpMPEG2NextStartCode(&parser))
exit(1);
break;
/* Start_code found */
switch (parser.code)
{
/* sequence_header_code */
case 0xB3:
debug_printf("[VDPAU][Bitstream parser] Sequence header code found\n");
/* We dont need to read this, because we already have this information */
break;
case 0xB5:
debug_printf("[VDPAU][Bitstream parser] Extension start code found\n");
//exit(1);
break;
case 0xB8:
debug_printf("[VDPAU][Bitstream parser] Extension start code found\n");
//exit(1);
break;
}
break;
case MPEG2_BITSTREAM_DONE:
if (parser.cur_bitstream < bitstream_buffer_count - 1)
{
debug_printf("[VDPAU][Bitstream parser] Done parsing current bitstream. Moving to the next\n");
parser.cur_bitstream++;
parser.ptr_bitstream = (unsigned char *)bitstream_buffers[parser.cur_bitstream].bitstream;
parser.ptr_bitstream_end = parser.ptr_bitstream + bitstream_buffers[parser.cur_bitstream].bitstream_bytes;
parser.state = MPEG2_HEADER_START_CODE;
}
else
{
debug_printf("[VDPAU][Bitstream parser] Done with frame\n");
exit(0);
// return 0;
}
break;
}
}
return 0;
}

65
src/gallium/state_trackers/vdpau/mpeg2_bitstream_parser.h Normal file
View File

@ -0,0 +1,65 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#ifndef MPEG2_BITSTREAM_PARSER_H
#define MPEG2_BITSTREAM_PARSER_H
#include <vdpau/vdpau.h>
#include <pipe/p_video_state.h>
#include "vdpau_private.h"
enum vdpMPEG2States
{
MPEG2_SEEK_HEADER,
MPEG2_HEADER_DONE,
MPEG2_BITSTREAM_DONE,
MPEG2_HEADER_START_CODE
};
struct vdpMPEG2BitstreamParser
{
enum vdpMPEG2States state;
uint32_t cur_bitstream;
const uint8_t *ptr_bitstream_end;
const uint8_t *ptr_bitstream;
uint8_t code;
/* The decoded bitstream goes here: */
/* Sequence_header_info */
uint32_t horizontal_size_value;
};
int
vlVdpMPEG2BitstreamToMacroblock(struct pipe_screen *screen,
VdpBitstreamBuffer const *bitstream_buffers,
uint32_t bitstream_buffer_count,
unsigned int *num_macroblocks,
struct pipe_mpeg12_macroblock **pipe_macroblocks);
#endif // MPEG2_BITSTREAM_PARSER_H

64
src/gallium/state_trackers/vdpau/output.c Normal file
View File

@ -0,0 +1,64 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "vdpau_private.h"
#include <vdpau/vdpau.h>
#include <util/u_debug.h>
#include <util/u_memory.h>
VdpStatus
vlVdpOutputSurfaceCreate ( VdpDevice device,
VdpRGBAFormat rgba_format,
uint32_t width, uint32_t height,
VdpOutputSurface *surface)
{
vlVdpOutputSurface *vlsurface = NULL;
debug_printf("[VDPAU] Creating output surface\n");
if (!(width && height))
return VDP_STATUS_INVALID_SIZE;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlsurface = CALLOC(1, sizeof(vlVdpOutputSurface));
if (!vlsurface)
return VDP_STATUS_RESOURCES;
vlsurface->width = width;
vlsurface->height = height;
vlsurface->format = FormatRGBAToPipe(rgba_format);
*surface = vlAddDataHTAB(vlsurface);
if (*surface == 0) {
FREE(dev);
return VDP_STATUS_ERROR;
}
return VDP_STATUS_OK;
}

39
src/gallium/state_trackers/vdpau/preemption.c Normal file
View File

@ -0,0 +1,39 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <vdpau/vdpau.h>
void vlVdpPreemptionCallback (VdpDevice device, void *context)
{
/* TODO: Implement preemption */
}
VdpStatus vlVdpPreemptionCallbackRegister (VdpDevice device, VdpPreemptionCallback callback, void *context)
{
return VDP_STATUS_OK;
}

149
src/gallium/state_trackers/vdpau/presentation.c Normal file
View File

@ -0,0 +1,149 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "vdpau_private.h"
#include <vdpau/vdpau.h>
#include <util/u_debug.h>
#include <util/u_memory.h>
VdpStatus
vlVdpPresentationQueueTargetDestroy (VdpPresentationQueueTarget presentation_queue_target)
{
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueCreate ( VdpDevice device,
VdpPresentationQueueTarget presentation_queue_target,
VdpPresentationQueue *presentation_queue)
{
debug_printf("[VDPAU] Creating PresentationQueue\n");
VdpStatus ret;
vlVdpPresentationQueue *pq = NULL;
if (!presentation_queue)
return VDP_STATUS_INVALID_POINTER;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlVdpPresentationQueueTarget *pqt = vlGetDataHTAB(presentation_queue_target);
if (!pqt)
return VDP_STATUS_INVALID_HANDLE;
if (dev != pqt->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
pq = CALLOC(1, sizeof(vlVdpPresentationQueue));
if (!pq)
return VDP_STATUS_RESOURCES;
*presentation_queue = vlAddDataHTAB(pq);
if (*presentation_queue == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
return VDP_STATUS_OK;
no_handle:
FREE(pq);
return ret;
}
VdpStatus
vlVdpPresentationQueueDestroy (VdpPresentationQueue presentation_queue)
{
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueSetBackgroundColor ( VdpPresentationQueue presentation_queue,
VdpColor *const background_color)
{
if (!background_color)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueGetBackgroundColor ( VdpPresentationQueue presentation_queue,
VdpColor *const background_color)
{
if (!background_color)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueGetTime ( VdpPresentationQueue presentation_queue,
VdpTime *current_time)
{
if (!current_time)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueDisplay ( VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
uint32_t clip_width,
uint32_t clip_height,
VdpTime earliest_presentation_time)
{
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueBlockUntilSurfaceIdle ( VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpTime *first_presentation_time)
{
if (!first_presentation_time)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueQuerySurfaceStatus ( VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpPresentationQueueStatus *status,
VdpTime *first_presentation_time)
{
if (!(status && first_presentation_time))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}

121
src/gallium/state_trackers/vdpau/query.c
View File

@ -26,6 +26,13 @@
**************************************************************************/
#include "vdpau_private.h"
#include <vl_winsys.h>
#include <assert.h>
#include <pipe/p_screen.h>
#include <pipe/p_defines.h>
#include <math.h>
#include <util/u_debug.h>
VdpStatus
vlVdpGetApiVersion(uint32_t *api_version)
@ -43,7 +50,7 @@ vlVdpGetInformationString(char const **information_string)
if (!information_string)
return VDP_STATUS_INVALID_POINTER;
*information_string = "VDPAU-G3DVL";
*information_string = INFORMATION_STRING;
return VDP_STATUS_OK;
}
@ -51,10 +58,44 @@ VdpStatus
vlVdpVideoSurfaceQueryCapabilities(VdpDevice device, VdpChromaType surface_chroma_type,
VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
{
struct vl_screen *vlscreen;
uint32_t max_2d_texture_level;
VdpStatus ret;
debug_printf("[VDPAU] Querying video surfaces\n");
if (!(is_supported && max_width && max_height))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlscreen = vl_screen_create(dev->display, dev->screen);
if (!vlscreen)
return VDP_STATUS_RESOURCES;
/* XXX: Current limits */
*is_supported = true;
if (surface_chroma_type != VDP_CHROMA_TYPE_420) {
*is_supported = false;
goto no_sup;
}
max_2d_texture_level = vlscreen->pscreen->get_param( vlscreen->pscreen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS );
if (!max_2d_texture_level) {
ret = VDP_STATUS_RESOURCES;
goto no_sup;
}
/* I am not quite sure if it is max_2d_texture_level-1 or just max_2d_texture_level */
*max_width = *max_height = pow(2,max_2d_texture_level-1);
vl_screen_destroy(vlscreen);
return VDP_STATUS_OK;
no_sup:
return ret;
}
VdpStatus
@ -62,10 +103,32 @@ vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities(VdpDevice device, VdpChromaTyp
VdpYCbCrFormat bits_ycbcr_format,
VdpBool *is_supported)
{
struct vl_screen *vlscreen;
debug_printf("[VDPAU] Querying get put video surfaces\n");
if (!is_supported)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlscreen = vl_screen_create(dev->display, dev->screen);
if (!vlscreen)
return VDP_STATUS_RESOURCES;
if (bits_ycbcr_format != VDP_YCBCR_FORMAT_Y8U8V8A8 && bits_ycbcr_format != VDP_YCBCR_FORMAT_V8U8Y8A8)
*is_supported = vlscreen->pscreen->is_format_supported(vlscreen->pscreen,
FormatToPipe(bits_ycbcr_format),
PIPE_TEXTURE_2D,
1,
PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_SQUARE );
vl_screen_destroy(vlscreen);
return VDP_STATUS_OK;
}
VdpStatus
@ -73,18 +136,61 @@ vlVdpDecoderQueryCapabilities(VdpDevice device, VdpDecoderProfile profile,
VdpBool *is_supported, uint32_t *max_level, uint32_t *max_macroblocks,
uint32_t *max_width, uint32_t *max_height)
{
enum pipe_video_profile p_profile;
uint32_t max_decode_width;
uint32_t max_decode_height;
uint32_t max_2d_texture_level;
struct vl_screen *vlscreen;
debug_printf("[VDPAU] Querying decoder\n");
if (!(is_supported && max_level && max_macroblocks && max_width && max_height))
return VDP_STATUS_INVALID_POINTER;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlscreen = vl_screen_create(dev->display, dev->screen);
if (!vlscreen)
return VDP_STATUS_RESOURCES;
return VDP_STATUS_NO_IMPLEMENTATION;
p_profile = ProfileToPipe(profile);
if (p_profile == PIPE_VIDEO_PROFILE_UNKNOWN) {
*is_supported = false;
return VDP_STATUS_OK;
}
if (p_profile != PIPE_VIDEO_PROFILE_MPEG2_SIMPLE && p_profile != PIPE_VIDEO_PROFILE_MPEG2_MAIN) {
*is_supported = false;
return VDP_STATUS_OK;
}
/* XXX hack, need to implement something more sane when the decoders have been implemented */
max_2d_texture_level = vlscreen->pscreen->get_param( vlscreen->pscreen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS );
max_decode_width = max_decode_height = pow(2,max_2d_texture_level-2);
if (!(max_decode_width && max_decode_height))
return VDP_STATUS_RESOURCES;
*is_supported = true;
*max_width = max_decode_width;
*max_height = max_decode_height;
*max_level = 16;
*max_macroblocks = (max_decode_width/16) * (max_decode_height/16);
vl_screen_destroy(vlscreen);
return VDP_STATUS_OK;
}
VdpStatus
vlVdpOutputSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
{
{
if (!(is_supported && max_width && max_height))
return VDP_STATUS_INVALID_POINTER;
debug_printf("[VDPAU] Querying ouput surfaces\n");
return VDP_STATUS_NO_IMPLEMENTATION;
}
@ -93,6 +199,8 @@ VdpStatus
vlVdpOutputSurfaceQueryGetPutBitsNativeCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
VdpBool *is_supported)
{
debug_printf("[VDPAU] Querying output surfaces get put native cap\n");
if (!is_supported)
return VDP_STATUS_INVALID_POINTER;
@ -104,6 +212,7 @@ vlVdpOutputSurfaceQueryPutBitsYCbCrCapabilities(VdpDevice device, VdpRGBAFormat
VdpYCbCrFormat bits_ycbcr_format,
VdpBool *is_supported)
{
debug_printf("[VDPAU] Querying output surfaces put ycrcb cap\n");
if (!is_supported)
return VDP_STATUS_INVALID_POINTER;
@ -114,6 +223,7 @@ VdpStatus
vlVdpBitmapSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
{
debug_printf("[VDPAU] Querying bitmap surfaces\n");
if (!(is_supported && max_width && max_height))
return VDP_STATUS_INVALID_POINTER;
@ -124,6 +234,7 @@ VdpStatus
vlVdpVideoMixerQueryFeatureSupport(VdpDevice device, VdpVideoMixerFeature feature,
VdpBool *is_supported)
{
debug_printf("[VDPAU] Querying mixer feature support\n");
if (!is_supported)
return VDP_STATUS_INVALID_POINTER;

193
src/gallium/state_trackers/vdpau/surface.c Normal file
View File

@ -0,0 +1,193 @@
/**************************************************************************
*
* Copyright 2010 Thomas Balling Sørensen.
* 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "vdpau_private.h"
#include <pipe/p_screen.h>
#include <pipe/p_state.h>
#include <util/u_memory.h>
#include <util/u_format.h>
VdpStatus
vlVdpVideoSurfaceCreate(VdpDevice device,
VdpChromaType chroma_type,
uint32_t width,
uint32_t height,
VdpVideoSurface *surface)
{
printf("[VDPAU] Creating a surface\n");
vlVdpSurface *p_surf;
VdpStatus ret;
if (!(width && height))
{
ret = VDP_STATUS_INVALID_SIZE;
goto inv_size;
}
if (!vlCreateHTAB()) {
ret = VDP_STATUS_RESOURCES;
goto no_htab;
}
p_surf = CALLOC(1, sizeof(p_surf));
if (!p_surf) {
ret = VDP_STATUS_RESOURCES;
goto no_res;
}
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev) {
ret = VDP_STATUS_INVALID_HANDLE;
goto inv_device;
}
p_surf->chroma_format = TypeToPipe(chroma_type);
p_surf->device = dev;
p_surf->width = width;
p_surf->height = height;
*surface = vlAddDataHTAB(p_surf);
if (*surface == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
return VDP_STATUS_OK;
no_handle:
FREE(p_surf->psurface);
inv_device:
no_surf:
FREE(p_surf);
no_res:
// vlDestroyHTAB(); XXX: Do not destroy this tab, I think.
no_htab:
inv_size:
return ret;
}
VdpStatus
vlVdpVideoSurfaceDestroy ( VdpVideoSurface surface )
{
vlVdpSurface *p_surf;
p_surf = (vlVdpSurface *)vlGetDataHTAB((vlHandle)surface);
if (!p_surf)
return VDP_STATUS_INVALID_HANDLE;
if (p_surf->psurface) {
if (p_surf->psurface->texture) {
if (p_surf->psurface->texture->screen)
p_surf->psurface->texture->screen->tex_surface_destroy(p_surf->psurface);
}
}
FREE(p_surf);
return VDP_STATUS_OK;
}
VdpStatus
vlVdpVideoSurfaceGetParameters ( VdpVideoSurface surface,
VdpChromaType *chroma_type,
uint32_t *width,
uint32_t *height
)
{
if (!(width && height && chroma_type))
return VDP_STATUS_INVALID_POINTER;
vlVdpSurface *p_surf = vlGetDataHTAB(surface);
if (!p_surf)
return VDP_STATUS_INVALID_HANDLE;
if (!(p_surf->chroma_format > 0 && p_surf->chroma_format < 3))
return VDP_STATUS_INVALID_CHROMA_TYPE;
*width = p_surf->width;
*height = p_surf->height;
*chroma_type = PipeToType(p_surf->chroma_format);
return VDP_STATUS_OK;
}
VdpStatus
vlVdpVideoSurfaceGetBitsYCbCr ( VdpVideoSurface surface,
VdpYCbCrFormat destination_ycbcr_format,
void *const *destination_data,
uint32_t const *destination_pitches
)
{
if (!vlCreateHTAB())
return VDP_STATUS_RESOURCES;
vlVdpSurface *p_surf = vlGetDataHTAB(surface);
if (!p_surf)
return VDP_STATUS_INVALID_HANDLE;
if (!p_surf->psurface)
return VDP_STATUS_RESOURCES;
return VDP_STATUS_OK;
}
VdpStatus
vlVdpVideoSurfacePutBitsYCbCr ( VdpVideoSurface surface,
VdpYCbCrFormat source_ycbcr_format,
void const *const *source_data,
uint32_t const *source_pitches
)
{
uint32_t size_surface_bytes;
const struct util_format_description *format_desc;
enum pipe_format pformat = FormatToPipe(source_ycbcr_format);
if (!vlCreateHTAB())
return VDP_STATUS_RESOURCES;
vlVdpSurface *p_surf = vlGetDataHTAB(surface);
if (!p_surf)
return VDP_STATUS_INVALID_HANDLE;
//size_surface_bytes = ( source_pitches[0] * p_surf->height util_format_get_blockheight(pformat) );
/*util_format_translate(enum pipe_format dst_format,
void *dst, unsigned dst_stride,
unsigned dst_x, unsigned dst_y,
enum pipe_format src_format,
const void *src, unsigned src_stride,
unsigned src_x, unsigned src_y,
unsigned width, unsigned height);*/
return VDP_STATUS_NO_IMPLEMENTATION;
}

223
src/gallium/state_trackers/vdpau/vdpau_private.h
View File

@ -1,6 +1,6 @@
/**************************************************************************
*
* Copyright 2010 Younes Manton.
* Copyright 2010 Younes Manton & Thomas Balling Sørensen.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
@ -25,14 +25,195 @@
*
**************************************************************************/
#ifndef VDPAU_PRIVATE_H
#define VDPAU_PRIVATE_H
#include <vdpau/vdpau.h>
#include <vdpau/vdpau_x11.h>
#include <pipe/p_compiler.h>
#include <pipe/p_video_context.h>
#include <vl_winsys.h>
#include <assert.h>
#define INFORMATION G3DVL VDPAU Driver Shared Library version VER_MAJOR.VER_MINOR
#define QUOTEME(x) #x
#define TOSTRING(x) QUOTEME(x)
#define INFORMATION_STRING TOSTRING(INFORMATION)
#define VL_HANDLES
static enum pipe_video_chroma_format TypeToPipe(VdpChromaType vdpau_type)
{
switch (vdpau_type) {
case VDP_CHROMA_TYPE_420:
return PIPE_VIDEO_CHROMA_FORMAT_420;
case VDP_CHROMA_TYPE_422:
return PIPE_VIDEO_CHROMA_FORMAT_422;
case VDP_CHROMA_TYPE_444:
return PIPE_VIDEO_CHROMA_FORMAT_444;
default:
assert(0);
}
return -1;
}
static VdpChromaType PipeToType(enum pipe_video_chroma_format pipe_type)
{
switch (pipe_type) {
case PIPE_VIDEO_CHROMA_FORMAT_420:
return VDP_CHROMA_TYPE_420;
case PIPE_VIDEO_CHROMA_FORMAT_422:
return VDP_CHROMA_TYPE_422;
case PIPE_VIDEO_CHROMA_FORMAT_444:
return VDP_CHROMA_TYPE_444;
default:
assert(0);
}
return -1;
}
static enum pipe_format FormatToPipe(VdpYCbCrFormat vdpau_format)
{
switch (vdpau_format) {
case VDP_YCBCR_FORMAT_NV12:
return PIPE_FORMAT_NV12;
case VDP_YCBCR_FORMAT_YV12:
return PIPE_FORMAT_YV12;
case VDP_YCBCR_FORMAT_UYVY:
return PIPE_FORMAT_UYVY;
case VDP_YCBCR_FORMAT_YUYV:
return PIPE_FORMAT_YUYV;
case VDP_YCBCR_FORMAT_Y8U8V8A8: /* Not defined in p_format.h */
return 0;
case VDP_YCBCR_FORMAT_V8U8Y8A8:
return PIPE_FORMAT_VUYA;
default:
assert(0);
}
return -1;
}
static enum pipe_format FormatRGBAToPipe(VdpRGBAFormat vdpau_format)
{
switch (vdpau_format) {
case VDP_RGBA_FORMAT_A8:
return PIPE_FORMAT_A8_UNORM;
case VDP_RGBA_FORMAT_B10G10R10A2:
return PIPE_FORMAT_B10G10R10A2_UNORM;
case VDP_RGBA_FORMAT_B8G8R8A8:
return PIPE_FORMAT_B8G8R8A8_UNORM;
case VDP_RGBA_FORMAT_R10G10B10A2:
return PIPE_FORMAT_R10G10B10A2_UNORM;
case VDP_RGBA_FORMAT_R8G8B8A8:
return PIPE_FORMAT_R8G8B8A8_UNORM;
default:
assert(0);
}
return -1;
}
static VdpYCbCrFormat PipeToFormat(enum pipe_format p_format)
{
switch (p_format) {
case PIPE_FORMAT_NV12:
return VDP_YCBCR_FORMAT_NV12;
case PIPE_FORMAT_YV12:
return VDP_YCBCR_FORMAT_YV12;
case PIPE_FORMAT_UYVY:
return VDP_YCBCR_FORMAT_UYVY;
case PIPE_FORMAT_YUYV:
return VDP_YCBCR_FORMAT_YUYV;
//case PIPE_FORMAT_YUVA:
// return VDP_YCBCR_FORMAT_Y8U8V8A8;
case PIPE_FORMAT_VUYA:
return VDP_YCBCR_FORMAT_V8U8Y8A8;
default:
assert(0);
}
return -1;
}
static enum pipe_video_profile ProfileToPipe(VdpDecoderProfile vdpau_profile)
{
switch (vdpau_profile) {
case VDP_DECODER_PROFILE_MPEG1:
return PIPE_VIDEO_PROFILE_MPEG1;
case VDP_DECODER_PROFILE_MPEG2_SIMPLE:
return PIPE_VIDEO_PROFILE_MPEG2_SIMPLE;
case VDP_DECODER_PROFILE_MPEG2_MAIN:
return PIPE_VIDEO_PROFILE_MPEG2_MAIN;
case VDP_DECODER_PROFILE_H264_BASELINE:
return PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE;
case VDP_DECODER_PROFILE_H264_MAIN: /* Not defined in p_format.h */
return PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN;
case VDP_DECODER_PROFILE_H264_HIGH:
return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
default:
PIPE_VIDEO_PROFILE_UNKNOWN;
}
return -1;
}
typedef struct
{
int dummy;
Display *display;
int screen;
struct vl_screen *vscreen;
} vlVdpDevice;
typedef struct
{
vlVdpDevice *device;
Drawable drawable;
} vlVdpPresentationQueueTarget;
typedef struct
{
vlVdpDevice *device;
Drawable drawable;
} vlVdpPresentationQueue;
typedef struct
{
vlVdpDevice *device;
} vlVdpVideoMixer;
typedef struct
{
vlVdpDevice *device;
uint32_t width;
uint32_t height;
uint32_t pitch;
struct pipe_surface *psurface;
enum pipe_video_chroma_format chroma_format;
uint8_t *data;
} vlVdpSurface;
typedef struct
{
vlVdpDevice *device;
uint32_t width;
uint32_t height;
enum pipe_format format;
} vlVdpOutputSurface;
typedef struct
{
vlVdpDevice *device;
struct vl_context *vctx;
enum pipe_video_chroma_format chroma_format;
enum pipe_video_profile profile;
uint32_t width;
uint32_t height;
} vlVdpDecoder;
typedef uint32_t vlHandle;
boolean vlCreateHTAB(void);
@ -41,6 +222,12 @@ vlHandle vlAddDataHTAB(void *data);
void* vlGetDataHTAB(vlHandle handle);
boolean vlGetFuncFTAB(VdpFuncId function_id, void **func);
/* Public functions */
VdpDeviceCreateX11 vdp_imp_device_create_x11;
VdpPresentationQueueTargetCreateX11 vlVdpPresentationQueueTargetCreateX11;
/* Internal function pointers */
VdpGetErrorString vlVdpGetErrorString;
VdpDeviceDestroy vlVdpDeviceDestroy;
VdpGetProcAddress vlVdpGetProcAddress;
VdpGetApiVersion vlVdpGetApiVersion;
@ -57,3 +244,35 @@ VdpVideoMixerQueryParameterSupport vlVdpVideoMixerQueryParameterSupport;
VdpVideoMixerQueryParameterValueRange vlVdpVideoMixerQueryParameterValueRange;
VdpVideoMixerQueryAttributeSupport vlVdpVideoMixerQueryAttributeSupport;
VdpVideoMixerQueryAttributeValueRange vlVdpVideoMixerQueryAttributeValueRange;
VdpVideoSurfaceCreate vlVdpVideoSurfaceCreate;
VdpVideoSurfaceDestroy vlVdpVideoSurfaceDestroy;
VdpVideoSurfaceGetParameters vlVdpVideoSurfaceGetParameters;
VdpVideoSurfaceGetBitsYCbCr vlVdpVideoSurfaceGetBitsYCbCr;
VdpVideoSurfacePutBitsYCbCr vlVdpVideoSurfacePutBitsYCbCr;
VdpDecoderCreate vlVdpDecoderCreate;
VdpDecoderDestroy vlVdpDecoderDestroy;
VdpDecoderRender vlVdpDecoderRender;
VdpOutputSurfaceCreate vlVdpOutputSurfaceCreate;
VdpBitmapSurfaceCreate vlVdpBitmapSurfaceCreate;
VdpBitmapSurfaceDestroy vlVdpBitmapSurfaceDestroy;
VdpBitmapSurfaceGetParameters vlVdpBitmapSurfaceGetParameters;
VdpBitmapSurfacePutBitsNative vlVdpBitmapSurfacePutBitsNative;
VdpPresentationQueueTargetDestroy vlVdpPresentationQueueTargetDestroy;
VdpPresentationQueueCreate vlVdpPresentationQueueCreate;
VdpPresentationQueueDestroy vlVdpPresentationQueueDestroy;
VdpPresentationQueueSetBackgroundColor vlVdpPresentationQueueSetBackgroundColor;
VdpPresentationQueueGetBackgroundColor vlVdpPresentationQueueGetBackgroundColor;
VdpPresentationQueueGetTime vlVdpPresentationQueueGetTime;
VdpPresentationQueueDisplay vlVdpPresentationQueueDisplay;
VdpPresentationQueueBlockUntilSurfaceIdle vlVdpPresentationQueueBlockUntilSurfaceIdle;
VdpPresentationQueueQuerySurfaceStatus vlVdpPresentationQueueQuerySurfaceStatus;
VdpPreemptionCallback vlVdpPreemptionCallback;
VdpPreemptionCallbackRegister vlVdpPreemptionCallbackRegister;
VdpVideoMixerSetFeatureEnables vlVdpVideoMixerSetFeatureEnables;
VdpVideoMixerCreate vlVdpVideoMixerCreate;
VdpVideoMixerRender vlVdpVideoMixerRender;
VdpVideoMixerSetAttributeValues vlVdpVideoMixerSetAttributeValues;
VdpGenerateCSCMatrix vlVdpGenerateCSCMatrix;
#endif // VDPAU_PRIVATE_H

13
src/gallium/state_trackers/xorg/xvmc/subpicture.c
View File

@ -215,18 +215,27 @@ Status XvMCClearSubpicture(Display *dpy, XvMCSubpicture *subpicture, short x, sh
{
XvMCSubpicturePrivate *subpicture_priv;
XvMCContextPrivate *context_priv;
unsigned int tmp_color;
float color_f[4];
assert(dpy);
if (!subpicture)
return XvMCBadSubpicture;
/* Convert color to float */
util_format_read_4f(PIPE_FORMAT_B8G8R8A8_UNORM,
color_f, 1,
&color, 4,
0, 0, 1, 1);
subpicture_priv = subpicture->privData;
context_priv = subpicture_priv->context->privData;
/* TODO: Assert clear rect is within bounds? Or clip? */
context_priv->vctx->vpipe->surface_fill(context_priv->vctx->vpipe,
context_priv->vctx->vpipe->clear_render_target(context_priv->vctx->vpipe,
subpicture_priv->sfc, x, y,
width, height, color);
color_f,
width, height);
return Success;
}

62
src/gallium/targets/Makefile.va Normal file
View File

@ -0,0 +1,62 @@
# This makefile template is used to build "driver"_drv_video.so
LIBNAME = lib$(LIBBASENAME).so
VA_LIB_GLOB= lib$(LIBBASENAME).*so*
VA_MAJOR = 0
VA_MINOR = 3
INCLUDES = -I$(TOP)/src/gallium/include \
-I$(TOP)/src/gallium/drivers \
-I$(TOP)/src/gallium/auxiliary \
-I$(TOP)/src/gallium/winsys \
-I$(TOP)/src/gallium/winsys/g3dvl \
$(DRIVER_INCLUDES)
DEFINES = -DGALLIUM_TRACE -DVER_MAJOR=$(VA_MAJOR) -DVER_MINOR=$(VA_MINOR) $(DRIVER_DEFINES)
LIBS = $(EXTRA_LIB_PATH) $(DRIVER_LIBS) -lva -lXext -lX11 -lm
STATE_TRACKER_LIB = $(TOP)/src/gallium/state_trackers/va/libvatracker.a
# XXX: Hack, VA public funcs aren't exported
OBJECTS = $(C_SOURCES:.c=.o) \
$(ASM_SOURCES:.S=.o) \
$(TOP)/src/gallium/state_trackers/va/*.o
##### RULES #####
.c.o:
$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@
.S.o:
$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@
##### TARGETS #####
default: depend symlinks $(TOP)/$(LIB_DIR)/gallium/$(LIBNAME)
$(TOP)/$(LIB_DIR)/gallium/$(LIBNAME): $(OBJECTS) $(PIPE_DRIVERS) $(STATE_TRACKER_LIB) $(TOP)/$(LIB_DIR)/gallium Makefile
$(MKLIB) -o $(LIBBASENAME) -linker '$(CC)' -ldflags '$(LDFLAGS)' \
-major $(VA_MAJOR) -minor $(VA_MINOR) $(MKLIB_OPTIONS) \
-install $(TOP)/$(LIB_DIR)/gallium \
$(OBJECTS) $(STATE_TRACKER_LIB) $(PIPE_DRIVERS) $(LIBS)
$(TOP)/$(LIB_DIR)/gallium:
mkdir -p $@
depend: $(C_SOURCES) $(ASM_SOURCES) $(SYMLINKS)
rm -f depend
touch depend
$(MKDEP) $(MKDEP_OPTIONS) $(DEFINES) $(INCLUDES) $(C_SOURCES) \
$(ASM_SOURCES) 2> /dev/null
# Emacs tags
tags:
etags `find . -name \*.[ch]` `find ../include`
# Remove .o and backup files
clean:
-rm -f *.o *~ *.so $(SYMLINKS)
-rm -f depend depend.bak
install: default
$(INSTALL) -d $(DESTDIR)$(VA_LIB_INSTALL_DIR)
$(MINSTALL) -m 755 $(TOP)/$(LIB_DIR)/gallium/$(VA_LIB_GLOB) $(DESTDIR)$(VA_LIB_INSTALL_DIR)
include depend

9
src/gallium/targets/Makefile.vdpau
View File

@ -2,6 +2,7 @@
LIBBASENAME = vdpau_g3dvl
LIBNAME = lib$(LIBBASENAME).so
VDPAU_LIB_GLOB=lib$(LIBBASENAME).*so*
VDPAU_MAJOR = 1
VDPAU_MINOR = 0
INCLUDES = -I$(TOP)/src/gallium/include \
@ -9,7 +10,7 @@ INCLUDES = -I$(TOP)/src/gallium/include \
-I$(TOP)/src/gallium/auxiliary \
-I$(TOP)/src/gallium/winsys/g3dvl \
$(DRIVER_INCLUDES)
DEFINES = -DGALLIUM_TRACE $(DRIVER_DEFINES)
DEFINES = -DGALLIUM_TRACE -DVER_MAJOR=$(VDPAU_MAJOR) -DVER_MINOR=$(VDPAU_MINOR) $(DRIVER_DEFINES)
LIBS = $(EXTRA_LIB_PATH) $(DRIVER_LIBS) -lvdpau -lXext -lX11 -lm
STATE_TRACKER_LIB = $(TOP)/src/gallium/state_trackers/vdpau/libvdpautracker.a
@ -54,8 +55,8 @@ clean:
-rm -f *.o *~ *.so $(SYMLINKS)
-rm -f depend depend.bak
#install: $(LIBNAME)
# $(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
# $(MINSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
install: default
$(INSTALL) -d $(DESTDIR)$(VDPAU_LIB_INSTALL_DIR)
$(MINSTALL) -m 755 $(TOP)/$(LIB_DIR)/gallium/$(VDPAU_LIB_GLOB) $(DESTDIR)$(VDPAU_LIB_INSTALL_DIR)
include depend

10
src/gallium/targets/Makefile.xvmc
View File

@ -1,7 +1,7 @@
# This makefile template is used to build libXvMCg3dvl.so
LIBBASENAME = XvMCg3dvl
LIBNAME = lib$(LIBBASENAME).so
LIB_GLOB=lib$(LIBBASENAME).*so*
XVMC_MAJOR = 1
XVMC_MINOR = 0
INCLUDES = -I$(TOP)/src/gallium/include \
@ -11,7 +11,7 @@ INCLUDES = -I$(TOP)/src/gallium/include \
-I$(TOP)/src/gallium/winsys/g3dvl \
$(DRIVER_INCLUDES)
DEFINES = -DGALLIUM_TRACE $(DRIVER_DEFINES)
LIBS = $(EXTRA_LIB_PATH) $(DRIVER_LIBS) -lXvMC -lXv -lX11 -lm
LIBS = $(EXTRA_LIB_PATH) $(DRIVER_LIBS) -lXv -lX11 -lm
STATE_TRACKER_LIB = $(TOP)/src/gallium/state_trackers/xorg/xvmc/libxvmctracker.a
# XXX: Hack, XvMC public funcs aren't exported if we link to libxvmctracker.a :(
@ -55,8 +55,8 @@ clean:
-rm -f *.o *~ *.so $(SYMLINKS)
-rm -f depend depend.bak
#install: $(LIBNAME)
# $(INSTALL) -d $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
# $(MINSTALL) -m 755 $(LIBNAME) $(DESTDIR)$(DRI_DRIVER_INSTALL_DIR)
install: default
$(INSTALL) -d $(DESTDIR)$(INSTALL_DIR)/$(LIB_DIR)
$(MINSTALL) -m 755 $(TOP)/$(LIB_DIR)/gallium/$(LIB_GLOB) $(DESTDIR)$(INSTALL_DIR)/$(LIB_DIR)
include depend

26
src/gallium/targets/va-r600/Makefile Normal file
View File

@ -0,0 +1,26 @@
TOP = ../../../..
include $(TOP)/configs/current
LIBBASENAME = r600_drv_video
DRIVER_DEFINES = -DGALLIUM_SOFTPIPE
DRIVER_INCLUDES =
PIPE_DRIVERS = \
$(TOP)/src/gallium/drivers/r600/libr600.a \
$(TOP)/src/gallium/winsys/g3dvl/dri/libvldri.a \
$(TOP)/src/gallium/winsys/r600/drm/libr600winsys.a \
$(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
$(TOP)/src/gallium/drivers/trace/libtrace.a \
$(TOP)/src/gallium/auxiliary/libgallium.a
C_SOURCES = \
target.c \
$(COMMON_GALLIUM_SOURCES) \
$(DRIVER_SOURCES)
DRIVER_LIBS = $(shell pkg-config libdrm_radeon --libs) -lXfixes
include ../Makefile.va
symlinks:

24
src/gallium/targets/va-r600/target.c Normal file
View File

@ -0,0 +1,24 @@
#include "state_tracker/drm_driver.h"
#include "target-helpers/inline_debug_helper.h"
#include "r600/drm/r600_drm_public.h"
#include "r600/r600_public.h"
static struct pipe_screen *create_screen(int fd)
{
struct radeon *radeon;
struct pipe_screen *screen;
radeon = r600_drm_winsys_create(fd);
if (!radeon)
return NULL;
screen = r600_screen_create(radeon);
if (!screen)
return NULL;
screen = debug_screen_wrap(screen);
return screen;
}
DRM_DRIVER_DESCRIPTOR("r600", "radeon", create_screen)

21
src/gallium/targets/va-softpipe/Makefile Normal file
View File

@ -0,0 +1,21 @@
TOP = ../../../..
include $(TOP)/configs/current
LIBBASENAME = softpipe_drv_video
DRIVER_DEFINES = -DGALLIUM_SOFTPIPE
DRIVER_INCLUDES =
PIPE_DRIVERS = \
$(TOP)/src/gallium/winsys/sw/xlib/libws_xlib.a \
$(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
$(TOP)/src/gallium/auxiliary/libgallium.a
C_SOURCES = \
$(TOP)/src/gallium/winsys/g3dvl/xlib/xsp_winsys.c
DRIVER_LIBS =
include ../Makefile.va
symlinks:

2
src/gallium/targets/xvmc-nouveau/Makefile
View File

@ -1,7 +1,7 @@
TOP = ../../../..
include $(TOP)/configs/current
#LIBNAME =
LIBBASENAME = XvMCnouveau
PIPE_DRIVERS = \
$(TOP)/src/gallium/winsys/g3dvl/dri/libvldri.a \

2
src/gallium/targets/xvmc-r600/Makefile
View File

@ -1,7 +1,7 @@
TOP = ../../../..
include $(TOP)/configs/current
#LIBNAME =
LIBBASENAME = XvMCr600
PIPE_DRIVERS = \
$(TOP)/src/gallium/drivers/r600/libr600.a \

2
src/gallium/targets/xvmc-softpipe/Makefile
View File

@ -1,6 +1,8 @@
TOP = ../../../..
include $(TOP)/configs/current
LIBBASENAME = XvMCsoftpipe
DRIVER_DEFINES = -DGALLIUM_SOFTPIPE
DRIVER_INCLUDES =

17
src/gallium/tests/python/retrace/README
View File

@ -1,17 +0,0 @@
This is an application written in python to replay the traces captured by the
trace pipe driver.
To use it follow the instructions in src/gallium/drivers/trace/README and
src/gallium/state_trackers/python/README, and then do
python src/gallium/state_trackers/python/samples/retrace/interpreter.py filename.trace
This is still work in progress:
- not everything is captured/replayed
- surface/textures contents
- any tiny error will result in a crash
--
Jose Fonseca <jrfonseca@tungstengraphics.com>

173
src/gallium/tests/python/retrace/format.py
View File

@ -1,173 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
# 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 TUNGSTEN GRAPHICS 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.
#
##########################################################################
import sys
class Formatter:
'''Plain formatter'''
def __init__(self, stream):
self.stream = stream
def text(self, text):
self.stream.write(text)
def newline(self):
self.text('\n')
def function(self, name):
self.text(name)
def variable(self, name):
self.text(name)
def literal(self, value):
self.text(str(value))
def address(self, addr):
self.text(str(addr))
class AnsiFormatter(Formatter):
'''Formatter for plain-text files which outputs ANSI escape codes. See
http://en.wikipedia.org/wiki/ANSI_escape_code for more information
concerning ANSI escape codes.
'''
_csi = '\33['
_normal = '0m'
_bold = '1m'
_italic = '3m'
_red = '31m'
_green = '32m'
_blue = '34m'
def _escape(self, code):
self.text(self._csi + code)
def function(self, name):
self._escape(self._bold)
Formatter.function(self, name)
self._escape(self._normal)
def variable(self, name):
self._escape(self._italic)
Formatter.variable(self, name)
self._escape(self._normal)
def literal(self, value):
self._escape(self._blue)
Formatter.literal(self, value)
self._escape(self._normal)
def address(self, value):
self._escape(self._green)
Formatter.address(self, value)
self._escape(self._normal)
class WindowsConsoleFormatter(Formatter):
'''Formatter for the Windows Console. See
http://code.activestate.com/recipes/496901/ for more information.
'''
STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE = -11
STD_ERROR_HANDLE = -12
FOREGROUND_BLUE = 0x01
FOREGROUND_GREEN = 0x02
FOREGROUND_RED = 0x04
FOREGROUND_INTENSITY = 0x08
BACKGROUND_BLUE = 0x10
BACKGROUND_GREEN = 0x20
BACKGROUND_RED = 0x40
BACKGROUND_INTENSITY = 0x80
_normal = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
_bold = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY
_italic = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
_red = FOREGROUND_RED | FOREGROUND_INTENSITY
_green = FOREGROUND_GREEN | FOREGROUND_INTENSITY
_blue = FOREGROUND_BLUE | FOREGROUND_INTENSITY
def __init__(self, stream):
Formatter.__init__(self, stream)
if stream is sys.stdin:
nStdHandle = self.STD_INPUT_HANDLE
elif stream is sys.stdout:
nStdHandle = self.STD_OUTPUT_HANDLE
elif stream is sys.stderr:
nStdHandle = self.STD_ERROR_HANDLE
else:
nStdHandle = None
if nStdHandle:
import ctypes
self.handle = ctypes.windll.kernel32.GetStdHandle(nStdHandle)
else:
self.handle = None
def _attribute(self, attr):
if self.handle:
import ctypes
ctypes.windll.kernel32.SetConsoleTextAttribute(self.handle, attr)
def function(self, name):
self._attribute(self._bold)
Formatter.function(self, name)
self._attribute(self._normal)
def variable(self, name):
self._attribute(self._italic)
Formatter.variable(self, name)
self._attribute(self._normal)
def literal(self, value):
self._attribute(self._blue)
Formatter.literal(self, value)
self._attribute(self._normal)
def address(self, value):
self._attribute(self._green)
Formatter.address(self, value)
self._attribute(self._normal)
def DefaultFormatter(stream):
if sys.platform in ('linux2', 'cygwin'):
return AnsiFormatter(stream)
elif sys.platform in ('win32',):
return WindowsConsoleFormatter(stream)
else:
return Formatter(stream)

213
src/gallium/tests/python/retrace/model.py
View File

@ -1,213 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
# 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 TUNGSTEN GRAPHICS 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.
#
##########################################################################
'''Trace data model.'''
import sys
import string
import format
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
class Node:
def visit(self, visitor):
raise NotImplementedError
def __str__(self):
stream = StringIO()
formatter = format.DefaultFormatter(stream)
pretty_printer = PrettyPrinter(formatter)
self.visit(pretty_printer)
return stream.getvalue()
class Literal(Node):
def __init__(self, value):
self.value = value
def visit(self, visitor):
visitor.visit_literal(self)
class NamedConstant(Node):
def __init__(self, name):
self.name = name
def visit(self, visitor):
visitor.visit_named_constant(self)
class Array(Node):
def __init__(self, elements):
self.elements = elements
def visit(self, visitor):
visitor.visit_array(self)
class Struct(Node):
def __init__(self, name, members):
self.name = name
self.members = members
def visit(self, visitor):
visitor.visit_struct(self)
class Pointer(Node):
def __init__(self, address):
self.address = address
def visit(self, visitor):
visitor.visit_pointer(self)
class Call:
def __init__(self, no, klass, method, args, ret):
self.no = no
self.klass = klass
self.method = method
self.args = args
self.ret = ret
def visit(self, visitor):
visitor.visit_call(self)
class Trace:
def __init__(self, calls):
self.calls = calls
def visit(self, visitor):
visitor.visit_trace(self)
class Visitor:
def visit_literal(self, node):
raise NotImplementedError
def visit_named_constant(self, node):
raise NotImplementedError
def visit_array(self, node):
raise NotImplementedError
def visit_struct(self, node):
raise NotImplementedError
def visit_pointer(self, node):
raise NotImplementedError
def visit_call(self, node):
raise NotImplementedError
def visit_trace(self, node):
raise NotImplementedError
class PrettyPrinter:
def __init__(self, formatter):
self.formatter = formatter
def visit_literal(self, node):
if isinstance(node.value, basestring):
if len(node.value) >= 4096 or node.value.strip(string.printable):
self.formatter.text('...')
return
self.formatter.literal('"' + node.value + '"')
return
self.formatter.literal(repr(node.value))
def visit_named_constant(self, node):
self.formatter.literal(node.name)
def visit_array(self, node):
self.formatter.text('{')
sep = ''
for value in node.elements:
self.formatter.text(sep)
value.visit(self)
sep = ', '
self.formatter.text('}')
def visit_struct(self, node):
self.formatter.text('{')
sep = ''
for name, value in node.members:
self.formatter.text(sep)
self.formatter.variable(name)
self.formatter.text(' = ')
value.visit(self)
sep = ', '
self.formatter.text('}')
def visit_pointer(self, node):
self.formatter.address(node.address)
def visit_call(self, node):
self.formatter.text('%s ' % node.no)
if node.klass is not None:
self.formatter.function(node.klass + '::' + node.method)
else:
self.formatter.function(node.method)
self.formatter.text('(')
sep = ''
for name, value in node.args:
self.formatter.text(sep)
self.formatter.variable(name)
self.formatter.text(' = ')
value.visit(self)
sep = ', '
self.formatter.text(')')
if node.ret is not None:
self.formatter.text(' = ')
node.ret.visit(self)
def visit_trace(self, node):
for call in node.calls:
call.visit(self)
self.formatter.newline()

392
src/gallium/tests/python/retrace/parse.py
View File

@ -1,392 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
# 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 TUNGSTEN GRAPHICS 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.
#
##########################################################################
import sys
import xml.parsers.expat
import binascii
import optparse
from model import *
ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF = range(4)
class XmlToken:
def __init__(self, type, name_or_data, attrs = None, line = None, column = None):
assert type in (ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF)
self.type = type
self.name_or_data = name_or_data
self.attrs = attrs
self.line = line
self.column = column
def __str__(self):
if self.type == ELEMENT_START:
return '<' + self.name_or_data + ' ...>'
if self.type == ELEMENT_END:
return '</' + self.name_or_data + '>'
if self.type == CHARACTER_DATA:
return self.name_or_data
if self.type == EOF:
return 'end of file'
assert 0
class XmlTokenizer:
"""Expat based XML tokenizer."""
def __init__(self, fp, skip_ws = True):
self.fp = fp
self.tokens = []
self.index = 0
self.final = False
self.skip_ws = skip_ws
self.character_pos = 0, 0
self.character_data = ''
self.parser = xml.parsers.expat.ParserCreate()
self.parser.StartElementHandler = self.handle_element_start
self.parser.EndElementHandler = self.handle_element_end
self.parser.CharacterDataHandler = self.handle_character_data
def handle_element_start(self, name, attributes):
self.finish_character_data()
line, column = self.pos()
token = XmlToken(ELEMENT_START, name, attributes, line, column)
self.tokens.append(token)
def handle_element_end(self, name):
self.finish_character_data()
line, column = self.pos()
token = XmlToken(ELEMENT_END, name, None, line, column)
self.tokens.append(token)
def handle_character_data(self, data):
if not self.character_data:
self.character_pos = self.pos()
self.character_data += data
def finish_character_data(self):
if self.character_data:
if not self.skip_ws or not self.character_data.isspace():
line, column = self.character_pos
token = XmlToken(CHARACTER_DATA, self.character_data, None, line, column)
self.tokens.append(token)
self.character_data = ''
def next(self):
size = 16*1024
while self.index >= len(self.tokens) and not self.final:
self.tokens = []
self.index = 0
data = self.fp.read(size)
self.final = len(data) < size
data = data.rstrip('\0')
try:
self.parser.Parse(data, self.final)
except xml.parsers.expat.ExpatError, e:
#if e.code == xml.parsers.expat.errors.XML_ERROR_NO_ELEMENTS:
if e.code == 3:
pass
else:
raise e
if self.index >= len(self.tokens):
line, column = self.pos()
token = XmlToken(EOF, None, None, line, column)
else:
token = self.tokens[self.index]
self.index += 1
return token
def pos(self):
return self.parser.CurrentLineNumber, self.parser.CurrentColumnNumber
class TokenMismatch(Exception):
def __init__(self, expected, found):
self.expected = expected
self.found = found
def __str__(self):
return '%u:%u: %s expected, %s found' % (self.found.line, self.found.column, str(self.expected), str(self.found))
class XmlParser:
"""Base XML document parser."""
def __init__(self, fp):
self.tokenizer = XmlTokenizer(fp)
self.consume()
def consume(self):
self.token = self.tokenizer.next()
def match_element_start(self, name):
return self.token.type == ELEMENT_START and self.token.name_or_data == name
def match_element_end(self, name):
return self.token.type == ELEMENT_END and self.token.name_or_data == name
def element_start(self, name):
while self.token.type == CHARACTER_DATA:
self.consume()
if self.token.type != ELEMENT_START:
raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token)
if self.token.name_or_data != name:
raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token)
attrs = self.token.attrs
self.consume()
return attrs
def element_end(self, name):
while self.token.type == CHARACTER_DATA:
self.consume()
if self.token.type != ELEMENT_END:
raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token)
if self.token.name_or_data != name:
raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token)
self.consume()
def character_data(self, strip = True):
data = ''
while self.token.type == CHARACTER_DATA:
data += self.token.name_or_data
self.consume()
if strip:
data = data.strip()
return data
class TraceParser(XmlParser):
def __init__(self, fp):
XmlParser.__init__(self, fp)
self.last_call_no = 0
def parse(self):
self.element_start('trace')
while self.token.type not in (ELEMENT_END, EOF):
call = self.parse_call()
self.handle_call(call)
if self.token.type != EOF:
self.element_end('trace')
def parse_call(self):
attrs = self.element_start('call')
try:
no = int(attrs['no'])
except KeyError:
self.last_call_no += 1
no = self.last_call_no
else:
self.last_call_no = no
klass = attrs['class']
method = attrs['method']
args = []
ret = None
while self.token.type == ELEMENT_START:
if self.token.name_or_data == 'arg':
arg = self.parse_arg()
args.append(arg)
elif self.token.name_or_data == 'ret':
ret = self.parse_ret()
elif self.token.name_or_data == 'call':
# ignore nested function calls
self.parse_call()
else:
raise TokenMismatch("<arg ...> or <ret ...>", self.token)
self.element_end('call')
return Call(no, klass, method, args, ret)
def parse_arg(self):
attrs = self.element_start('arg')
name = attrs['name']
value = self.parse_value()
self.element_end('arg')
return name, value
def parse_ret(self):
attrs = self.element_start('ret')
value = self.parse_value()
self.element_end('ret')
return value
def parse_value(self):
expected_tokens = ('null', 'bool', 'int', 'uint', 'float', 'string', 'enum', 'array', 'struct', 'ptr', 'bytes')
if self.token.type == ELEMENT_START:
if self.token.name_or_data in expected_tokens:
method = getattr(self, 'parse_' + self.token.name_or_data)
return method()
raise TokenMismatch(" or " .join(expected_tokens), self.token)
def parse_null(self):
self.element_start('null')
self.element_end('null')
return Literal(None)
def parse_bool(self):
self.element_start('bool')
value = int(self.character_data())
self.element_end('bool')
return Literal(value)
def parse_int(self):
self.element_start('int')
value = int(self.character_data())
self.element_end('int')
return Literal(value)
def parse_uint(self):
self.element_start('uint')
value = int(self.character_data())
self.element_end('uint')
return Literal(value)
def parse_float(self):
self.element_start('float')
value = float(self.character_data())
self.element_end('float')
return Literal(value)
def parse_enum(self):
self.element_start('enum')
name = self.character_data()
self.element_end('enum')
return NamedConstant(name)
def parse_string(self):
self.element_start('string')
value = self.character_data()
self.element_end('string')
return Literal(value)
def parse_bytes(self):
self.element_start('bytes')
value = binascii.a2b_hex(self.character_data())
self.element_end('bytes')
return Literal(value)
def parse_array(self):
self.element_start('array')
elems = []
while self.token.type != ELEMENT_END:
elems.append(self.parse_elem())
self.element_end('array')
return Array(elems)
def parse_elem(self):
self.element_start('elem')
value = self.parse_value()
self.element_end('elem')
return value
def parse_struct(self):
attrs = self.element_start('struct')
name = attrs['name']
members = []
while self.token.type != ELEMENT_END:
members.append(self.parse_member())
self.element_end('struct')
return Struct(name, members)
def parse_member(self):
attrs = self.element_start('member')
name = attrs['name']
value = self.parse_value()
self.element_end('member')
return name, value
def parse_ptr(self):
self.element_start('ptr')
address = self.character_data()
self.element_end('ptr')
return Pointer(address)
def handle_call(self, call):
pass
class TraceDumper(TraceParser):
def __init__(self, fp):
TraceParser.__init__(self, fp)
self.formatter = format.DefaultFormatter(sys.stdout)
self.pretty_printer = PrettyPrinter(self.formatter)
def handle_call(self, call):
call.visit(self.pretty_printer)
self.formatter.newline()
class Main:
'''Common main class for all retrace command line utilities.'''
def __init__(self):
pass
def main(self):
optparser = self.get_optparser()
(options, args) = optparser.parse_args(sys.argv[1:])
if args:
for arg in args:
if arg.endswith('.gz'):
from gzip import GzipFile
stream = GzipFile(arg, 'rt')
elif arg.endswith('.bz2'):
from bz2 import BZ2File
stream = BZ2File(arg, 'rU')
else:
stream = open(arg, 'rt')
self.process_arg(stream, options)
else:
self.process_arg(stream, options)
def get_optparser(self):
optparser = optparse.OptionParser(
usage="\n\t%prog [options] [traces] ...")
return optparser
def process_arg(self, stream, options):
parser = TraceDumper(stream)
parser.parse()
if __name__ == '__main__':
Main().main()

34
src/gallium/tests/python/retrace/parser.py
View File

@ -1,34 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
# 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 TUNGSTEN GRAPHICS 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.
#
##########################################################################
from parse import *
if __name__ == '__main__':
Main().main()

254
src/gallium/tests/python/samples/gs.py
View File

@ -1,254 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2009 VMware
# 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 TUNGSTEN GRAPHICS 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.
#
##########################################################################
from gallium import *
def make_image(surface):
data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
import Image
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
return outimage
def save_image(filename, surface):
outimage = make_image(surface)
outimage.save(filename, "PNG")
def show_image(surface):
outimage = make_image(surface)
import Tkinter as tk
from PIL import Image, ImageTk
root = tk.Tk()
root.title('background image')
image1 = ImageTk.PhotoImage(outimage)
w = image1.width()
h = image1.height()
x = 100
y = 100
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
panel1 = tk.Label(root, image=image1)
panel1.pack(side='top', fill='both', expand='yes')
panel1.image = image1
root.mainloop()
def test(dev):
ctx = dev.context_create()
width = 255
height = 255
minz = 0.0
maxz = 1.0
# disabled blending/masking
blend = Blend()
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].colormask = PIPE_MASK_RGBA
ctx.set_blend(blend)
# depth/stencil/alpha
depth_stencil_alpha = DepthStencilAlpha()
depth_stencil_alpha.depth.enabled = 1
depth_stencil_alpha.depth.writemask = 1
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
# rasterizer
rasterizer = Rasterizer()
rasterizer.front_winding = PIPE_WINDING_CW
rasterizer.cull_mode = PIPE_WINDING_NONE
rasterizer.scissor = 1
ctx.set_rasterizer(rasterizer)
# viewport
viewport = Viewport()
scale = FloatArray(4)
scale[0] = width / 2.0
scale[1] = -height / 2.0
scale[2] = (maxz - minz) / 2.0
scale[3] = 1.0
viewport.scale = scale
translate = FloatArray(4)
translate[0] = width / 2.0
translate[1] = height / 2.0
translate[2] = (maxz - minz) / 2.0
translate[3] = 0.0
viewport.translate = translate
ctx.set_viewport(viewport)
# samplers
sampler = Sampler()
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.normalized_coords = 1
ctx.set_sampler(0, sampler)
# scissor
scissor = Scissor()
scissor.minx = 0
scissor.miny = 0
scissor.maxx = width
scissor.maxy = height
ctx.set_scissor(scissor)
clip = Clip()
clip.nr = 0
ctx.set_clip(clip)
# framebuffer
cbuf = dev.resource_create(
PIPE_FORMAT_B8G8R8X8_UNORM,
width, height,
bind=PIPE_BIND_RENDER_TARGET,
).get_surface()
zbuf = dev.resource_create(
PIPE_FORMAT_Z32_UNORM,
width, height,
bind=PIPE_BIND_DEPTH_STENCIL,
).get_surface()
fb = Framebuffer()
fb.width = width
fb.height = height
fb.nr_cbufs = 1
fb.set_cbuf(0, cbuf)
fb.set_zsbuf(zbuf)
ctx.set_framebuffer(fb)
rgba = FloatArray(4);
rgba[0] = 0.0
rgba[1] = 0.0
rgba[2] = 0.0
rgba[3] = 0.0
ctx.clear(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0xff)
# vertex shader
vs = Shader('''
VERT
DCL IN[0], POSITION, CONSTANT
DCL IN[1], COLOR, CONSTANT
DCL OUT[0], POSITION, CONSTANT
DCL OUT[1], COLOR, CONSTANT
0:MOV OUT[0], IN[0]
1:MOV OUT[1], IN[1]
2:END
''')
ctx.set_vertex_shader(vs)
gs = Shader('''
GEOM
PROPERTY GS_INPUT_PRIMITIVE TRIANGLES
PROPERTY GS_OUTPUT_PRIMITIVE TRIANGLE_STRIP
DCL IN[][0], POSITION, CONSTANT
DCL IN[][1], COLOR, CONSTANT
DCL OUT[0], POSITION, CONSTANT
DCL OUT[1], COLOR, CONSTANT
0:MOV OUT[0], IN[0][0]
1:MOV OUT[1], IN[0][1]
2:EMIT
3:MOV OUT[0], IN[1][0]
4:MOV OUT[1], IN[1][1]
5:EMIT
6:MOV OUT[0], IN[2][0]
7:MOV OUT[1], IN[2][1]
8:EMIT
9:ENDPRIM
10:END
''')
ctx.set_geometry_shader(gs)
# fragment shader
fs = Shader('''
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR, CONSTANT
0:MOV OUT[0], IN[0]
1:END
''')
ctx.set_fragment_shader(fs)
nverts = 3
nattrs = 2
verts = FloatArray(nverts * nattrs * 4)
verts[ 0] = 0.0 # x1
verts[ 1] = 0.8 # y1
verts[ 2] = 0.2 # z1
verts[ 3] = 1.0 # w1
verts[ 4] = 1.0 # r1
verts[ 5] = 0.0 # g1
verts[ 6] = 0.0 # b1
verts[ 7] = 1.0 # a1
verts[ 8] = -0.8 # x2
verts[ 9] = -0.8 # y2
verts[10] = 0.5 # z2
verts[11] = 1.0 # w2
verts[12] = 0.0 # r2
verts[13] = 1.0 # g2
verts[14] = 0.0 # b2
verts[15] = 1.0 # a2
verts[16] = 0.8 # x3
verts[17] = -0.8 # y3
verts[18] = 0.8 # z3
verts[19] = 1.0 # w3
verts[20] = 0.0 # r3
verts[21] = 0.0 # g3
verts[22] = 1.0 # b3
verts[23] = 1.0 # a3
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
nverts,
nattrs,
verts)
ctx.flush()
show_image(cbuf)
#show_image(zbuf)
#save_image('cbuf.png', cbuf)
#save_image('zbuf.png', zbuf)
def main():
dev = Device()
test(dev)
if __name__ == '__main__':
main()

233
src/gallium/tests/python/samples/tri.py
View File

@ -1,233 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
# 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 TUNGSTEN GRAPHICS 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.
#
##########################################################################
from gallium import *
def make_image(ctx, surface):
data = ctx.surface_read_rgba8(surface, 0, 0, surface.width, surface.height)
import Image
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
return outimage
def save_image(ctx, surface, filename):
outimage = make_image(ctx, surface)
outimage.save(filename, "PNG")
def show_image(ctx, surface):
outimage = make_image(ctx, surface)
import Tkinter as tk
from PIL import Image, ImageTk
root = tk.Tk()
root.title('background image')
image1 = ImageTk.PhotoImage(outimage)
w = image1.width()
h = image1.height()
x = 100
y = 100
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
panel1 = tk.Label(root, image=image1)
panel1.pack(side='top', fill='both', expand='yes')
panel1.image = image1
root.mainloop()
def test(dev):
ctx = dev.context_create()
width = 255
height = 255
minz = 0.0
maxz = 1.0
# disabled blending/masking
blend = Blend()
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].colormask = PIPE_MASK_RGBA
ctx.set_blend(blend)
# depth/stencil/alpha
depth_stencil_alpha = DepthStencilAlpha()
depth_stencil_alpha.depth.enabled = 1
depth_stencil_alpha.depth.writemask = 1
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
# rasterizer
rasterizer = Rasterizer()
rasterizer.front_ccw = False
rasterizer.cull_face = PIPE_FACE_NONE
rasterizer.scissor = 1
ctx.set_rasterizer(rasterizer)
# viewport
viewport = Viewport()
scale = FloatArray(4)
scale[0] = width / 2.0
scale[1] = -height / 2.0
scale[2] = (maxz - minz) / 2.0
scale[3] = 1.0
viewport.scale = scale
translate = FloatArray(4)
translate[0] = width / 2.0
translate[1] = height / 2.0
translate[2] = (maxz - minz) / 2.0
translate[3] = 0.0
viewport.translate = translate
ctx.set_viewport(viewport)
# samplers
sampler = Sampler()
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.normalized_coords = 1
ctx.set_fragment_sampler(0, sampler)
# scissor
scissor = Scissor()
scissor.minx = 0
scissor.miny = 0
scissor.maxx = width
scissor.maxy = height
ctx.set_scissor(scissor)
# clip
clip = Clip()
clip.nr = 0
ctx.set_clip(clip)
# framebuffer
cbuf = dev.resource_create(
PIPE_FORMAT_B8G8R8X8_UNORM,
width, height,
bind=PIPE_BIND_RENDER_TARGET,
).get_surface()
zbuf = dev.resource_create(
PIPE_FORMAT_Z32_UNORM,
width, height,
bind=PIPE_BIND_DEPTH_STENCIL,
).get_surface()
fb = Framebuffer()
fb.width = width
fb.height = height
fb.nr_cbufs = 1
fb.set_cbuf(0, cbuf)
fb.set_zsbuf(zbuf)
ctx.set_framebuffer(fb)
rgba = FloatArray(4);
rgba[0] = 0.0
rgba[1] = 0.0
rgba[2] = 0.0
rgba[3] = 0.0
ctx.clear(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0xff)
# vertex shader
vs = Shader('''
VERT
DCL IN[0]
DCL IN[1]
DCL OUT[0], POSITION, CONSTANT
DCL OUT[1], COLOR, CONSTANT
0:MOV OUT[0], IN[0]
1:MOV OUT[1], IN[1]
2:END
''')
ctx.set_vertex_shader(vs)
# fragment shader
fs = Shader('''
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR, CONSTANT
0:MOV OUT[0], IN[0]
1:END
''')
ctx.set_fragment_shader(fs)
nverts = 3
nattrs = 2
verts = FloatArray(nverts * nattrs * 4)
verts[ 0] = 0.0 # x1
verts[ 1] = 0.8 # y1
verts[ 2] = 0.2 # z1
verts[ 3] = 1.0 # w1
verts[ 4] = 1.0 # r1
verts[ 5] = 0.0 # g1
verts[ 6] = 0.0 # b1
verts[ 7] = 1.0 # a1
verts[ 8] = -0.8 # x2
verts[ 9] = -0.8 # y2
verts[10] = 0.5 # z2
verts[11] = 1.0 # w2
verts[12] = 0.0 # r2
verts[13] = 1.0 # g2
verts[14] = 0.0 # b2
verts[15] = 1.0 # a2
verts[16] = 0.8 # x3
verts[17] = -0.8 # y3
verts[18] = 0.8 # z3
verts[19] = 1.0 # w3
verts[20] = 0.0 # r3
verts[21] = 0.0 # g3
verts[22] = 1.0 # b3
verts[23] = 1.0 # a3
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
nverts,
nattrs,
verts)
ctx.flush()
show_image(ctx, cbuf)
show_image(ctx, zbuf)
save_image(ctx, cbuf, 'cbuf.png')
save_image(ctx, zbuf, 'zbuf.png')
def main():
dev = Device()
test(dev)
if __name__ == '__main__':
main()

3
src/gallium/tests/python/tests/.gitignore vendored
View File

@ -1,3 +0,0 @@
*.txt
*.tsv
*.dot

399
src/gallium/tests/python/tests/base.py
View File

@ -1,399 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2009 VMware, Inc.
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
# 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 VMWARE 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.
#
##########################################################################
"""Base classes for tests.
Loosely inspired on Python's unittest module.
"""
import os.path
import sys
from gallium import *
# Enumerate all pixel formats
formats = {}
for name, value in globals().items():
if name.startswith("PIPE_FORMAT_") and isinstance(value, int) and name not in ("PIPE_FORMAT_NONE", "PIPE_FORMAT_COUNT"):
formats[value] = name
def make_image(width, height, rgba):
import Image
outimage = Image.new(
mode='RGB',
size=(width, height),
color=(0,0,0))
outpixels = outimage.load()
for y in range(0, height):
for x in range(0, width):
offset = (y*width + x)*4
r, g, b, a = [int(min(max(rgba[offset + ch], 0.0), 1.0)*255) for ch in range(4)]
outpixels[x, y] = r, g, b
return outimage
def save_image(width, height, rgba, filename):
outimage = make_image(width, height, rgba)
outimage.save(filename, "PNG")
def show_image(width, height, **rgbas):
import Tkinter as tk
from PIL import Image, ImageTk
root = tk.Tk()
x = 64
y = 64
labels = rgbas.keys()
labels.sort()
for i in range(len(labels)):
label = labels[i]
outimage = make_image(width, height, rgbas[label])
if i:
window = tk.Toplevel(root)
else:
window = root
window.title(label)
image1 = ImageTk.PhotoImage(outimage)
w = image1.width()
h = image1.height()
window.geometry("%dx%d+%d+%d" % (w, h, x, y))
panel1 = tk.Label(window, image=image1)
panel1.pack(side='top', fill='both', expand='yes')
panel1.image = image1
x += w + 2
root.mainloop()
class TestFailure(Exception):
pass
class TestSkip(Exception):
pass
class Test:
def __init__(self):
pass
def _run(self, result):
raise NotImplementedError
def run(self):
result = TestResult()
self._run(result)
result.report()
def assert_rgba(self, ctx, surface, x, y, w, h, expected_rgba, pixel_tol=4.0/256, surface_tol=0.85):
total = h*w
different = ctx.surface_compare_rgba(surface, x, y, w, h, expected_rgba, tol=pixel_tol)
if different:
sys.stderr.write("%u out of %u pixels differ\n" % (different, total))
if float(total - different)/float(total) < surface_tol:
if 0:
rgba = FloatArray(h*w*4)
ctx.surface_read_rgba(surface, x, y, w, h, rgba)
show_image(w, h, Result=rgba, Expected=expected_rgba)
save_image(w, h, rgba, "result.png")
save_image(w, h, expected_rgba, "expected.png")
#sys.exit(0)
raise TestFailure
class TestCase(Test):
tags = ()
def __init__(self, dev, **kargs):
Test.__init__(self)
self.dev = dev
self.__dict__.update(kargs)
def description(self):
descriptions = []
for tag in self.tags:
value = self.get(tag)
if value is not None and value != '':
descriptions.append(tag + '=' + str(value))
return ' '.join(descriptions)
def get(self, tag):
try:
method = getattr(self, '_get_' + tag)
except AttributeError:
return getattr(self, tag, None)
else:
return method()
def _get_target(self):
return {
PIPE_TEXTURE_1D: "1d",
PIPE_TEXTURE_2D: "2d",
PIPE_TEXTURE_3D: "3d",
PIPE_TEXTURE_CUBE: "cube",
}[self.target]
def _get_format(self):
name = formats[self.format]
if name.startswith('PIPE_FORMAT_'):
name = name[12:]
name = name.lower()
return name
def _get_face(self):
if self.target == PIPE_TEXTURE_CUBE:
return {
PIPE_TEX_FACE_POS_X: "+x",
PIPE_TEX_FACE_NEG_X: "-x",
PIPE_TEX_FACE_POS_Y: "+y",
PIPE_TEX_FACE_NEG_Y: "-y",
PIPE_TEX_FACE_POS_Z: "+z",
PIPE_TEX_FACE_NEG_Z: "-z",
}[self.face]
else:
return ''
def test(self):
raise NotImplementedError
def _run(self, result):
result.test_start(self)
try:
self.test()
except KeyboardInterrupt:
raise
except TestSkip:
result.test_skipped(self)
except TestFailure:
result.test_failed(self)
else:
result.test_passed(self)
class TestSuite(Test):
def __init__(self, tests = None):
Test.__init__(self)
if tests is None:
self.tests = []
else:
self.tests = tests
def add_test(self, test):
self.tests.append(test)
def _run(self, result):
for test in self.tests:
test._run(result)
class TestResult:
def __init__(self):
self.tests = 0
self.passed = 0
self.skipped = 0
self.failed = 0
self.names = ['result']
self.types = ['pass skip fail']
self.rows = []
def test_start(self, test):
sys.stdout.write("Running %s...\n" % test.description())
sys.stdout.flush()
self.tests += 1
def test_passed(self, test):
sys.stdout.write("PASS\n")
sys.stdout.flush()
self.passed += 1
self.log_result(test, 'pass')
def test_skipped(self, test):
sys.stdout.write("SKIP\n")
sys.stdout.flush()
self.skipped += 1
self.log_result(test, 'skip')
def test_failed(self, test):
sys.stdout.write("FAIL\n")
sys.stdout.flush()
self.failed += 1
self.log_result(test, 'fail')
def log_result(self, test, result):
row = ['']*len(self.names)
# add result
assert self.names[0] == 'result'
assert result in ('pass', 'skip', 'fail')
row[0] = result
# add tags
for tag in test.tags:
value = test.get(tag)
# infer type
if value is None:
continue
elif isinstance(value, (int, float)):
value = str(value)
type = 'c' # continous
elif isinstance(value, basestring):
type = 'd' # discrete
else:
assert False
value = str(value)
type = 'd' # discrete
# insert value
try:
col = self.names.index(tag, 1)
except ValueError:
self.names.append(tag)
self.types.append(type)
row.append(value)
else:
row[col] = value
assert self.types[col] == type
self.rows.append(row)
def report(self):
sys.stdout.write("%u tests, %u passed, %u skipped, %u failed\n\n" % (self.tests, self.passed, self.skipped, self.failed))
sys.stdout.flush()
name, ext = os.path.splitext(os.path.basename(sys.argv[0]))
tree = self.report_tree(name)
self.report_junit(name, stdout=tree)
def report_tree(self, name):
filename = name + '.tsv'
stream = file(filename, 'wt')
# header
stream.write('\t'.join(self.names) + '\n')
stream.write('\t'.join(self.types) + '\n')
stream.write('class\n')
# rows
for row in self.rows:
if row[0] == 'skip':
continue
row += ['']*(len(self.names) - len(row))
stream.write('\t'.join(row) + '\n')
stream.close()
# See http://www.ailab.si/orange/doc/ofb/c_otherclass.htm
try:
import orange
import orngTree
except ImportError:
sys.stderr.write('Install Orange from http://www.ailab.si/orange/ for a classification tree.\n')
return None
data = orange.ExampleTable(filename)
tree = orngTree.TreeLearner(data, sameMajorityPruning=1, mForPruning=2)
orngTree.printTxt(tree, maxDepth=4)
text_tree = orngTree.dumpTree(tree)
file(name + '.txt', 'wt').write(text_tree)
orngTree.printDot(tree, fileName=name+'.dot', nodeShape='ellipse', leafShape='box')
return text_tree
def report_junit(self, name, stdout=None, stderr=None):
"""Write test results in ANT's junit XML format, to use with Hudson CI.
See also:
- http://fisheye.hudson-ci.org/browse/Hudson/trunk/hudson/main/core/src/test/resources/hudson/tasks/junit
- http://www.junit.org/node/399
- http://wiki.apache.org/ant/Proposals/EnhancedTestReports
"""
stream = file(name + '.xml', 'wt')
stream.write('<?xml version="1.0" encoding="UTF-8" ?>\n')
stream.write('<testsuite name="%s">\n' % self.escape_xml(name))
stream.write(' <properties>\n')
stream.write(' </properties>\n')
names = self.names[1:]
for row in self.rows:
test_name = ' '.join(['%s=%s' % pair for pair in zip(self.names[1:], row[1:])])
stream.write(' <testcase name="%s">\n' % (self.escape_xml(test_name)))
result = row[0]
if result == 'pass':
pass
elif result == 'skip':
stream.write(' <skipped/>\n')
else:
stream.write(' <failure/>\n')
stream.write(' </testcase>\n')
if stdout:
stream.write(' <system-out>%s</system-out>\n' % self.escape_xml(stdout))
if stderr:
stream.write(' <system-err>%s</system-err>\n' % self.escape_xml(stderr))
stream.write('</testsuite>\n')
stream.close()
def escape_xml(self, s):
'''Escape a XML string.'''
s = s.replace('&', '&amp;')
s = s.replace('<', '&lt;')
s = s.replace('>', '&gt;')
s = s.replace('"', '&quot;')
s = s.replace("'", '&apos;')
return s

1
src/gallium/tests/python/tests/regress/fragment-shader/.gitignore vendored
View File

@ -1 +0,0 @@
*.png

13
src/gallium/tests/python/tests/regress/fragment-shader/frag-abs.sh
View File

@ -1,13 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { -0.5, -0.4, -0.6, 0.0 }
ADD TEMP[0], IN[0], IMM[0]
ABS OUT[0], TEMP[0]
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-add.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
ADD OUT[0], IN[0], IN[0]
END

13
src/gallium/tests/python/tests/regress/fragment-shader/frag-cb-1d.sh
View File

@ -1,13 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL CONST[1]
DCL CONST[3]
DCL TEMP[0..1]
ADD TEMP[0], IN[0], CONST[1]
RCP TEMP[1], CONST[3].xxxx
MUL OUT[0], TEMP[0], TEMP[1]
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-dp3.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DP3 OUT[0], IN[0], IN[0]
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-dp4.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DP4 OUT[0], IN[0].xyzx, IN[0].xyzx
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-dst.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DST OUT[0], IN[0], IN[0]
END

11
src/gallium/tests/python/tests/regress/fragment-shader/frag-ex2.sh
View File

@ -1,11 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
EX2 TEMP[0], IN[0].xxxx
MUL OUT[0], TEMP[0], IN[0]
END

15
src/gallium/tests/python/tests/regress/fragment-shader/frag-flr.sh
View File

@ -1,15 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { 2.5, 4.0, 2.0, 1.0 }
IMM FLT32 { 0.4, 0.25, 0.5, 1.0 }
MUL TEMP[0], IN[0], IMM[0]
FLR TEMP[0], TEMP[0]
MUL OUT[0], TEMP[0], IMM[1]
END

13
src/gallium/tests/python/tests/regress/fragment-shader/frag-frc.sh
View File

@ -1,13 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { 2.7, 3.1, 4.5, 1.0 }
MUL TEMP[0], IN[0], IMM[0]
FRC OUT[0], TEMP[0]
END

15
src/gallium/tests/python/tests/regress/fragment-shader/frag-lg2.sh
View File

@ -1,15 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
IMM FLT32 { 0.5, 0.0, 0.0, 0.0 }
ADD TEMP[0], IN[0], IMM[0]
LG2 TEMP[0].x, TEMP[0].xxxx
ADD OUT[0], TEMP[0], IMM[1]
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-lit.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
LIT OUT[0], IN[0]
END

11
src/gallium/tests/python/tests/regress/fragment-shader/frag-lrp.sh
View File

@ -1,11 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
ABS TEMP[0], IN[0]
LRP OUT[0], TEMP[0], IN[0].xxxx, IN[0].yyyy
END

11
src/gallium/tests/python/tests/regress/fragment-shader/frag-mad.sh
View File

@ -1,11 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
IMM FLT32 { 0.5, 0.4, 0.6, 1.0 }
IMM FLT32 { 0.5, 0.4, 0.6, 0.0 }
MAD OUT[0], IN[0], IMM[0], IMM[1]
END

10
src/gallium/tests/python/tests/regress/fragment-shader/frag-max.sh
View File

@ -1,10 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
IMM FLT32 { 0.4, 0.4, 0.4, 0.0 }
MAX OUT[0], IN[0], IMM[0]
END

10
src/gallium/tests/python/tests/regress/fragment-shader/frag-min.sh
View File

@ -1,10 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
IMM FLT32 { 0.6, 0.6, 0.6, 1.0 }
MIN OUT[0], IN[0], IMM[0]
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-mov.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
MOV OUT[0], IN[0]
END

10
src/gallium/tests/python/tests/regress/fragment-shader/frag-mul.sh
View File

@ -1,10 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
IMM FLT32 { 0.5, 0.6, 0.7, 1.0 }
MUL OUT[0], IN[0], IMM[0]
END

15
src/gallium/tests/python/tests/regress/fragment-shader/frag-rcp.sh
View File

@ -1,15 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
ADD TEMP[0], IN[0], IMM[0]
RCP TEMP[0].x, TEMP[0].xxxx
SUB OUT[0], TEMP[0], IMM[1]
END

15
src/gallium/tests/python/tests/regress/fragment-shader/frag-rsq.sh
View File

@ -1,15 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
ADD TEMP[0], IN[0], IMM[0]
RSQ TEMP[0].x, TEMP[0].xxxx
SUB OUT[0], TEMP[0], IMM[1]
END

13
src/gallium/tests/python/tests/regress/fragment-shader/frag-sge.sh
View File

@ -1,13 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { 0.6, 0.6, 0.6, 0.0 }
SGE TEMP[0], IN[0], IMM[0]
MUL OUT[0], IN[0], TEMP[0]
END

13
src/gallium/tests/python/tests/regress/fragment-shader/frag-slt.sh
View File

@ -1,13 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { 0.6, 0.6, 0.6, 0.0 }
SLT TEMP[0], IN[0], IMM[0]
MUL OUT[0], IN[0], TEMP[0]
END

13
src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-abs.sh
View File

@ -1,13 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { -0.3, -0.5, -0.4, 0.0 }
ADD TEMP[0], IN[0], IMM[0]
MOV OUT[0], |TEMP[0]|
END

15
src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-absneg.sh
View File

@ -1,15 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
IMM FLT32 { -0.2, -0.3, -0.4, 0.0 }
IMM FLT32 { -1.0, -1.0, -1.0, -1.0 }
ADD TEMP[0], IN[0], IMM[0]
MOV TEMP[0], -|TEMP[0]|
MUL OUT[0], TEMP[0], IMM[1]
END

11
src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-neg.sh
View File

@ -1,11 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
DCL TEMP[0]
SUB TEMP[0], IN[0], IN[0].yzxw
MOV OUT[0], -TEMP[0]
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-srcmod-swz.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
MOV OUT[0], IN[0].yxzw
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-sub.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
SUB OUT[0], IN[0], IN[0].yzxw
END

8
src/gallium/tests/python/tests/regress/fragment-shader/frag-xpd.sh
View File

@ -1,8 +0,0 @@
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR
XPD OUT[0], IN[0], IN[0].yzxw
END

257
src/gallium/tests/python/tests/regress/fragment-shader/fragment-shader.py
View File

@ -1,257 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2009 VMware, 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 VMWARE 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.
#
##########################################################################
import struct
from gallium import *
def make_image(surface):
data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
import Image
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
return outimage
def save_image(filename, surface):
outimage = make_image(surface)
outimage.save(filename, "PNG")
def test(dev, name):
ctx = dev.context_create()
width = 320
height = 320
minz = 0.0
maxz = 1.0
# disabled blending/masking
blend = Blend()
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].colormask = PIPE_MASK_RGBA
ctx.set_blend(blend)
# depth/stencil/alpha
depth_stencil_alpha = DepthStencilAlpha()
depth_stencil_alpha.depth.enabled = 0
depth_stencil_alpha.depth.writemask = 1
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
# rasterizer
rasterizer = Rasterizer()
rasterizer.front_winding = PIPE_WINDING_CW
rasterizer.cull_mode = PIPE_WINDING_NONE
rasterizer.scissor = 1
ctx.set_rasterizer(rasterizer)
# viewport
viewport = Viewport()
scale = FloatArray(4)
scale[0] = width / 2.0
scale[1] = -height / 2.0
scale[2] = (maxz - minz) / 2.0
scale[3] = 1.0
viewport.scale = scale
translate = FloatArray(4)
translate[0] = width / 2.0
translate[1] = height / 2.0
translate[2] = (maxz - minz) / 2.0
translate[3] = 0.0
viewport.translate = translate
ctx.set_viewport(viewport)
# samplers
sampler = Sampler()
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.normalized_coords = 1
ctx.set_fragment_sampler(0, sampler)
# scissor
scissor = Scissor()
scissor.minx = 0
scissor.miny = 0
scissor.maxx = width
scissor.maxy = height
ctx.set_scissor(scissor)
clip = Clip()
clip.nr = 0
ctx.set_clip(clip)
# framebuffer
cbuf = dev.resource_create(
PIPE_FORMAT_B8G8R8X8_UNORM,
width, height,
bind=PIPE_BIND_RENDER_TARGET,
).get_surface()
fb = Framebuffer()
fb.width = width
fb.height = height
fb.nr_cbufs = 1
fb.set_cbuf(0, cbuf)
ctx.set_framebuffer(fb)
rgba = FloatArray(4);
rgba[0] = 0.5
rgba[1] = 0.5
rgba[2] = 0.5
rgba[3] = 0.5
ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
# vertex shader
vs = Shader('''
VERT
DCL IN[0], POSITION
DCL IN[1], COLOR
DCL OUT[0], POSITION
DCL OUT[1], COLOR
MOV OUT[0], IN[0]
MOV OUT[1], IN[1]
END
''')
ctx.set_vertex_shader(vs)
# fragment shader
fs = Shader(file('frag-' + name + '.sh', 'rt').read())
ctx.set_fragment_shader(fs)
constbuf0 = dev.buffer_create(64,
(PIPE_BUFFER_USAGE_CONSTANT |
PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_CPU_WRITE),
4 * 4 * 4)
cbdata = ''
cbdata += struct.pack('4f', 0.4, 0.0, 0.0, 1.0)
cbdata += struct.pack('4f', 1.0, 1.0, 1.0, 1.0)
cbdata += struct.pack('4f', 2.0, 2.0, 2.0, 2.0)
cbdata += struct.pack('4f', 4.0, 8.0, 16.0, 32.0)
constbuf0.write(cbdata, 0)
ctx.set_constant_buffer(PIPE_SHADER_FRAGMENT,
0,
constbuf0)
constbuf1 = dev.buffer_create(64,
(PIPE_BUFFER_USAGE_CONSTANT |
PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_CPU_WRITE),
4 * 4 * 4)
cbdata = ''
cbdata += struct.pack('4f', 0.1, 0.1, 0.1, 0.1)
cbdata += struct.pack('4f', 0.25, 0.25, 0.25, 0.25)
cbdata += struct.pack('4f', 0.5, 0.5, 0.5, 0.5)
cbdata += struct.pack('4f', 0.75, 0.75, 0.75, 0.75)
constbuf1.write(cbdata, 0)
ctx.set_constant_buffer(PIPE_SHADER_FRAGMENT,
1,
constbuf1)
xy = [
-0.8, -0.8,
0.8, -0.8,
0.0, 0.8,
]
color = [
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
]
nverts = 3
nattrs = 2
verts = FloatArray(nverts * nattrs * 4)
for i in range(0, nverts):
verts[i * nattrs * 4 + 0] = xy[i * 2 + 0] # x
verts[i * nattrs * 4 + 1] = xy[i * 2 + 1] # y
verts[i * nattrs * 4 + 2] = 0.5 # z
verts[i * nattrs * 4 + 3] = 1.0 # w
verts[i * nattrs * 4 + 4] = color[i * 3 + 0] # r
verts[i * nattrs * 4 + 5] = color[i * 3 + 1] # g
verts[i * nattrs * 4 + 6] = color[i * 3 + 2] # b
verts[i * nattrs * 4 + 7] = 1.0 # a
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
nverts,
nattrs,
verts)
ctx.flush()
save_image('frag-' + name + '.png', cbuf)
def main():
tests = [
'abs',
'add',
'cb-1d',
'cb-2d',
'dp3',
'dp4',
'dst',
'ex2',
'flr',
'frc',
'lg2',
'lit',
'lrp',
'mad',
'max',
'min',
'mov',
'mul',
'rcp',
'rsq',
'sge',
'slt',
'srcmod-abs',
'srcmod-absneg',
'srcmod-neg',
'srcmod-swz',
'sub',
'xpd',
]
dev = Device()
for t in tests:
test(dev, t)
if __name__ == '__main__':
main()

1
src/gallium/tests/python/tests/regress/vertex-shader/.gitignore vendored
View File

@ -1 +0,0 @@
*.png

287
src/gallium/tests/python/tests/regress/vertex-shader/vertex-shader.py
View File

@ -1,287 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2009 VMware, 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 VMWARE 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.
#
##########################################################################
import struct
from gallium import *
def make_image(surface):
data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
import Image
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
return outimage
def save_image(filename, surface):
outimage = make_image(surface)
outimage.save(filename, "PNG")
def test(dev, name):
ctx = dev.context_create()
width = 320
height = 320
minz = 0.0
maxz = 1.0
# disabled blending/masking
blend = Blend()
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].colormask = PIPE_MASK_RGBA
ctx.set_blend(blend)
# depth/stencil/alpha
depth_stencil_alpha = DepthStencilAlpha()
depth_stencil_alpha.depth.enabled = 0
depth_stencil_alpha.depth.writemask = 1
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
# rasterizer
rasterizer = Rasterizer()
rasterizer.front_winding = PIPE_WINDING_CW
rasterizer.cull_mode = PIPE_WINDING_NONE
rasterizer.scissor = 1
ctx.set_rasterizer(rasterizer)
# viewport
viewport = Viewport()
scale = FloatArray(4)
scale[0] = width / 2.0
scale[1] = -height / 2.0
scale[2] = (maxz - minz) / 2.0
scale[3] = 1.0
viewport.scale = scale
translate = FloatArray(4)
translate[0] = width / 2.0
translate[1] = height / 2.0
translate[2] = (maxz - minz) / 2.0
translate[3] = 0.0
viewport.translate = translate
ctx.set_viewport(viewport)
# samplers
sampler = Sampler()
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.normalized_coords = 1
ctx.set_fragment_sampler(0, sampler)
# scissor
scissor = Scissor()
scissor.minx = 0
scissor.miny = 0
scissor.maxx = width
scissor.maxy = height
ctx.set_scissor(scissor)
clip = Clip()
clip.nr = 0
ctx.set_clip(clip)
# framebuffer
cbuf = dev.resource_create(
PIPE_FORMAT_B8G8R8X8_UNORM,
width, height,
bind=PIPE_BIND_RENDER_TARGET,
).get_surface()
fb = Framebuffer()
fb.width = width
fb.height = height
fb.nr_cbufs = 1
fb.set_cbuf(0, cbuf)
ctx.set_framebuffer(fb)
rgba = FloatArray(4);
rgba[0] = 0.5
rgba[1] = 0.5
rgba[2] = 0.5
rgba[3] = 0.5
ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
# vertex shader
vs = Shader(file('vert-' + name + '.sh', 'rt').read())
ctx.set_vertex_shader(vs)
# fragment shader
fs = Shader('''
FRAG
DCL IN[0], COLOR, LINEAR
DCL OUT[0], COLOR, CONSTANT
0:MOV OUT[0], IN[0]
1:END
''')
ctx.set_fragment_shader(fs)
constbuf0 = dev.buffer_create(64,
(PIPE_BUFFER_USAGE_CONSTANT |
PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_CPU_WRITE),
4 * 4 * 4)
cbdata = ''
cbdata += struct.pack('4f', 0.4, 0.0, 0.0, 1.0)
cbdata += struct.pack('4f', 1.0, 1.0, 1.0, 1.0)
cbdata += struct.pack('4f', 2.0, 2.0, 2.0, 2.0)
cbdata += struct.pack('4f', 4.0, 8.0, 16.0, 32.0)
constbuf0.write(cbdata, 0)
ctx.set_constant_buffer(PIPE_SHADER_VERTEX,
0,
constbuf0)
constbuf1 = dev.buffer_create(64,
(PIPE_BUFFER_USAGE_CONSTANT |
PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_CPU_WRITE),
4 * 4 * 4)
cbdata = ''
cbdata += struct.pack('4f', 0.1, 0.1, 0.1, 0.1)
cbdata += struct.pack('4f', 0.25, 0.25, 0.25, 0.25)
cbdata += struct.pack('4f', 0.5, 0.5, 0.5, 0.5)
cbdata += struct.pack('4f', 0.75, 0.75, 0.75, 0.75)
constbuf1.write(cbdata, 0)
ctx.set_constant_buffer(PIPE_SHADER_VERTEX,
1,
constbuf1)
xy = [
0.0, 0.8,
-0.2, 0.4,
0.2, 0.4,
-0.4, 0.0,
0.0, 0.0,
0.4, 0.0,
-0.6, -0.4,
-0.2, -0.4,
0.2, -0.4,
0.6, -0.4,
-0.8, -0.8,
-0.4, -0.8,
0.0, -0.8,
0.4, -0.8,
0.8, -0.8,
]
color = [
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
]
tri = [
1, 2, 0,
3, 4, 1,
4, 2, 1,
4, 5, 2,
6, 7, 3,
7, 4, 3,
7, 8, 4,
8, 5, 4,
8, 9, 5,
10, 11, 6,
11, 7, 6,
11, 12, 7,
12, 8, 7,
12, 13, 8,
13, 9, 8,
13, 14, 9,
]
nverts = 16 * 3
nattrs = 2
verts = FloatArray(nverts * nattrs * 4)
for i in range(0, nverts):
verts[i * nattrs * 4 + 0] = xy[tri[i] * 2 + 0] # x
verts[i * nattrs * 4 + 1] = xy[tri[i] * 2 + 1] # y
verts[i * nattrs * 4 + 2] = 0.5 # z
verts[i * nattrs * 4 + 3] = 1.0 # w
verts[i * nattrs * 4 + 4] = color[(i % 3) * 3 + 0] # r
verts[i * nattrs * 4 + 5] = color[(i % 3) * 3 + 1] # g
verts[i * nattrs * 4 + 6] = color[(i % 3) * 3 + 2] # b
verts[i * nattrs * 4 + 7] = 1.0 # a
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
nverts,
nattrs,
verts)
ctx.flush()
save_image('vert-' + name + '.png', cbuf)
def main():
tests = [
'abs',
'add',
'arl',
'arr',
'cb-1d',
'cb-2d',
'dp3',
'dp4',
'dst',
'ex2',
'flr',
'frc',
'lg2',
'lit',
'lrp',
'mad',
'max',
'min',
'mov',
'mul',
'rcp',
'rsq',
'sge',
'slt',
'srcmod-abs',
'srcmod-absneg',
'srcmod-neg',
'srcmod-swz',
'sub',
'xpd',
]
dev = Device()
for t in tests:
test(dev, t)
if __name__ == '__main__':
main()

320
src/gallium/tests/python/tests/texture_render.py
View File

@ -1,320 +0,0 @@
#!/usr/bin/env python
##########################################################################
#
# Copyright 2009 VMware, 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 VMWARE 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.
#
##########################################################################
from gallium import *
from base import *
def lods(*dims):
size = max(dims)
lods = 0
while size:
lods += 1
size >>= 1
return lods
class TextureTest(TestCase):
tags = (
'target',
'format',
'width',
'height',
'depth',
'last_level',
'face',
'level',
'zslice',
)
def test(self):
dev = self.dev
target = self.target
format = self.format
width = self.width
height = self.height
depth = self.depth
last_level = self.last_level
face = self.face
level = self.level
zslice = self.zslice
# textures
dst_texture = dev.resource_create(
target = target,
format = format,
width = width,
height = height,
depth = depth,
last_level = last_level,
bind = PIPE_BIND_RENDER_TARGET,
)
if dst_texture is None:
raise TestSkip
dst_surface = dst_texture.get_surface(face = face, level = level, zslice = zslice)
ref_texture = dev.resource_create(
target = target,
format = format,
width = dst_surface.width,
height = dst_surface.height,
depth = 1,
last_level = 0,
bind = PIPE_BIND_SAMPLER_VIEW,
)
ref_surface = ref_texture.get_surface()
src_texture = dev.resource_create(
target = target,
format = PIPE_FORMAT_B8G8R8A8_UNORM,
width = dst_surface.width,
height = dst_surface.height,
depth = 1,
last_level = 0,
bind = PIPE_BIND_SAMPLER_VIEW,
)
src_surface = src_texture.get_surface()
expected_rgba = FloatArray(height*width*4)
ref_surface.sample_rgba(expected_rgba)
src_surface.put_tile_rgba(0, 0, src_surface.width, src_surface.height, expected_rgba)
ctx = self.dev.context_create()
# disabled blending/masking
blend = Blend()
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
blend.rt[0].colormask = PIPE_MASK_RGBA
ctx.set_blend(blend)
# no-op depth/stencil/alpha
depth_stencil_alpha = DepthStencilAlpha()
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
# rasterizer
rasterizer = Rasterizer()
rasterizer.front_winding = PIPE_WINDING_CW
rasterizer.cull_mode = PIPE_WINDING_NONE
rasterizer.bypass_vs_clip_and_viewport = 1
ctx.set_rasterizer(rasterizer)
# samplers
sampler = Sampler()
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
sampler.normalized_coords = 1
sampler.min_lod = 0
sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
ctx.set_fragment_sampler(0, sampler)
ctx.set_fragment_sampler_texture(0, src_texture)
# framebuffer
cbuf_tex = dev.resource_create(
PIPE_FORMAT_B8G8R8A8_UNORM,
width,
height,
bind = PIPE_BIND_RENDER_TARGET,
)
fb = Framebuffer()
fb.width = dst_surface.width
fb.height = dst_surface.height
fb.nr_cbufs = 1
fb.set_cbuf(0, dst_surface)
ctx.set_framebuffer(fb)
rgba = FloatArray(4);
rgba[0] = 0.0
rgba[1] = 0.0
rgba[2] = 0.0
rgba[3] = 0.0
ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
del fb
# vertex shader
vs = Shader('''
VERT
DCL IN[0], POSITION, CONSTANT
DCL IN[1], GENERIC, CONSTANT
DCL OUT[0], POSITION, CONSTANT
DCL OUT[1], GENERIC, CONSTANT
0:MOV OUT[0], IN[0]
1:MOV OUT[1], IN[1]
2:END
''')
#vs.dump()
ctx.set_vertex_shader(vs)
# fragment shader
fs = Shader('''
FRAG
DCL IN[0], GENERIC[0], LINEAR
DCL OUT[0], COLOR, CONSTANT
DCL SAMP[0], CONSTANT
0:TEX OUT[0], IN[0], SAMP[0], 2D
1:END
''')
#fs.dump()
ctx.set_fragment_shader(fs)
nverts = 4
nattrs = 2
verts = FloatArray(nverts * nattrs * 4)
x = 0
y = 0
w = dst_surface.width
h = dst_surface.height
pos = [
[x, y],
[x+w, y],
[x+w, y+h],
[x, y+h],
]
tex = [
[0.0, 0.0],
[1.0, 0.0],
[1.0, 1.0],
[0.0, 1.0],
]
for i in range(0, 4):
j = 8*i
verts[j + 0] = pos[i][0] # x
verts[j + 1] = pos[i][1] # y
verts[j + 2] = 0.0 # z
verts[j + 3] = 1.0 # w
verts[j + 4] = tex[i][0] # s
verts[j + 5] = tex[i][1] # r
verts[j + 6] = 0.0
verts[j + 7] = 1.0
ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
nverts,
nattrs,
verts)
ctx.flush()
self.assert_rgba(dst_surface, x, y, w, h, expected_rgba, 4.0/256, 0.85)
def main():
dev = Device()
suite = TestSuite()
targets = [
PIPE_TEXTURE_2D,
PIPE_TEXTURE_CUBE,
#PIPE_TEXTURE_3D,
]
formats = [
PIPE_FORMAT_B8G8R8A8_UNORM,
PIPE_FORMAT_B8G8R8X8_UNORM,
#PIPE_FORMAT_B8G8R8A8_SRGB,
PIPE_FORMAT_B5G6R5_UNORM,
PIPE_FORMAT_B5G5R5A1_UNORM,
PIPE_FORMAT_B4G4R4A4_UNORM,
#PIPE_FORMAT_Z32_UNORM,
#PIPE_FORMAT_S8_USCALED_Z24_UNORM,
#PIPE_FORMAT_X8Z24_UNORM,
#PIPE_FORMAT_Z16_UNORM,
#PIPE_FORMAT_S8_USCALED,
PIPE_FORMAT_A8_UNORM,
PIPE_FORMAT_L8_UNORM,
#PIPE_FORMAT_DXT1_RGB,
#PIPE_FORMAT_DXT1_RGBA,
#PIPE_FORMAT_DXT3_RGBA,
#PIPE_FORMAT_DXT5_RGBA,
]
sizes = [64, 32, 16, 8, 4, 2, 1]
#sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
#sizes = [64]
#sizes = [63]
faces = [
PIPE_TEX_FACE_POS_X,
PIPE_TEX_FACE_NEG_X,
PIPE_TEX_FACE_POS_Y,
PIPE_TEX_FACE_NEG_Y,
PIPE_TEX_FACE_POS_Z,
PIPE_TEX_FACE_NEG_Z,
]
for target in targets:
for format in formats:
for size in sizes:
if target == PIPE_TEXTURE_3D:
depth = size
else:
depth = 1
for face in faces:
if target != PIPE_TEXTURE_CUBE and face:
continue
levels = lods(size)
for last_level in range(levels):
for level in range(0, last_level + 1):
zslice = 0
while zslice < depth >> level:
test = TextureTest(
dev = dev,
target = target,
format = format,
width = size,
height = size,
depth = depth,
last_level = last_level,
face = face,
level = level,
zslice = zslice,
)
suite.add_test(test)
zslice = (zslice + 1)*2 - 1
suite.run()
if __name__ == '__main__':
main()

23
src/gallium/tests/python/tests/tree.py
View File

@ -1,23 +0,0 @@
#!/usr/bin/env python
#
# See also:
# http://www.ailab.si/orange/doc/ofb/c_otherclass.htm
import os.path
import sys
import orange
import orngTree
for arg in sys.argv[1:]:
name, ext = os.path.splitext(arg)
data = orange.ExampleTable(arg)
tree = orngTree.TreeLearner(data, sameMajorityPruning=1, mForPruning=2)
orngTree.printTxt(tree)
file(name+'.txt', 'wt').write(orngTree.dumpTree(tree) + '\n')
orngTree.printDot(tree, fileName=name+'.dot', nodeShape='ellipse', leafShape='box')

3
src/gallium/tests/trivial/.gitignore vendored
View File

@ -1,3 +0,0 @@
tri
quad-tex
result.bmp

49
src/gallium/tests/trivial/Makefile
View File

@ -1,49 +0,0 @@
# progs/gallium/simple/Makefile
TOP = ../../../..
include $(TOP)/configs/current
INCLUDES = \
-I. \
-I$(TOP)/src/gallium/include \
-I$(TOP)/src/gallium/auxiliary \
-I$(TOP)/src/gallium/drivers \
-I$(TOP)/src/gallium/winsys \
$(PROG_INCLUDES)
LINKS = \
$(TOP)/src/gallium/drivers/rbug/librbug.a \
$(TOP)/src/gallium/drivers/trace/libtrace.a \
$(TOP)/src/gallium/drivers/galahad/libgalahad.a \
$(TOP)/src/gallium/winsys/sw/null/libws_null.a \
$(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
$(GALLIUM_AUXILIARIES) \
$(PROG_LINKS)
SOURCES = \
tri.c \
quad-tex.c
OBJECTS = $(SOURCES:.c=.o)
PROGS = $(OBJECTS:.o=)
PROG_DEFINES = \
-DGALLIUM_SOFTPIPE -DGALLIUM_RBUG -DGALLIUM_TRACE -DGALLIUM_GALAHAD
##### TARGETS #####
default: $(PROGS)
clean:
-rm -f $(PROGS)
-rm -f *.o
-rm -f result.bmp
##### RULES #####
$(OBJECTS): %.o: %.c
$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $(PROG_DEFINES) $< -o $@
$(PROGS): %: %.o $(LINKS)
$(CC) $(LDFLAGS) $< $(LINKS) -lm -lpthread -ldl -o $@

49
src/gallium/tests/unit/Makefile
View File

@ -1,49 +0,0 @@
# progs/gallium/simple/Makefile
TOP = ../../../..
include $(TOP)/configs/current
INCLUDES = \
-I. \
-I$(TOP)/src/gallium/include \
-I$(TOP)/src/gallium/auxiliary \
-I$(TOP)/src/gallium/drivers \
-I$(TOP)/src/gallium/winsys \
$(PROG_INCLUDES)
LINKS = \
$(TOP)/src/gallium/drivers/trace/libtrace.a \
$(TOP)/src/gallium/winsys/sw/null/libws_null.a \
$(TOP)/src/gallium/drivers/softpipe/libsoftpipe.a \
$(GALLIUM_AUXILIARIES) \
$(PROG_LINKS)
SOURCES = \
pipe_barrier_test.c \
u_cache_test.c \
u_half_test.c \
u_format_test.c \
u_format_compatible_test.c \
translate_test.c
OBJECTS = $(SOURCES:.c=.o)
PROGS = $(OBJECTS:.o=)
##### TARGETS #####
default: $(PROGS)
clean:
-rm -f $(PROGS)
-rm -f *.o
-rm -f result.bmp
##### RULES #####
$(OBJECTS): %.o: %.c
$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $(PROG_DEFINES) $< -o $@
$(PROGS): %: %.o
$(CC) $(LDFLAGS) $< $(LINKS) -lm -lpthread -ldl -o $@

33
src/gallium/tests/unit/SConscript
View File

@ -1,33 +0,0 @@
Import('*')
env = env.Clone()
env.Prepend(LIBS = [gallium])
if env['platform'] in ('freebsd8', 'sunos5'):
env.Append(LIBS = ['m'])
if env['platform'] == 'freebsd8':
env.Append(LIBS = ['pthread'])
progs = [
'pipe_barrier_test',
'u_cache_test',
'u_format_test',
'u_format_compatible_test',
'u_half_test',
'translate_test'
]
for prog in progs:
prog = env.Program(
target = prog,
source = prog + '.c',
)
env.InstallProgram(prog)
# http://www.scons.org/wiki/UnitTests
test_alias = env.Alias('unit', [prog], prog[0].abspath)
AlwaysBuild(test_alias)

121
src/gallium/tests/unit/u_cache_test.c
View File

@ -1,121 +0,0 @@
/**************************************************************************
*
* Copyright 2010 VMware, 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 VMWARE 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.
*
**************************************************************************/
/*
* Test case for u_cache.
*/
#include <assert.h>
#include <stdio.h>
#include "util/u_cache.h"
#include "util/u_hash.h"
typedef uint32_t cache_test_key;
typedef uint32_t cache_test_value;
static uint32_t
cache_test_hash(const void *key)
{
return util_hash_crc32(key, sizeof(cache_test_key));
}
static void
cache_test_destroy(void *key, void *value)
{
free(key);
free(value);
}
static int
cache_test_compare(const void *key1, const void *key2) {
return !(key1 == key2);
}
int main() {
unsigned cache_size;
unsigned cache_count;
for (cache_size = 2; cache_size < (1 << 15); cache_size *= 2) {
for (cache_count = (cache_size << 5); cache_count < (cache_size << 10); cache_count *= 2) {
struct util_cache * cache;
cache_test_key *key;
cache_test_value *value_in;
cache_test_value *value_out;
int i;
printf("Testing cache size of %d with %d values.\n", cache_size, cache_count);
cache = util_cache_create(cache_test_hash,
cache_test_compare,
cache_test_destroy,
cache_size);
/*
* Retrieve a value from an empty cache.
*/
key = malloc(sizeof(cache_test_key));
*key = 0xdeadbeef;
value_out = (cache_test_value *) util_cache_get(cache, key);
assert(value_out == NULL);
free(key);
/*
* Repeatedly insert into and retrieve values from the cache.
*/
for (i = 0; i < cache_count; i++) {
key = malloc(sizeof(cache_test_key));
value_in = malloc(sizeof(cache_test_value));
*key = rand();
*value_in = rand();
util_cache_set(cache, key, value_in);
value_out = util_cache_get(cache, key);
assert(value_out != NULL);
assert(value_in == value_out);
assert(*value_in == *value_out);
}
/*
* In debug builds, this will trigger a self-check by the cache of
* the distribution of hits in its internal cache entries.
*/
util_cache_destroy(cache);
}
}
return 0;
}

716
src/gallium/tests/unit/u_format_test.c
View File

@ -1,716 +0,0 @@
/**************************************************************************
*
* Copyright 2009-2010 VMware, 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 VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include "util/u_half.h"
#include "util/u_format.h"
#include "util/u_format_tests.h"
#include "util/u_format_s3tc.h"
static boolean
compare_float(float x, float y)
{
float error = y - x;
if (error < 0.0f)
error = -error;
if (error > FLT_EPSILON) {
return FALSE;
}
return TRUE;
}
static void
print_packed(const struct util_format_description *format_desc,
const char *prefix,
const uint8_t *packed,
const char *suffix)
{
unsigned i;
const char *sep = "";
printf("%s", prefix);
for (i = 0; i < format_desc->block.bits/8; ++i) {
printf("%s%02x", sep, packed[i]);
sep = " ";
}
printf("%s", suffix);
fflush(stdout);
}
static void
print_unpacked_rgba_doubl(const struct util_format_description *format_desc,
const char *prefix,
const double unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
const char *suffix)
{
unsigned i, j;
const char *sep = "";
printf("%s", prefix);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
sep = ", ";
}
sep = ",\n";
}
printf("%s", suffix);
fflush(stdout);
}
static void
print_unpacked_rgba_float(const struct util_format_description *format_desc,
const char *prefix,
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
const char *suffix)
{
unsigned i, j;
const char *sep = "";
printf("%s", prefix);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
sep = ", ";
}
sep = ",\n";
}
printf("%s", suffix);
fflush(stdout);
}
static void
print_unpacked_rgba_8unorm(const struct util_format_description *format_desc,
const char *prefix,
uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
const char *suffix)
{
unsigned i, j;
const char *sep = "";
printf("%s", prefix);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
printf("%s{0x%02x, 0x%02x, 0x%02x, 0x%02x}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
sep = ", ";
}
}
printf("%s", suffix);
fflush(stdout);
}
static void
print_unpacked_z_float(const struct util_format_description *format_desc,
const char *prefix,
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
const char *suffix)
{
unsigned i, j;
const char *sep = "";
printf("%s", prefix);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
printf("%s%f", sep, unpacked[i][j]);
sep = ", ";
}
sep = ",\n";
}
printf("%s", suffix);
fflush(stdout);
}
static void
print_unpacked_z_32unorm(const struct util_format_description *format_desc,
const char *prefix,
uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
const char *suffix)
{
unsigned i, j;
const char *sep = "";
printf("%s", prefix);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
printf("%s0x%08x", sep, unpacked[i][j]);
sep = ", ";
}
}
printf("%s", suffix);
fflush(stdout);
}
static void
print_unpacked_s_8uscaled(const struct util_format_description *format_desc,
const char *prefix,
uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
const char *suffix)
{
unsigned i, j;
const char *sep = "";
printf("%s", prefix);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
printf("%s0x%02x", sep, unpacked[i][j]);
sep = ", ";
}
}
printf("%s", suffix);
fflush(stdout);
}
static boolean
test_format_fetch_rgba_float(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
unsigned i, j, k;
boolean success;
success = TRUE;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
format_desc->fetch_rgba_float(unpacked[i][j], test->packed, j, i);
for (k = 0; k < 4; ++k) {
if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
success = FALSE;
}
}
}
}
if (!success) {
print_unpacked_rgba_float(format_desc, "FAILED: ", unpacked, " obtained\n");
print_unpacked_rgba_doubl(format_desc, " ", test->unpacked, " expected\n");
}
return success;
}
static boolean
test_format_unpack_rgba_float(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
unsigned i, j, k;
boolean success;
format_desc->unpack_rgba_float(&unpacked[0][0][0], sizeof unpacked[0],
test->packed, 0,
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
for (k = 0; k < 4; ++k) {
if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
success = FALSE;
}
}
}
}
if (!success) {
print_unpacked_rgba_float(format_desc, "FAILED: ", unpacked, " obtained\n");
print_unpacked_rgba_doubl(format_desc, " ", test->unpacked, " expected\n");
}
return success;
}
static boolean
test_format_pack_rgba_float(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
unsigned i, j, k;
boolean success;
if (test->format == PIPE_FORMAT_DXT1_RGBA) {
/*
* Skip S3TC as packed representation is not canonical.
*
* TODO: Do a round trip conversion.
*/
return TRUE;
}
memset(packed, 0, sizeof packed);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
for (k = 0; k < 4; ++k) {
unpacked[i][j][k] = (float) test->unpacked[i][j][k];
}
}
}
format_desc->pack_rgba_float(packed, 0,
&unpacked[0][0][0], sizeof unpacked[0],
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.bits/8; ++i)
if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
success = FALSE;
if (!success) {
print_packed(format_desc, "FAILED: ", packed, " obtained\n");
print_packed(format_desc, " ", test->packed, " expected\n");
}
return success;
}
static boolean
convert_float_to_8unorm(uint8_t *dst, const double *src)
{
unsigned i;
boolean accurate = TRUE;
for (i = 0; i < UTIL_FORMAT_MAX_UNPACKED_HEIGHT*UTIL_FORMAT_MAX_UNPACKED_WIDTH*4; ++i) {
if (src[i] < 0.0) {
accurate = FALSE;
dst[i] = 0;
}
else if (src[i] > 1.0) {
accurate = FALSE;
dst[i] = 255;
}
else {
dst[i] = src[i] * 255.0;
}
}
return accurate;
}
static boolean
test_format_unpack_rgba_8unorm(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
unsigned i, j, k;
boolean success;
format_desc->unpack_rgba_8unorm(&unpacked[0][0][0], sizeof unpacked[0],
test->packed, 0,
format_desc->block.width, format_desc->block.height);
convert_float_to_8unorm(&expected[0][0][0], &test->unpacked[0][0][0]);
success = TRUE;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
for (k = 0; k < 4; ++k) {
if (expected[i][j][k] != unpacked[i][j][k]) {
success = FALSE;
}
}
}
}
if (!success) {
print_unpacked_rgba_8unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
print_unpacked_rgba_8unorm(format_desc, " ", expected, " expected\n");
}
return success;
}
static boolean
test_format_pack_rgba_8unorm(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
unsigned i;
boolean success;
if (test->format == PIPE_FORMAT_DXT1_RGBA) {
/*
* Skip S3TC as packed representation is not canonical.
*
* TODO: Do a round trip conversion.
*/
return TRUE;
}
if (!convert_float_to_8unorm(&unpacked[0][0][0], &test->unpacked[0][0][0])) {
/*
* Skip test cases which cannot be represented by four unorm bytes.
*/
return TRUE;
}
memset(packed, 0, sizeof packed);
format_desc->pack_rgba_8unorm(packed, 0,
&unpacked[0][0][0], sizeof unpacked[0],
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.bits/8; ++i)
if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
success = FALSE;
if (!success) {
print_packed(format_desc, "FAILED: ", packed, " obtained\n");
print_packed(format_desc, " ", test->packed, " expected\n");
}
return success;
}
static boolean
test_format_unpack_z_float(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
unsigned i, j;
boolean success;
format_desc->unpack_z_float(&unpacked[0][0], sizeof unpacked[0],
test->packed, 0,
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
if (!compare_float(test->unpacked[i][j][0], unpacked[i][j])) {
success = FALSE;
}
}
}
if (!success) {
print_unpacked_z_float(format_desc, "FAILED: ", unpacked, " obtained\n");
print_unpacked_rgba_doubl(format_desc, " ", test->unpacked, " expected\n");
}
return success;
}
static boolean
test_format_pack_z_float(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
unsigned i, j;
boolean success;
memset(packed, 0, sizeof packed);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
unpacked[i][j] = (float) test->unpacked[i][j][0];
if (test->unpacked[i][j][1]) {
return TRUE;
}
}
}
format_desc->pack_z_float(packed, 0,
&unpacked[0][0], sizeof unpacked[0],
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.bits/8; ++i)
if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
success = FALSE;
if (!success) {
print_packed(format_desc, "FAILED: ", packed, " obtained\n");
print_packed(format_desc, " ", test->packed, " expected\n");
}
return success;
}
static boolean
test_format_unpack_z_32unorm(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
uint32_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
unsigned i, j;
boolean success;
format_desc->unpack_z_32unorm(&unpacked[0][0], sizeof unpacked[0],
test->packed, 0,
format_desc->block.width, format_desc->block.height);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
expected[i][j] = test->unpacked[i][j][0] * 0xffffffff;
}
}
success = TRUE;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
if (expected[i][j] != unpacked[i][j]) {
success = FALSE;
}
}
}
if (!success) {
print_unpacked_z_32unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
print_unpacked_z_32unorm(format_desc, " ", expected, " expected\n");
}
return success;
}
static boolean
test_format_pack_z_32unorm(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
unsigned i, j;
boolean success;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
unpacked[i][j] = test->unpacked[i][j][0] * 0xffffffff;
if (test->unpacked[i][j][1]) {
return TRUE;
}
}
}
memset(packed, 0, sizeof packed);
format_desc->pack_z_32unorm(packed, 0,
&unpacked[0][0], sizeof unpacked[0],
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.bits/8; ++i)
if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
success = FALSE;
if (!success) {
print_packed(format_desc, "FAILED: ", packed, " obtained\n");
print_packed(format_desc, " ", test->packed, " expected\n");
}
return success;
}
static boolean
test_format_unpack_s_8uscaled(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
unsigned i, j;
boolean success;
format_desc->unpack_s_8uscaled(&unpacked[0][0], sizeof unpacked[0],
test->packed, 0,
format_desc->block.width, format_desc->block.height);
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
expected[i][j] = test->unpacked[i][j][1];
}
}
success = TRUE;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
if (expected[i][j] != unpacked[i][j]) {
success = FALSE;
}
}
}
if (!success) {
print_unpacked_s_8uscaled(format_desc, "FAILED: ", unpacked, " obtained\n");
print_unpacked_s_8uscaled(format_desc, " ", expected, " expected\n");
}
return success;
}
static boolean
test_format_pack_s_8uscaled(const struct util_format_description *format_desc,
const struct util_format_test_case *test)
{
uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
unsigned i, j;
boolean success;
for (i = 0; i < format_desc->block.height; ++i) {
for (j = 0; j < format_desc->block.width; ++j) {
unpacked[i][j] = test->unpacked[i][j][1];
if (test->unpacked[i][j][0]) {
return TRUE;
}
}
}
memset(packed, 0, sizeof packed);
format_desc->pack_s_8uscaled(packed, 0,
&unpacked[0][0], sizeof unpacked[0],
format_desc->block.width, format_desc->block.height);
success = TRUE;
for (i = 0; i < format_desc->block.bits/8; ++i)
if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
success = FALSE;
if (!success) {
print_packed(format_desc, "FAILED: ", packed, " obtained\n");
print_packed(format_desc, " ", test->packed, " expected\n");
}
return success;
}
typedef boolean
(*test_func_t)(const struct util_format_description *format_desc,
const struct util_format_test_case *test);
static boolean
test_one_func(const struct util_format_description *format_desc,
test_func_t func,
const char *suffix)
{
unsigned i;
bool success = TRUE;
printf("Testing util_format_%s_%s ...\n",
format_desc->short_name, suffix);
fflush(stdout);
for (i = 0; i < util_format_nr_test_cases; ++i) {
const struct util_format_test_case *test = &util_format_test_cases[i];
if (test->format == format_desc->format) {
if (!func(format_desc, &util_format_test_cases[i])) {
success = FALSE;
}
}
}
return success;
}
static boolean
test_all(void)
{
enum pipe_format format;
bool success = TRUE;
for (format = 1; format < PIPE_FORMAT_COUNT; ++format) {
const struct util_format_description *format_desc;
format_desc = util_format_description(format);
if (!format_desc) {
continue;
}
if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC &&
!util_format_s3tc_enabled) {
continue;
}
# define TEST_ONE_FUNC(name) \
if (format_desc->name) { \
if (!test_one_func(format_desc, &test_format_##name, #name)) { \
success = FALSE; \
} \
}
TEST_ONE_FUNC(fetch_rgba_float);
TEST_ONE_FUNC(pack_rgba_float);
TEST_ONE_FUNC(unpack_rgba_float);
TEST_ONE_FUNC(pack_rgba_8unorm);
TEST_ONE_FUNC(unpack_rgba_8unorm);
TEST_ONE_FUNC(unpack_z_32unorm);
TEST_ONE_FUNC(pack_z_32unorm);
TEST_ONE_FUNC(unpack_z_float);
TEST_ONE_FUNC(pack_z_float);
TEST_ONE_FUNC(unpack_s_8uscaled);
TEST_ONE_FUNC(pack_s_8uscaled);
# undef TEST_ONE_FUNC
}
return success;
}
int main(int argc, char **argv)
{
boolean success;
util_format_s3tc_init();
success = test_all();
return success ? 0 : 1;
}

32
src/gallium/tests/unit/u_half_test.c
View File

@ -1,32 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include "util/u_math.h"
#include "util/u_half.h"
int
main(int argc, char **argv)
{
unsigned i;
unsigned roundtrip_fails = 0;
for(i = 0; i < 1 << 16; ++i)
{
uint16_t h = (uint16_t) i;
union fi f;
uint16_t rh;
f.ui = util_half_to_floatui(h);
rh = util_floatui_to_half(f.ui);
if(h != rh)
{
printf("Roundtrip failed: %x -> %x = %f -> %x\n", h, f.ui, f.f, rh);
++roundtrip_fails;
}
}
if(roundtrip_fails)
printf("Failure! %u/65536 half floats failed a conversion to float and back.\n", roundtrip_fails);
else
printf("Success!\n");
return 0;
}