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

st/xorg: Delete. 

Acked-by: Lucas Stach <l.stach@pengutronix.de>
This commit is contained in:
Matt Turner 2013-10-26 17:25:11 -07:00
parent 48f4f59dc6
commit 69b425efae
23 changed files with 11 additions and 7125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
configure.ac
View File

@ -35,8 +35,6 @@ LIBDRM_NOUVEAU_REQUIRED="2.4.33 libdrm >= 2.4.41"
LIBDRM_FREEDRENO_REQUIRED=2.4.39
DRI2PROTO_REQUIRED=2.6
GLPROTO_REQUIRED=1.4.14
LIBDRM_XORG_REQUIRED=2.4.24
LIBKMS_XORG_REQUIRED=1.0.0
dnl Check for progs
AC_PROG_CPP
@ -556,11 +554,6 @@ AC_ARG_ENABLE([egl],
[enable_egl="$enableval"],
[enable_egl=yes])
AC_ARG_ENABLE([xorg],
[AS_HELP_STRING([--enable-xorg],
[enable support for X.Org DDX API @<:@default=no@:>@])],
[enable_xorg="$enableval"],
[enable_xorg=no])
AC_ARG_ENABLE([xa],
[AS_HELP_STRING([--enable-xa],
[enable build of the XA X Acceleration API @<:@default=no@:>@])],
@ -651,7 +644,6 @@ if test "x$enable_opengl" = xno -a \
"x$enable_gles1" = xno -a \
"x$enable_gles2" = xno -a \
"x$enable_openvg" = xno -a \
"x$enable_xorg" = xno -a \
"x$enable_xa" = xno -a \
"x$enable_xvmc" = xno -a \
"x$enable_vdpau" = xno -a \
@ -1235,20 +1227,6 @@ if test "x$enable_gallium_gbm" = xyes; then
fi
AM_CONDITIONAL(HAVE_GALLIUM_GBM, test "x$enable_gallium_gbm" = xyes)
dnl
dnl X.Org DDX configuration
dnl
if test "x$enable_xorg" = xyes; then
PKG_CHECK_MODULES([XORG], [xorg-server >= 1.6.0])
PKG_CHECK_MODULES([LIBDRM_XORG], [libdrm >= $LIBDRM_XORG_REQUIRED])
PKG_CHECK_MODULES([LIBKMS_XORG], [libkms >= $LIBKMS_XORG_REQUIRED])
PKG_CHECK_MODULES(XEXT, [xextproto >= 7.0.99.1],
HAVE_XEXTPROTO_71="yes"; DEFINES="$DEFINES -DHAVE_XEXTPROTO_71",
HAVE_XEXTPROTO_71="no")
GALLIUM_STATE_TRACKERS_DIRS="xorg $GALLIUM_STATE_TRACKERS_DIRS"
fi
AM_CONDITIONAL(HAVE_ST_XORG, test "x$enable_xorg" = xyes)
dnl
dnl XA configuration
dnl
@ -1487,13 +1465,6 @@ AC_ARG_WITH([egl-driver-dir],
[EGL_DRIVER_INSTALL_DIR='${libdir}/egl'])
AC_SUBST([EGL_DRIVER_INSTALL_DIR])
AC_ARG_WITH([xorg-driver-dir],
[AS_HELP_STRING([--with-xorg-driver-dir=DIR],
[Default xorg driver directory[[default=${libdir}/xorg/modules/drivers]]])],
[XORG_DRIVER_INSTALL_DIR="$withval"],
[XORG_DRIVER_INSTALL_DIR="${libdir}/xorg/modules/drivers"])
AC_SUBST([XORG_DRIVER_INSTALL_DIR])
AC_ARG_WITH([max-width],
[AS_HELP_STRING([--with-max-width=N],
[Maximum framebuffer width (4096)])],
@ -1675,18 +1646,15 @@ gallium_check_st() {
if test "x$enable_dri" = xyes && test "x$2" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $2"
fi
if test "x$enable_xorg" = xyes && test "x$3" != x; then
if test "x$enable_xa" = xyes && test "x$3" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $3"
fi
if test "x$enable_xa" = xyes && test "x$4" != x; then
if test "x$enable_xvmc" = xyes && test "x$4" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $4"
fi
if test "x$enable_xvmc" = xyes && test "x$5" != x; then
if test "x$enable_vdpau" = xyes && test "x$5" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $5"
fi
if test "x$enable_vdpau" = xyes && test "x$6" != x; then
GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS $6"
fi
}
gallium_require_llvm() {
@ -1726,9 +1694,8 @@ radeon_llvm_check() {
}
dnl Gallium drivers
if test "x$enable_dri" = xyes -o "x$enable_xorg" = xyes -o \
"x$enable_xa" = xyes -o "x$enable_xvmc" = xyes -o \
"x$enable_vdpau" = xyes; then
if test "x$enable_dri" = xyes -o "x$enable_xa" = xyes -o \
"x$enable_xvmc" = xyes -o "x$enable_vdpau" = xyes; then
NEED_NONNULL_WINSYS=yes
fi
AM_CONDITIONAL(NEED_NONNULL_WINSYS, test "x$NEED_NONNULL_WINSYS" = xyes)
@ -1741,7 +1708,7 @@ if test "x$with_gallium_drivers" != x; then
xsvga)
HAVE_GALLIUM_SVGA=yes
GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS svga softpipe"
gallium_check_st "svga/drm" "dri-vmwgfx" "" "xa-vmwgfx"
gallium_check_st "svga/drm" "dri-vmwgfx" "xa-vmwgfx"
;;
xi915)
HAVE_GALLIUM_I915=yes
@ -1767,7 +1734,7 @@ if test "x$with_gallium_drivers" != x; then
PKG_CHECK_MODULES([RADEON], [libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])
gallium_require_llvm "Gallium R300"
GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS r300"
gallium_check_st "radeon/drm" "r300/dri" "" "" "" ""
gallium_check_st "radeon/drm" "r300/dri" "" "" ""
DRICOMMON_NEED_LIBDRM=yes
;;
xr600)
@ -1785,7 +1752,7 @@ if test "x$with_gallium_drivers" != x; then
if test "x$enable_opencl" = xyes; then
LLVM_COMPONENTS="${LLVM_COMPONENTS} bitreader asmparser"
fi
gallium_check_st "radeon/drm" "r600/dri" "" "" "r600/xvmc" "r600/vdpau"
gallium_check_st "radeon/drm" "r600/dri" "" "r600/xvmc" "r600/vdpau"
DRICOMMON_NEED_LIBDRM=yes
;;
xradeonsi)
@ -1794,7 +1761,7 @@ if test "x$with_gallium_drivers" != x; then
gallium_require_drm_loader
GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS radeonsi"
radeon_llvm_check
gallium_check_st "radeon/drm" "radeonsi/dri" "" "" "" "radeonsi/vdpau" ""
gallium_check_st "radeon/drm" "radeonsi/dri" "" "" "radeonsi/vdpau"
DRICOMMON_NEED_LIBDRM=yes
;;
xnouveau)
@ -1802,7 +1769,7 @@ if test "x$with_gallium_drivers" != x; then
PKG_CHECK_MODULES([NOUVEAU], [libdrm_nouveau >= $LIBDRM_NOUVEAU_REQUIRED])
gallium_require_drm_loader
GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS nouveau"
gallium_check_st "nouveau/drm" "dri-nouveau" "" "" "xvmc-nouveau" "vdpau-nouveau"
gallium_check_st "nouveau/drm" "dri-nouveau" "" "xvmc-nouveau" "vdpau-nouveau"
DRICOMMON_NEED_LIBDRM=yes
;;
xfreedreno)
@ -1810,7 +1777,7 @@ if test "x$with_gallium_drivers" != x; then
PKG_CHECK_MODULES([FREEDRENO], [libdrm_freedreno >= $LIBDRM_FREEDRENO_REQUIRED])
gallium_require_drm_loader
GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS freedreno"
gallium_check_st "freedreno/drm" "dri-freedreno" "" "" "" ""
gallium_check_st "freedreno/drm" "dri-freedreno" "" "" ""
DRICOMMON_NEED_LIBDRM=yes
;;
xswrast)
@ -2013,7 +1980,6 @@ AC_CONFIG_FILES([Makefile
src/gallium/state_trackers/vdpau/Makefile
src/gallium/state_trackers/vega/Makefile
src/gallium/state_trackers/xa/Makefile
src/gallium/state_trackers/xorg/Makefile
src/gallium/state_trackers/xvmc/Makefile
src/gallium/targets/Makefile
src/gallium/targets/dri-freedreno/Makefile

3
src/gallium/SConscript
View File

@ -45,9 +45,6 @@ if not env['embedded']:
if env['dri']:
SConscript('state_trackers/dri/SConscript')
if env['dri'] and env['xorg']:
SConscript('state_trackers/xorg/SConscript')
if env['platform'] == 'windows':
SConscript('state_trackers/wgl/SConscript')

4
src/gallium/state_trackers/Makefile.am
View File

@ -41,10 +41,6 @@ if HAVE_GALLIUM_GBM
SUBDIRS += gbm
endif
if HAVE_ST_XORG
SUBDIRS += xorg
endif
if HAVE_ST_XA
SUBDIRS += xa
endif

43
src/gallium/state_trackers/xorg/Makefile.am
View File

@ -1,43 +0,0 @@
# Copyright © 2012 Intel Corporation
#
# 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, sublicense,
# 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
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS 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 Makefile.sources
include $(top_srcdir)/src/gallium/Automake.inc
AM_CFLAGS = \
$(GALLIUM_CFLAGS) \
$(XEXT_CFLAGS) \
$(LIBKMS_XORG_CFLAGS) \
$(LIBDRM_XORG_CFLAGS) \
$(shell $(PKG_CONFIG) --cflags-only-I xorg-server)
AM_CPPFLAGS = \
-I$(top_srcdir)/include \
-I$(top_srcdir)/src/mesa \
-I$(top_srcdir)/src/mesa/drivers/dri/common \
-I$(top_srcdir)/src/mesa/main \
-DHAVE_CONFIG_H \
-DHAVE_LIBKMS
noinst_LTLIBRARIES = libxorgtracker.la
libxorgtracker_la_SOURCES = $(C_SOURCES)

11
src/gallium/state_trackers/xorg/Makefile.sources
View File

@ -1,11 +0,0 @@
C_SOURCES := \
xorg_composite.c \
xorg_crtc.c \
xorg_dri2.c \
xorg_driver.c \
xorg_exa.c \
xorg_exa_tgsi.c \
xorg_output.c \
xorg_renderer.c \
xorg_xv.c \
xorg_xvmc.c

29
src/gallium/state_trackers/xorg/SConscript
View File

@ -1,29 +0,0 @@
#######################################################################
# SConscript for xorg state_tracker
Import('*')
env = env.Clone()
env.Append(CPPPATH = [
'#/src/mesa',
])
env.PkgUseModules(['DRM', 'XORG'])
if env['HAVE_KMS']:
env.Append(CPPDEFINES = ['HAVE_LIBKMS'])
env.PkgUseModules(['KMS'])
conf = env.Configure()
if conf.CheckHeader('X11/extensions/dpmsconst.h'):
env.Append(CPPDEFINES = [('HAVE_XEXTPROTO_71', '1')])
conf.Finish()
st_xorg = env.ConvenienceLibrary(
target = 'st_xorg',
source = env.ParseSourceList('Makefile.sources', 'C_SOURCES')
)
Export('st_xorg')

99
src/gallium/state_trackers/xorg/compat-api.h
View File

@ -1,99 +0,0 @@
/*
* Copyright 2012 Red Hat, Inc.
*
* 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, sublicense,
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS 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.
*
* Author: Dave Airlie <airlied@redhat.com>
*/
/* this file provides API compat between server post 1.13 and pre it,
it should be reused inside as many drivers as possible */
#ifndef COMPAT_API_H
#define COMPAT_API_H
#ifndef GLYPH_HAS_GLYPH_PICTURE_ACCESSOR
#define GetGlyphPicture(g, s) GlyphPicture((g))[(s)->myNum]
#define SetGlyphPicture(g, s, p) GlyphPicture((g))[(s)->myNum] = p
#endif
#ifndef XF86_HAS_SCRN_CONV
#define xf86ScreenToScrn(s) xf86Screens[(s)->myNum]
#define xf86ScrnToScreen(s) screenInfo.screens[(s)->scrnIndex]
#endif
#ifndef XF86_SCRN_INTERFACE
#define SCRN_ARG_TYPE int
#define SCRN_INFO_PTR(arg1) ScrnInfoPtr pScrn = xf86Screens[(arg1)]
#define SCREEN_ARG_TYPE int
#define SCREEN_PTR(arg1) ScreenPtr pScreen = screenInfo.screens[(arg1)]
#define SCREEN_INIT_ARGS_DECL int i, ScreenPtr pScreen, int argc, char **argv
#define BLOCKHANDLER_ARGS_DECL int arg, pointer blockData, pointer pTimeout, pointer pReadmask
#define BLOCKHANDLER_ARGS arg, blockData, pTimeout, pReadmask
#define CLOSE_SCREEN_ARGS_DECL int scrnIndex, ScreenPtr pScreen
#define CLOSE_SCREEN_ARGS scrnIndex, pScreen
#define ADJUST_FRAME_ARGS_DECL int arg, int x, int y, int flags
#define ADJUST_FRAME_ARGS(arg, x, y) (arg)->scrnIndex, x, y, 0
#define SWITCH_MODE_ARGS_DECL int arg, DisplayModePtr mode, int flags
#define SWITCH_MODE_ARGS(arg, m) (arg)->scrnIndex, m, 0
#define FREE_SCREEN_ARGS_DECL int arg, int flags
#define VT_FUNC_ARGS_DECL int arg, int flags
#define VT_FUNC_ARGS pScrn->scrnIndex, 0
#define XF86_SCRN_ARG(x) ((x)->scrnIndex)
#else
#define SCRN_ARG_TYPE ScrnInfoPtr
#define SCRN_INFO_PTR(arg1) ScrnInfoPtr pScrn = (arg1)
#define SCREEN_ARG_TYPE ScreenPtr
#define SCREEN_PTR(arg1) ScreenPtr pScreen = (arg1)
#define SCREEN_INIT_ARGS_DECL ScreenPtr pScreen, int argc, char **argv
#define BLOCKHANDLER_ARGS_DECL ScreenPtr arg, pointer pTimeout, pointer pReadmask
#define BLOCKHANDLER_ARGS arg, pTimeout, pReadmask
#define CLOSE_SCREEN_ARGS_DECL ScreenPtr pScreen
#define CLOSE_SCREEN_ARGS pScreen
#define ADJUST_FRAME_ARGS_DECL ScrnInfoPtr arg, int x, int y
#define ADJUST_FRAME_ARGS(arg, x, y) arg, x, y
#define SWITCH_MODE_ARGS_DECL ScrnInfoPtr arg, DisplayModePtr mode
#define SWITCH_MODE_ARGS(arg, m) arg, m
#define FREE_SCREEN_ARGS_DECL ScrnInfoPtr arg
#define VT_FUNC_ARGS_DECL ScrnInfoPtr arg
#define VT_FUNC_ARGS pScrn
#define XF86_SCRN_ARG(x) (x)
#endif
#endif

585
src/gallium/state_trackers/xorg/xorg_composite.c
View File

@ -1,585 +0,0 @@
#include "xorg_composite.h"
#include "xorg_renderer.h"
#include "xorg_exa_tgsi.h"
#include "cso_cache/cso_context.h"
#include "util/u_format.h"
#include "util/u_sampler.h"
/*XXX also in Xrender.h but the including it here breaks compilition */
#define XFixedToDouble(f) (((double) (f)) / 65536.)
struct xorg_composite_blend {
int op : 8;
unsigned alpha_dst : 4;
unsigned alpha_src : 4;
unsigned rgb_src : 8; /**< PIPE_BLENDFACTOR_x */
unsigned rgb_dst : 8; /**< PIPE_BLENDFACTOR_x */
};
#define BLEND_OP_OVER 3
static const struct xorg_composite_blend xorg_blends[] = {
{ PictOpClear,
0, 0, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_ZERO},
{ PictOpSrc,
0, 0, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ZERO},
{ PictOpDst,
0, 0, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_ONE},
{ PictOpOver,
0, 1, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
{ PictOpOverReverse,
1, 0, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_ONE},
{ PictOpIn,
1, 0, PIPE_BLENDFACTOR_DST_ALPHA, PIPE_BLENDFACTOR_ZERO},
{ PictOpInReverse,
0, 1, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_SRC_ALPHA},
{ PictOpOut,
1, 0, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_ZERO},
{ PictOpOutReverse,
0, 1, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
{ PictOpAtop,
1, 1, PIPE_BLENDFACTOR_DST_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
{ PictOpAtopReverse,
1, 1, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_SRC_ALPHA},
{ PictOpXor,
1, 1, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
{ PictOpAdd,
0, 0, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ONE},
};
static INLINE void
pixel_to_float4(Pixel pixel, float *color, enum pipe_format format)
{
const struct util_format_description *format_desc;
uint8_t packed[4];
format_desc = util_format_description(format);
packed[0] = pixel;
packed[1] = pixel >> 8;
packed[2] = pixel >> 16;
packed[3] = pixel >> 24;
format_desc->unpack_rgba_float(color, 0, packed, 0, 1, 1);
}
static boolean
blend_for_op(struct xorg_composite_blend *blend,
int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
PicturePtr pDstPicture)
{
const int num_blends =
sizeof(xorg_blends)/sizeof(struct xorg_composite_blend);
int i;
boolean supported = FALSE;
/* our default in case something goes wrong */
*blend = xorg_blends[BLEND_OP_OVER];
for (i = 0; i < num_blends; ++i) {
if (xorg_blends[i].op == op) {
*blend = xorg_blends[i];
supported = TRUE;
}
}
/* If there's no dst alpha channel, adjust the blend op so that we'll treat
* it as always 1. */
if (pDstPicture &&
PICT_FORMAT_A(pDstPicture->format) == 0 && blend->alpha_dst) {
if (blend->rgb_src == PIPE_BLENDFACTOR_DST_ALPHA)
blend->rgb_src = PIPE_BLENDFACTOR_ONE;
else if (blend->rgb_src == PIPE_BLENDFACTOR_INV_DST_ALPHA)
blend->rgb_src = PIPE_BLENDFACTOR_ZERO;
}
/* If the source alpha is being used, then we should only be in a case where
* the source blend factor is 0, and the source blend value is the mask
* channels multiplied by the source picture's alpha. */
if (pMaskPicture && pMaskPicture->componentAlpha &&
PICT_FORMAT_RGB(pMaskPicture->format) && blend->alpha_src) {
if (blend->rgb_dst == PIPE_BLENDFACTOR_SRC_ALPHA) {
blend->rgb_dst = PIPE_BLENDFACTOR_SRC_COLOR;
} else if (blend->rgb_dst == PIPE_BLENDFACTOR_INV_SRC_ALPHA) {
blend->rgb_dst = PIPE_BLENDFACTOR_INV_SRC_COLOR;
}
}
return supported;
}
static INLINE int
render_repeat_to_gallium(int mode)
{
switch(mode) {
case RepeatNone:
return PIPE_TEX_WRAP_CLAMP_TO_BORDER;
case RepeatNormal:
return PIPE_TEX_WRAP_REPEAT;
case RepeatReflect:
return PIPE_TEX_WRAP_MIRROR_REPEAT;
case RepeatPad:
return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
default:
debug_printf("Unsupported repeat mode\n");
}
return PIPE_TEX_WRAP_REPEAT;
}
static INLINE boolean
render_filter_to_gallium(int xrender_filter, int *out_filter)
{
switch (xrender_filter) {
case PictFilterNearest:
*out_filter = PIPE_TEX_FILTER_NEAREST;
break;
case PictFilterBilinear:
*out_filter = PIPE_TEX_FILTER_LINEAR;
break;
case PictFilterFast:
*out_filter = PIPE_TEX_FILTER_NEAREST;
break;
case PictFilterGood:
*out_filter = PIPE_TEX_FILTER_LINEAR;
break;
case PictFilterBest:
*out_filter = PIPE_TEX_FILTER_LINEAR;
break;
case PictFilterConvolution:
*out_filter = PIPE_TEX_FILTER_NEAREST;
return FALSE;
default:
debug_printf("Unknown xrender filter\n");
*out_filter = PIPE_TEX_FILTER_NEAREST;
return FALSE;
}
return TRUE;
}
static boolean is_filter_accelerated(PicturePtr pic)
{
int filter;
if (pic && !render_filter_to_gallium(pic->filter, &filter))
return FALSE;
return TRUE;
}
boolean xorg_composite_accelerated(int op,
PicturePtr pSrcPicture,
PicturePtr pMaskPicture,
PicturePtr pDstPicture)
{
ScreenPtr pScreen = pDstPicture->pDrawable->pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct xorg_composite_blend blend;
if (!is_filter_accelerated(pSrcPicture) ||
!is_filter_accelerated(pMaskPicture)) {
XORG_FALLBACK("Unsupported Xrender filter");
}
if (pSrcPicture->pSourcePict) {
if (pSrcPicture->pSourcePict->type != SourcePictTypeSolidFill)
XORG_FALLBACK("Gradients not enabled (haven't been well tested)");
}
if (blend_for_op(&blend, op,
pSrcPicture, pMaskPicture, pDstPicture)) {
/* Check for component alpha */
if (pMaskPicture && pMaskPicture->componentAlpha &&
PICT_FORMAT_RGB(pMaskPicture->format)) {
if (blend.alpha_src && blend.rgb_src != PIPE_BLENDFACTOR_ZERO) {
XORG_FALLBACK("Component alpha not supported with source "
"alpha and source value blending. (op=%d)",
op);
}
}
return TRUE;
}
XORG_FALLBACK("Unsupported composition operation = %d", op);
}
static void
bind_blend_state(struct exa_context *exa, int op,
PicturePtr pSrcPicture,
PicturePtr pMaskPicture,
PicturePtr pDstPicture)
{
struct xorg_composite_blend blend_opt;
struct pipe_blend_state blend;
blend_for_op(&blend_opt, op, pSrcPicture, pMaskPicture, pDstPicture);
memset(&blend, 0, sizeof(struct pipe_blend_state));
blend.rt[0].blend_enable = 1;
blend.rt[0].colormask = PIPE_MASK_RGBA;
blend.rt[0].rgb_src_factor = blend_opt.rgb_src;
blend.rt[0].alpha_src_factor = blend_opt.rgb_src;
blend.rt[0].rgb_dst_factor = blend_opt.rgb_dst;
blend.rt[0].alpha_dst_factor = blend_opt.rgb_dst;
cso_set_blend(exa->renderer->cso, &blend);
}
static unsigned
picture_format_fixups(struct exa_pixmap_priv *pSrc, PicturePtr pSrcPicture, boolean mask,
PicturePtr pDstPicture)
{
boolean set_alpha = FALSE;
boolean swizzle = FALSE;
unsigned ret = 0;
if (pSrc && pSrc->picture_format == pSrcPicture->format) {
if (pSrc->picture_format == PICT_a8) {
if (mask)
return FS_MASK_LUMINANCE;
else if (pDstPicture->format != PICT_a8) {
/* if both dst and src are luminance then
* we don't want to swizzle the alpha (X) of the
* source into W component of the dst because
* it will break our destination */
return FS_SRC_LUMINANCE;
}
}
return 0;
}
if (pSrc && pSrc->picture_format != PICT_a8r8g8b8) {
assert(!"can not handle formats");
return 0;
}
/* pSrc->picture_format == PICT_a8r8g8b8 */
switch (pSrcPicture->format) {
case PICT_x8b8g8r8:
case PICT_b8g8r8:
set_alpha = TRUE; /* fall trough */
case PICT_a8b8g8r8:
swizzle = TRUE;
break;
case PICT_x8r8g8b8:
case PICT_r8g8b8:
set_alpha = TRUE; /* fall through */
case PICT_a8r8g8b8:
break;
#ifdef PICT_TYPE_BGRA
case PICT_b8g8r8a8:
case PICT_b8g8r8x8:
case PICT_a2r10g10b10:
case PICT_x2r10g10b10:
case PICT_a2b10g10r10:
case PICT_x2b10g10r10:
#endif
default:
assert(!"can not handle formats");
return 0;
}
if (set_alpha)
ret |= mask ? FS_MASK_SET_ALPHA : FS_SRC_SET_ALPHA;
if (swizzle)
ret |= mask ? FS_MASK_SWIZZLE_RGB : FS_SRC_SWIZZLE_RGB;
return ret;
}
static void
bind_shaders(struct exa_context *exa, int op,
PicturePtr pSrcPicture, PicturePtr pMaskPicture, PicturePtr pDstPicture,
struct exa_pixmap_priv *pSrc, struct exa_pixmap_priv *pMask)
{
unsigned vs_traits = 0, fs_traits = 0;
struct xorg_shader shader;
exa->has_solid_color = FALSE;
if (pSrcPicture) {
if (pSrcPicture->repeatType == RepeatNone && pSrcPicture->transform)
fs_traits |= FS_SRC_REPEAT_NONE;
if (pSrcPicture->pSourcePict) {
if (pSrcPicture->pSourcePict->type == SourcePictTypeSolidFill) {
fs_traits |= FS_SOLID_FILL;
vs_traits |= VS_SOLID_FILL;
debug_assert(pSrcPicture->format == PICT_a8r8g8b8);
pixel_to_float4(pSrcPicture->pSourcePict->solidFill.color,
exa->solid_color, PIPE_FORMAT_B8G8R8A8_UNORM);
exa->has_solid_color = TRUE;
} else {
debug_assert("!gradients not supported");
}
} else {
fs_traits |= FS_COMPOSITE;
vs_traits |= VS_COMPOSITE;
}
fs_traits |= picture_format_fixups(pSrc, pSrcPicture, FALSE, pDstPicture);
}
if (pMaskPicture) {
vs_traits |= VS_MASK;
fs_traits |= FS_MASK;
if (pMaskPicture->repeatType == RepeatNone && pMaskPicture->transform)
fs_traits |= FS_MASK_REPEAT_NONE;
if (pMaskPicture->componentAlpha) {
struct xorg_composite_blend blend;
blend_for_op(&blend, op,
pSrcPicture, pMaskPicture, NULL);
if (blend.alpha_src) {
fs_traits |= FS_CA_SRCALPHA;
} else
fs_traits |= FS_CA_FULL;
}
fs_traits |= picture_format_fixups(pMask, pMaskPicture, TRUE, pDstPicture);
}
shader = xorg_shaders_get(exa->renderer->shaders, vs_traits, fs_traits);
cso_set_vertex_shader_handle(exa->renderer->cso, shader.vs);
cso_set_fragment_shader_handle(exa->renderer->cso, shader.fs);
}
static void
bind_samplers(struct exa_context *exa, int op,
PicturePtr pSrcPicture, PicturePtr pMaskPicture,
PicturePtr pDstPicture,
struct exa_pixmap_priv *pSrc,
struct exa_pixmap_priv *pMask,
struct exa_pixmap_priv *pDst)
{
struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS] = {0};
struct pipe_sampler_state src_sampler, mask_sampler;
struct pipe_sampler_view view_templ;
struct pipe_sampler_view *src_view;
struct pipe_context *pipe = exa->pipe;
exa->num_bound_samplers = 0;
memset(&src_sampler, 0, sizeof(struct pipe_sampler_state));
memset(&mask_sampler, 0, sizeof(struct pipe_sampler_state));
if (pSrcPicture && pSrc) {
if (exa->has_solid_color) {
debug_assert(!"solid color with textures");
samplers[0] = NULL;
pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL);
} else {
unsigned src_wrap = render_repeat_to_gallium(
pSrcPicture->repeatType);
int filter;
render_filter_to_gallium(pSrcPicture->filter, &filter);
src_sampler.wrap_s = src_wrap;
src_sampler.wrap_t = src_wrap;
src_sampler.min_img_filter = filter;
src_sampler.mag_img_filter = filter;
src_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
src_sampler.normalized_coords = 1;
samplers[0] = &src_sampler;
exa->num_bound_samplers = 1;
u_sampler_view_default_template(&view_templ,
pSrc->tex,
pSrc->tex->format);
src_view = pipe->create_sampler_view(pipe, pSrc->tex, &view_templ);
pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL);
exa->bound_sampler_views[0] = src_view;
}
}
if (pMaskPicture && pMask) {
unsigned mask_wrap = render_repeat_to_gallium(
pMaskPicture->repeatType);
int filter;
render_filter_to_gallium(pMaskPicture->filter, &filter);
mask_sampler.wrap_s = mask_wrap;
mask_sampler.wrap_t = mask_wrap;
mask_sampler.min_img_filter = filter;
mask_sampler.mag_img_filter = filter;
src_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
mask_sampler.normalized_coords = 1;
samplers[1] = &mask_sampler;
exa->num_bound_samplers = 2;
u_sampler_view_default_template(&view_templ,
pMask->tex,
pMask->tex->format);
src_view = pipe->create_sampler_view(pipe, pMask->tex, &view_templ);
pipe_sampler_view_reference(&exa->bound_sampler_views[1], NULL);
exa->bound_sampler_views[1] = src_view;
}
cso_set_samplers(exa->renderer->cso, PIPE_SHADER_FRAGMENT,
exa->num_bound_samplers,
(const struct pipe_sampler_state **)samplers);
cso_set_sampler_views(exa->renderer->cso, PIPE_SHADER_FRAGMENT,
exa->num_bound_samplers,
exa->bound_sampler_views);
}
static INLINE boolean matrix_from_pict_transform(PictTransform *trans, float *matrix)
{
if (!trans)
return FALSE;
matrix[0] = XFixedToDouble(trans->matrix[0][0]);
matrix[3] = XFixedToDouble(trans->matrix[0][1]);
matrix[6] = XFixedToDouble(trans->matrix[0][2]);
matrix[1] = XFixedToDouble(trans->matrix[1][0]);
matrix[4] = XFixedToDouble(trans->matrix[1][1]);
matrix[7] = XFixedToDouble(trans->matrix[1][2]);
matrix[2] = XFixedToDouble(trans->matrix[2][0]);
matrix[5] = XFixedToDouble(trans->matrix[2][1]);
matrix[8] = XFixedToDouble(trans->matrix[2][2]);
return TRUE;
}
static void
setup_transforms(struct exa_context *exa,
PicturePtr pSrcPicture, PicturePtr pMaskPicture)
{
PictTransform *src_t = NULL;
PictTransform *mask_t = NULL;
if (pSrcPicture)
src_t = pSrcPicture->transform;
if (pMaskPicture)
mask_t = pMaskPicture->transform;
exa->transform.has_src =
matrix_from_pict_transform(src_t, exa->transform.src);
exa->transform.has_mask =
matrix_from_pict_transform(mask_t, exa->transform.mask);
}
boolean xorg_composite_bind_state(struct exa_context *exa,
int op,
PicturePtr pSrcPicture,
PicturePtr pMaskPicture,
PicturePtr pDstPicture,
struct exa_pixmap_priv *pSrc,
struct exa_pixmap_priv *pMask,
struct exa_pixmap_priv *pDst)
{
struct pipe_surface *dst_surf = xorg_gpu_surface(exa->pipe, pDst);
renderer_bind_destination(exa->renderer, dst_surf,
pDst->width,
pDst->height);
bind_blend_state(exa, op, pSrcPicture, pMaskPicture, pDstPicture);
bind_shaders(exa, op, pSrcPicture, pMaskPicture, pDstPicture, pSrc, pMask);
bind_samplers(exa, op, pSrcPicture, pMaskPicture,
pDstPicture, pSrc, pMask, pDst);
setup_transforms(exa, pSrcPicture, pMaskPicture);
if (exa->num_bound_samplers == 0 ) { /* solid fill */
renderer_begin_solid(exa->renderer);
} else {
renderer_begin_textures(exa->renderer,
exa->num_bound_samplers);
}
pipe_surface_reference(&dst_surf, NULL);
return TRUE;
}
void xorg_composite(struct exa_context *exa,
struct exa_pixmap_priv *dst,
int srcX, int srcY, int maskX, int maskY,
int dstX, int dstY, int width, int height)
{
if (exa->num_bound_samplers == 0 ) { /* solid fill */
renderer_solid(exa->renderer,
dstX, dstY, dstX + width, dstY + height,
exa->solid_color);
} else {
int pos[6] = {srcX, srcY, maskX, maskY, dstX, dstY};
float *src_matrix = NULL;
float *mask_matrix = NULL;
if (exa->transform.has_src)
src_matrix = exa->transform.src;
if (exa->transform.has_mask)
mask_matrix = exa->transform.mask;
renderer_texture(exa->renderer,
pos, width, height,
exa->bound_sampler_views,
exa->num_bound_samplers,
src_matrix, mask_matrix);
}
}
boolean xorg_solid_bind_state(struct exa_context *exa,
struct exa_pixmap_priv *pixmap,
Pixel fg)
{
struct pipe_surface *dst_surf = xorg_gpu_surface(exa->pipe, pixmap);
unsigned vs_traits, fs_traits;
struct xorg_shader shader;
pixel_to_float4(fg, exa->solid_color, pixmap->tex->format);
exa->has_solid_color = TRUE;
#if 0
debug_printf("Color Pixel=(%d, %d, %d, %d), RGBA=(%f, %f, %f, %f)\n",
(fg >> 24) & 0xff, (fg >> 16) & 0xff,
(fg >> 8) & 0xff, (fg >> 0) & 0xff,
exa->solid_color[0], exa->solid_color[1],
exa->solid_color[2], exa->solid_color[3]);
#endif
vs_traits = VS_SOLID_FILL;
fs_traits = FS_SOLID_FILL;
renderer_bind_destination(exa->renderer, dst_surf,
pixmap->width, pixmap->height);
bind_blend_state(exa, PictOpSrc, NULL, NULL, NULL);
cso_set_samplers(exa->renderer->cso, PIPE_SHADER_FRAGMENT, 0, NULL);
cso_set_sampler_views(exa->renderer->cso, PIPE_SHADER_FRAGMENT, 0, NULL);
shader = xorg_shaders_get(exa->renderer->shaders, vs_traits, fs_traits);
cso_set_vertex_shader_handle(exa->renderer->cso, shader.vs);
cso_set_fragment_shader_handle(exa->renderer->cso, shader.fs);
renderer_begin_solid(exa->renderer);
pipe_surface_reference(&dst_surf, NULL);
return TRUE;
}
void xorg_solid(struct exa_context *exa,
struct exa_pixmap_priv *pixmap,
int x0, int y0, int x1, int y1)
{
renderer_solid(exa->renderer,
x0, y0, x1, y1, exa->solid_color);
}
void
xorg_composite_done(struct exa_context *exa)
{
renderer_draw_flush(exa->renderer);
exa->transform.has_src = FALSE;
exa->transform.has_mask = FALSE;
exa->has_solid_color = FALSE;
exa->num_bound_samplers = 0;
}

36
src/gallium/state_trackers/xorg/xorg_composite.h
View File

@ -1,36 +0,0 @@
#ifndef XORG_COMPOSITE_H
#define XORG_COMPOSITE_H
#include "xorg_exa.h"
boolean xorg_composite_accelerated(int op,
PicturePtr pSrcPicture,
PicturePtr pMaskPicture,
PicturePtr pDstPicture);
boolean xorg_composite_bind_state(struct exa_context *exa,
int op,
PicturePtr pSrcPicture,
PicturePtr pMaskPicture,
PicturePtr pDstPicture,
struct exa_pixmap_priv *pSrc,
struct exa_pixmap_priv *pMask,
struct exa_pixmap_priv *pDst);
void xorg_composite(struct exa_context *exa,
struct exa_pixmap_priv *dst,
int srcX, int srcY, int maskX, int maskY,
int dstX, int dstY, int width, int height);
boolean xorg_solid_bind_state(struct exa_context *exa,
struct exa_pixmap_priv *pixmap,
Pixel fg);
void xorg_solid(struct exa_context *exa,
struct exa_pixmap_priv *pixmap,
int x0, int y0, int x1, int y1);
void
xorg_composite_done(struct exa_context *exa);
#endif

448
src/gallium/state_trackers/xorg/xorg_crtc.c
View File

@ -1,448 +0,0 @@
/*
* 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.
*
*
* Author: Alan Hourihane <alanh@tungstengraphics.com>
* Author: Jakob Bornecrantz <wallbraker@gmail.com>
*
*/
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <math.h>
#include <stdint.h>
#include "xorg-server.h"
#include <xf86.h>
#include <xf86i2c.h>
#include <xf86Crtc.h>
#include <cursorstr.h>
#include "xorg_tracker.h"
#include "xf86Modes.h"
#ifdef HAVE_XEXTPROTO_71
#include <X11/extensions/dpmsconst.h>
#else
#define DPMS_SERVER
#include <X11/extensions/dpms.h>
#endif
#include "state_tracker/drm_driver.h"
#include "util/u_inlines.h"
#include "util/u_rect.h"
#include "util/u_surface.h"
#ifdef HAVE_LIBKMS
#include "libkms/libkms.h"
#endif
struct crtc_private
{
drmModeCrtcPtr drm_crtc;
/* hwcursor */
struct pipe_resource *cursor_tex;
struct kms_bo *cursor_bo;
unsigned cursor_handle;
};
static void
crtc_dpms(xf86CrtcPtr crtc, int mode)
{
/* ScrnInfoPtr pScrn = crtc->scrn; */
switch (mode) {
case DPMSModeOn:
case DPMSModeStandby:
case DPMSModeSuspend:
break;
case DPMSModeOff:
break;
}
}
static Bool
crtc_set_mode_major(xf86CrtcPtr crtc, DisplayModePtr mode,
Rotation rotation, int x, int y)
{
xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
modesettingPtr ms = modesettingPTR(crtc->scrn);
xf86OutputPtr output = NULL;
struct crtc_private *crtcp = crtc->driver_private;
drmModeCrtcPtr drm_crtc = crtcp->drm_crtc;
drmModeModeInfo drm_mode;
int i, ret;
unsigned int connector_id;
for (i = 0; i < config->num_output; output = NULL, i++) {
output = config->output[i];
if (output->crtc == crtc)
break;
}
if (!output)
return FALSE;
connector_id = xorg_output_get_id(output);
drm_mode.clock = mode->Clock;
drm_mode.hdisplay = mode->HDisplay;
drm_mode.hsync_start = mode->HSyncStart;
drm_mode.hsync_end = mode->HSyncEnd;
drm_mode.htotal = mode->HTotal;
drm_mode.vdisplay = mode->VDisplay;
drm_mode.vsync_start = mode->VSyncStart;
drm_mode.vsync_end = mode->VSyncEnd;
drm_mode.vtotal = mode->VTotal;
drm_mode.flags = mode->Flags;
drm_mode.hskew = mode->HSkew;
drm_mode.vscan = mode->VScan;
drm_mode.vrefresh = mode->VRefresh;
drm_mode.type = 0;
if (!mode->name)
xf86SetModeDefaultName(mode);
strncpy(drm_mode.name, mode->name, DRM_DISPLAY_MODE_LEN - 1);
drm_mode.name[DRM_DISPLAY_MODE_LEN - 1] = '\0';
ret = drmModeSetCrtc(ms->fd, drm_crtc->crtc_id, ms->fb_id, x, y,
&connector_id, 1, &drm_mode);
if (ret)
return FALSE;
/* Only set gamma when needed, to avoid unneeded delays. */
#if defined(XF86_CRTC_VERSION) && XF86_CRTC_VERSION >= 3
if (!crtc->active && crtc->version >= 3)
crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green,
crtc->gamma_blue, crtc->gamma_size);
crtc->active = TRUE;
#endif
crtc->x = x;
crtc->y = y;
crtc->mode = *mode;
crtc->rotation = rotation;
return TRUE;
}
static void
crtc_gamma_set(xf86CrtcPtr crtc, CARD16 * red, CARD16 * green, CARD16 * blue,
int size)
{
modesettingPtr ms = modesettingPTR(crtc->scrn);
struct crtc_private *crtcp = crtc->driver_private;
drmModeCrtcSetGamma(ms->fd, crtcp->drm_crtc->crtc_id, size, red, green, blue);
}
#if 0 /* Implement and enable to enable rotation and reflection. */
static void *
crtc_shadow_allocate(xf86CrtcPtr crtc, int width, int height)
{
/* ScrnInfoPtr pScrn = crtc->scrn; */
return NULL;
}
static PixmapPtr
crtc_shadow_create(xf86CrtcPtr crtc, void *data, int width, int height)
{
/* ScrnInfoPtr pScrn = crtc->scrn; */
return NULL;
}
static void
crtc_shadow_destroy(xf86CrtcPtr crtc, PixmapPtr rotate_pixmap, void *data)
{
/* ScrnInfoPtr pScrn = crtc->scrn; */
}
#endif
/*
* Cursor functions
*/
static void
crtc_set_cursor_colors(xf86CrtcPtr crtc, int bg, int fg)
{
/* XXX: See if this one is needed, as we only support ARGB cursors */
}
static void
crtc_set_cursor_position(xf86CrtcPtr crtc, int x, int y)
{
modesettingPtr ms = modesettingPTR(crtc->scrn);
struct crtc_private *crtcp = crtc->driver_private;
drmModeMoveCursor(ms->fd, crtcp->drm_crtc->crtc_id, x, y);
}
static void
crtc_load_cursor_argb_ga3d(xf86CrtcPtr crtc, CARD32 * image)
{
unsigned char *ptr;
modesettingPtr ms = modesettingPTR(crtc->scrn);
struct crtc_private *crtcp = crtc->driver_private;
struct pipe_transfer *transfer;
struct pipe_fence_handle *fence = NULL;
struct pipe_context *ctx = ms->ctx;
struct pipe_screen *screen = ms->screen;
if (!crtcp->cursor_tex) {
struct pipe_resource templat;
struct winsys_handle whandle;
memset(&templat, 0, sizeof(templat));
templat.bind |= PIPE_BIND_RENDER_TARGET;
templat.bind |= PIPE_BIND_SCANOUT;
templat.bind |= PIPE_BIND_CURSOR;
templat.target = PIPE_TEXTURE_2D;
templat.last_level = 0;
templat.depth0 = 1;
templat.array_size = 1;
templat.format = PIPE_FORMAT_B8G8R8A8_UNORM;
templat.width0 = 64;
templat.height0 = 64;
memset(&whandle, 0, sizeof(whandle));
whandle.type = DRM_API_HANDLE_TYPE_KMS;
crtcp->cursor_tex = screen->resource_create(screen, &templat);
screen->resource_get_handle(screen, crtcp->cursor_tex, &whandle);
crtcp->cursor_handle = whandle.handle;
}
ptr = pipe_transfer_map(ctx, crtcp->cursor_tex,
0, 0,
PIPE_TRANSFER_WRITE,
0, 0, 64, 64, &transfer);
util_copy_rect(ptr, crtcp->cursor_tex->format,
transfer->stride, 0, 0,
64, 64, (void*)image, 64 * 4, 0, 0);
ctx->transfer_unmap(ctx, transfer);
ctx->flush(ctx, &fence, 0);
if (fence) {
screen->fence_finish(screen, fence, PIPE_TIMEOUT_INFINITE);
screen->fence_reference(screen, &fence, NULL);
}
if (crtc->cursor_shown)
drmModeSetCursor(ms->fd, crtcp->drm_crtc->crtc_id,
crtcp->cursor_handle, 64, 64);
}
#if HAVE_LIBKMS
static void
crtc_load_cursor_argb_kms(xf86CrtcPtr crtc, CARD32 * image)
{
modesettingPtr ms = modesettingPTR(crtc->scrn);
struct crtc_private *crtcp = crtc->driver_private;
unsigned char *ptr;
if (!crtcp->cursor_bo) {
unsigned attr[8];
attr[0] = KMS_BO_TYPE;
#ifdef KMS_BO_TYPE_CURSOR_64X64_A8R8G8B8
attr[1] = KMS_BO_TYPE_CURSOR_64X64_A8R8G8B8;
#else
attr[1] = KMS_BO_TYPE_CURSOR;
#endif
attr[2] = KMS_WIDTH;
attr[3] = 64;
attr[4] = KMS_HEIGHT;
attr[5] = 64;
attr[6] = 0;
if (kms_bo_create(ms->kms, attr, &crtcp->cursor_bo))
return;
if (kms_bo_get_prop(crtcp->cursor_bo, KMS_HANDLE,
&crtcp->cursor_handle))
goto err_bo_destroy;
}
kms_bo_map(crtcp->cursor_bo, (void**)&ptr);
memcpy(ptr, image, 64*64*4);
kms_bo_unmap(crtcp->cursor_bo);
if (crtc->cursor_shown)
drmModeSetCursor(ms->fd, crtcp->drm_crtc->crtc_id,
crtcp->cursor_handle, 64, 64);
return;
err_bo_destroy:
kms_bo_destroy(&crtcp->cursor_bo);
}
#endif
static void
crtc_load_cursor_argb(xf86CrtcPtr crtc, CARD32 * image)
{
xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(crtc->scrn);
modesettingPtr ms = modesettingPTR(crtc->scrn);
/* Older X servers have cursor reference counting bugs leading to use of
* freed memory and consequently random crashes. Should be fixed as of
* xserver 1.8, but this workaround shouldn't hurt anyway.
*/
if (config->cursor)
config->cursor->refcnt++;
if (ms->cursor)
FreeCursor(ms->cursor, None);
ms->cursor = config->cursor;
if (ms->screen)
crtc_load_cursor_argb_ga3d(crtc, image);
#ifdef HAVE_LIBKMS
else if (ms->kms)
crtc_load_cursor_argb_kms(crtc, image);
#endif
}
static void
crtc_show_cursor(xf86CrtcPtr crtc)
{
modesettingPtr ms = modesettingPTR(crtc->scrn);
struct crtc_private *crtcp = crtc->driver_private;
if (crtcp->cursor_tex || crtcp->cursor_bo)
drmModeSetCursor(ms->fd, crtcp->drm_crtc->crtc_id,
crtcp->cursor_handle, 64, 64);
}
static void
crtc_hide_cursor(xf86CrtcPtr crtc)
{
modesettingPtr ms = modesettingPTR(crtc->scrn);
struct crtc_private *crtcp = crtc->driver_private;
drmModeSetCursor(ms->fd, crtcp->drm_crtc->crtc_id, 0, 0, 0);
}
/**
* Called at vt leave
*/
void
xorg_crtc_cursor_destroy(xf86CrtcPtr crtc)
{
struct crtc_private *crtcp = crtc->driver_private;
if (crtcp->cursor_tex)
pipe_resource_reference(&crtcp->cursor_tex, NULL);
#ifdef HAVE_LIBKMS
if (crtcp->cursor_bo)
kms_bo_destroy(&crtcp->cursor_bo);
#endif
}
/*
* Misc functions
*/
static void
crtc_destroy(xf86CrtcPtr crtc)
{
struct crtc_private *crtcp = crtc->driver_private;
xorg_crtc_cursor_destroy(crtc);
drmModeFreeCrtc(crtcp->drm_crtc);
free(crtcp);
crtc->driver_private = NULL;
}
static const xf86CrtcFuncsRec crtc_funcs = {
.dpms = crtc_dpms,
.set_mode_major = crtc_set_mode_major,
.set_cursor_colors = crtc_set_cursor_colors,
.set_cursor_position = crtc_set_cursor_position,
.show_cursor = crtc_show_cursor,
.hide_cursor = crtc_hide_cursor,
.load_cursor_argb = crtc_load_cursor_argb,
.shadow_create = NULL,
.shadow_allocate = NULL,
.shadow_destroy = NULL,
.gamma_set = crtc_gamma_set,
.destroy = crtc_destroy,
};
void
xorg_crtc_init(ScrnInfoPtr pScrn)
{
modesettingPtr ms = modesettingPTR(pScrn);
xf86CrtcPtr crtc;
drmModeResPtr res;
drmModeCrtcPtr drm_crtc = NULL;
struct crtc_private *crtcp;
int c;
res = drmModeGetResources(ms->fd);
if (res == 0) {
ErrorF("Failed drmModeGetResources %d\n", errno);
return;
}
for (c = 0; c < res->count_crtcs; c++) {
drm_crtc = drmModeGetCrtc(ms->fd, res->crtcs[c]);
if (!drm_crtc)
continue;
crtc = xf86CrtcCreate(pScrn, &crtc_funcs);
if (crtc == NULL)
goto out;
crtcp = calloc(1, sizeof(struct crtc_private));
if (!crtcp) {
xf86CrtcDestroy(crtc);
goto out;
}
crtcp->drm_crtc = drm_crtc;
crtc->driver_private = crtcp;
}
out:
drmModeFreeResources(res);
}
/* vim: set sw=4 ts=8 sts=4: */

473
src/gallium/state_trackers/xorg/xorg_dri2.c
View File

@ -1,473 +0,0 @@
/*
* 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.
*
*
* Author: Alan Hourihane <alanh@tungstengraphics.com>
* Author: Jakob Bornecrantz <wallbraker@gmail.com>
*
*/
#include "xorg-server.h"
#include "xf86.h"
#include "xf86_OSproc.h"
#include "xorg_tracker.h"
#include "xorg_exa.h"
#include "dri2.h"
#include "pipe/p_state.h"
#include "util/u_inlines.h"
#include "util/u_format.h"
#include "state_tracker/drm_driver.h"
/* Make all the #if cases in the code esier to read */
#ifndef DRI2INFOREC_VERSION
#define DRI2INFOREC_VERSION 1
#endif
#if DRI2INFOREC_VERSION == 2
static Bool set_format_in_do_create_buffer;
#endif
typedef struct {
PixmapPtr pPixmap;
struct pipe_resource *tex;
struct pipe_fence_handle *fence;
} *BufferPrivatePtr;
static Bool
dri2_do_create_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer, unsigned int format)
{
struct pipe_resource *tex = NULL;
ScreenPtr pScreen = pDraw->pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_pixmap_priv *exa_priv;
BufferPrivatePtr private = buffer->driverPrivate;
PixmapPtr pPixmap;
struct winsys_handle whandle;
if (pDraw->type == DRAWABLE_PIXMAP)
pPixmap = (PixmapPtr) pDraw;
else
pPixmap = (*pScreen->GetWindowPixmap)((WindowPtr) pDraw);
exa_priv = exaGetPixmapDriverPrivate(pPixmap);
switch (buffer->attachment) {
default:
if (buffer->attachment != DRI2BufferFakeFrontLeft ||
pDraw->type != DRAWABLE_PIXMAP) {
private->pPixmap = (*pScreen->CreatePixmap)(pScreen, pDraw->width,
pDraw->height,
pDraw->depth,
0);
}
break;
case DRI2BufferFrontLeft:
break;
case DRI2BufferStencil:
#if DRI2INFOREC_VERSION >= 3
case DRI2BufferDepthStencil:
#else
/* Works on old X servers because sanity checking is for the weak */
case 9:
#endif
if (exa_priv->depth_stencil_tex &&
!util_format_is_depth_or_stencil(exa_priv->depth_stencil_tex->format))
exa_priv->depth_stencil_tex = NULL;
/* Fall through */
case DRI2BufferDepth:
if (exa_priv->depth_stencil_tex)
pipe_resource_reference(&tex, exa_priv->depth_stencil_tex);
else {
struct pipe_resource template;
unsigned depthBits = (format != 0) ? format : pDraw->depth;
memset(&template, 0, sizeof(template));
template.target = PIPE_TEXTURE_2D;
if (buffer->attachment == DRI2BufferDepth) {
switch(depthBits) {
case 16:
template.format = PIPE_FORMAT_Z16_UNORM;
break;
case 32:
template.format = PIPE_FORMAT_Z32_UNORM;
break;
default:
template.format = ms->ds_depth_bits_last ?
PIPE_FORMAT_Z24X8_UNORM : PIPE_FORMAT_X8Z24_UNORM;
break;
}
} else {
template.format = ms->ds_depth_bits_last ?
PIPE_FORMAT_Z24_UNORM_S8_UINT : PIPE_FORMAT_S8_UINT_Z24_UNORM;
}
template.width0 = pDraw->width;
template.height0 = pDraw->height;
template.depth0 = 1;
template.array_size = 1;
template.last_level = 0;
template.bind = PIPE_BIND_DEPTH_STENCIL |
PIPE_BIND_SHARED;
tex = ms->screen->resource_create(ms->screen, &template);
pipe_resource_reference(&exa_priv->depth_stencil_tex, tex);
}
break;
}
if (!private->pPixmap) {
private->pPixmap = pPixmap;
pPixmap->refcnt++;
}
if (!tex) {
/* First call to make sure we have a pixmap private */
exaMoveInPixmap(private->pPixmap);
xorg_exa_set_shared_usage(private->pPixmap);
pScreen->ModifyPixmapHeader(private->pPixmap, 0, 0, 0, 0, 0, NULL);
/* Second call to make sure texture has valid contents */
exaMoveInPixmap(private->pPixmap);
tex = xorg_exa_get_texture(private->pPixmap);
}
if (!tex)
FatalError("NO TEXTURE IN DRI2\n");
memset(&whandle, 0, sizeof(whandle));
whandle.type = DRM_API_HANDLE_TYPE_SHARED;
ms->screen->resource_get_handle(ms->screen, tex, &whandle);
buffer->name = whandle.handle;
buffer->pitch = whandle.stride;
buffer->cpp = 4;
buffer->driverPrivate = private;
buffer->flags = 0; /* not tiled */
#if DRI2INFOREC_VERSION == 2
/* ABI forwards/backwards compatibility */
if (set_format_in_do_create_buffer)
((DRI2Buffer2Ptr)buffer)->format = 0;
#elif DRI2INFOREC_VERSION >= 3
buffer->format = 0;
#endif
private->tex = tex;
return TRUE;
}
static void
dri2_do_destroy_buffer(DrawablePtr pDraw, DRI2BufferPtr buffer)
{
ScreenPtr pScreen = pDraw->pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
BufferPrivatePtr private = buffer->driverPrivate;
struct exa_pixmap_priv *exa_priv = exaGetPixmapDriverPrivate(private->pPixmap);
pipe_resource_reference(&private->tex, NULL);
ms->screen->fence_reference(ms->screen, &private->fence, NULL);
pipe_resource_reference(&exa_priv->depth_stencil_tex, NULL);
(*pScreen->DestroyPixmap)(private->pPixmap);
}
#if DRI2INFOREC_VERSION >= 2
static DRI2Buffer2Ptr
dri2_create_buffer(DrawablePtr pDraw, unsigned int attachment, unsigned int format)
{
DRI2Buffer2Ptr buffer;
BufferPrivatePtr private;
buffer = calloc(1, sizeof *buffer);
if (!buffer)
return NULL;
private = calloc(1, sizeof *private);
if (!private) {
goto fail;
}
buffer->attachment = attachment;
buffer->driverPrivate = private;
/* So far it is safe to downcast a DRI2Buffer2Ptr to DRI2BufferPtr */
if (dri2_do_create_buffer(pDraw, (DRI2BufferPtr)buffer, format))
return buffer;
free(private);
fail:
free(buffer);
return NULL;
}
static void
dri2_destroy_buffer(DrawablePtr pDraw, DRI2Buffer2Ptr buffer)
{
/* So far it is safe to downcast a DRI2Buffer2Ptr to DRI2BufferPtr */
dri2_do_destroy_buffer(pDraw, (DRI2BufferPtr)buffer);
free(buffer->driverPrivate);
free(buffer);
}
#endif /* DRI2INFOREC_VERSION >= 2 */
#if DRI2INFOREC_VERSION <= 2
static DRI2BufferPtr
dri2_create_buffers(DrawablePtr pDraw, unsigned int *attachments, int count)
{
BufferPrivatePtr privates;
DRI2BufferPtr buffers;
int i;
buffers = calloc(count, sizeof *buffers);
if (!buffers)
goto fail_buffers;
privates = calloc(count, sizeof *privates);
if (!privates)
goto fail_privates;
for (i = 0; i < count; i++) {
buffers[i].attachment = attachments[i];
buffers[i].driverPrivate = &privates[i];
if (!dri2_do_create_buffer(pDraw, &buffers[i], 0))
goto fail;
}
return buffers;
fail:
free(privates);
fail_privates:
free(buffers);
fail_buffers:
return NULL;
}
static void
dri2_destroy_buffers(DrawablePtr pDraw, DRI2BufferPtr buffers, int count)
{
int i;
for (i = 0; i < count; i++) {
dri2_do_destroy_buffer(pDraw, &buffers[i]);
}
if (buffers) {
free(buffers[0].driverPrivate);
free(buffers);
}
}
#endif /* DRI2INFOREC_VERSION <= 2 */
static void
dri2_copy_region(DrawablePtr pDraw, RegionPtr pRegion,
DRI2BufferPtr pDestBuffer, DRI2BufferPtr pSrcBuffer)
{
ScreenPtr pScreen = pDraw->pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
BufferPrivatePtr dst_priv = pDestBuffer->driverPrivate;
BufferPrivatePtr src_priv = pSrcBuffer->driverPrivate;
DrawablePtr src_draw;
DrawablePtr dst_draw;
GCPtr gc;
RegionPtr copy_clip;
Bool save_accel;
CustomizerPtr cust = ms->cust;
/*
* In driCreateBuffers we dewrap windows into the
* backing pixmaps in order to get to the texture.
* We need to use the real drawable in CopyArea
* so that cliprects and offsets are correct.
*/
src_draw = (pSrcBuffer->attachment == DRI2BufferFrontLeft) ? pDraw :
&src_priv->pPixmap->drawable;
dst_draw = (pDestBuffer->attachment == DRI2BufferFrontLeft) ? pDraw :
&dst_priv->pPixmap->drawable;
/*
* The clients implements glXWaitX with a copy front to fake and then
* waiting on the server to signal its completion of it. While
* glXWaitGL is a client side flush and a copy from fake to front.
* This is how it is done in the DRI2 protocol, how ever depending
* which type of drawables the server does things a bit differently
* then what the protocol says as the fake and front are the same.
*
* for pixmaps glXWaitX is a server flush.
* for pixmaps glXWaitGL is a client flush.
* for windows glXWaitX is a copy from front to fake then a server flush.
* for windows glXWaitGL is a client flush then a copy from fake to front.
*
* XXX in the windows case this code always flushes but that isn't a
* must in the glXWaitGL case but we don't know if this is a glXWaitGL
* or a glFlush/glFinish call.
*/
if (dst_priv->pPixmap == src_priv->pPixmap) {
/* pixmap glXWaitX */
if (pSrcBuffer->attachment == DRI2BufferFrontLeft &&
pDestBuffer->attachment == DRI2BufferFakeFrontLeft) {
ms->ctx->flush(ms->ctx, NULL, 0);
return;
}
/* pixmap glXWaitGL */
if (pDestBuffer->attachment == DRI2BufferFrontLeft &&
pSrcBuffer->attachment == DRI2BufferFakeFrontLeft) {
return;
} else {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"copying between the same pixmap\n");
}
}
gc = GetScratchGC(pDraw->depth, pScreen);
copy_clip = REGION_CREATE(pScreen, NULL, 0);
REGION_COPY(pScreen, copy_clip, pRegion);
(*gc->funcs->ChangeClip) (gc, CT_REGION, copy_clip, 0);
ValidateGC(dst_draw, gc);
/* If this is a full buffer swap, throttle on the previous one */
if (ms->swapThrottling &&
dst_priv->fence && REGION_NUM_RECTS(pRegion) == 1) {
BoxPtr extents = REGION_EXTENTS(pScreen, pRegion);
if (extents->x1 == 0 && extents->y1 == 0 &&
extents->x2 == pDraw->width && extents->y2 == pDraw->height) {
ms->screen->fence_finish(ms->screen, dst_priv->fence,
PIPE_TIMEOUT_INFINITE);
ms->screen->fence_reference(ms->screen, &dst_priv->fence, NULL);
}
}
/* Try to make sure the blit will be accelerated */
save_accel = ms->exa->accel;
ms->exa->accel = TRUE;
if (pSrcBuffer->attachment != DRI2BufferFrontLeft) {
/* In case it won't be though, make sure the GPU copy contents of the
* source pixmap will be used for the software fallback - presumably the
* client modified them before calling in here.
*/
exaMoveInPixmap(src_priv->pPixmap);
DamageRegionAppend(src_draw, pRegion);
DamageRegionProcessPending(src_draw);
}
if (cust && cust->winsys_context_throttle)
cust->winsys_context_throttle(cust, ms->ctx, THROTTLE_SWAP);
(*gc->ops->CopyArea)(src_draw, dst_draw, gc,
0, 0, pDraw->width, pDraw->height, 0, 0);
ms->exa->accel = save_accel;
FreeScratchGC(gc);
ms->ctx->flush(ms->ctx,
(pDestBuffer->attachment == DRI2BufferFrontLeft
&& ms->swapThrottling) ?
&dst_priv->fence : NULL, 0);
if (cust && cust->winsys_context_throttle)
cust->winsys_context_throttle(cust, ms->ctx, THROTTLE_RENDER);
}
Bool
xorg_dri2_init(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
DRI2InfoRec dri2info;
#if DRI2INFOREC_VERSION >= 2
int major, minor;
if (xf86LoaderCheckSymbol("DRI2Version")) {
DRI2Version(&major, &minor);
} else {
/* Assume version 1.0 */
major = 1;
minor = 0;
}
#endif
dri2info.version = min(DRI2INFOREC_VERSION, 3);
dri2info.fd = ms->fd;
dri2info.driverName = pScrn->driverName;
dri2info.deviceName = "/dev/dri/card0"; /* FIXME */
#if DRI2INFOREC_VERSION >= 2
dri2info.CreateBuffer = dri2_create_buffer;
dri2info.DestroyBuffer = dri2_destroy_buffer;
#endif
/* For X servers in the 1.6.x series there where two DRI2 version.
* This allows us to build one binary that works on both servers.
*/
#if DRI2INFOREC_VERSION == 2
if (minor == 0) {
set_format_in_do_create_buffer = FALSE;
dri2info.CreateBuffers = dri2_create_buffers;
dri2info.DestroyBuffers = dri2_destroy_buffers;
} else
set_format_in_do_create_buffer = FALSE;
#endif
/* For version 1 set these unconditionaly. */
#if DRI2INFOREC_VERSION == 1
dri2info.CreateBuffers = dri2_create_buffers;
dri2info.DestroyBuffers = dri2_destroy_buffers;
#endif
dri2info.CopyRegion = dri2_copy_region;
dri2info.Wait = NULL;
ms->d_depth_bits_last =
ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24X8_UNORM,
PIPE_TEXTURE_2D,
0,
PIPE_BIND_DEPTH_STENCIL);
ms->ds_depth_bits_last =
ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24_UNORM_S8_UINT,
PIPE_TEXTURE_2D,
0,
PIPE_BIND_DEPTH_STENCIL);
return DRI2ScreenInit(pScreen, &dri2info);
}
void
xorg_dri2_close(ScreenPtr pScreen)
{
DRI2CloseScreen(pScreen);
}
/* vim: set sw=4 ts=8 sts=4: */

1323
src/gallium/state_trackers/xorg/xorg_driver.c
View File

File diff suppressed because it is too large Load Diff

1087
src/gallium/state_trackers/xorg/xorg_exa.c
View File

File diff suppressed because it is too large Load Diff

76
src/gallium/state_trackers/xorg/xorg_exa.h
View File

@ -1,76 +0,0 @@
#ifndef XORG_EXA_H
#define XORG_EXA_H
#include "xorg_tracker.h"
#include "pipe/p_state.h"
struct cso_context;
struct xorg_shaders;
/* src + mask + dst */
#define MAX_EXA_SAMPLERS 3
struct exa_context
{
ExaDriverPtr pExa;
struct pipe_context *pipe;
struct pipe_screen *scrn;
struct xorg_renderer *renderer;
struct pipe_sampler_view *bound_sampler_views[MAX_EXA_SAMPLERS];
int num_bound_samplers;
float solid_color[4];
boolean has_solid_color;
boolean accel;
/* float[9] projective matrix bound to pictures */
struct {
float src[9];
float mask[9];
boolean has_src;
boolean has_mask;
} transform;
struct {
struct exa_pixmap_priv *src;
struct exa_pixmap_priv *dst;
PixmapPtr tmp_pix;
} copy;
};
struct exa_pixmap_priv
{
int width, height;
int flags;
int tex_flags;
int picture_format;
struct pipe_resource *tex;
struct pipe_resource *depth_stencil_tex;
struct pipe_transfer *map_transfer;
unsigned map_count;
};
#define XORG_FALLBACK(s, arg...) \
do { \
if (ms->debug_fallback) { \
xf86DrvMsg(pScrn->scrnIndex, X_INFO, \
"%s fallback " s "\n", __FUNCTION__, ##arg); \
} \
return FALSE; \
} while(0)
struct pipe_surface *
xorg_gpu_surface(struct pipe_context *pipe, struct exa_pixmap_priv *priv);
void xorg_exa_flush(struct exa_context *exa,
struct pipe_fence_handle **fence);
void xorg_exa_finish(struct exa_context *exa);
#endif

690
src/gallium/state_trackers/xorg/xorg_exa_tgsi.c
View File

@ -1,690 +0,0 @@
#include "xorg_exa_tgsi.h"
/*### stupidity defined in X11/extensions/XI.h */
#undef Absolute
#include "pipe/p_format.h"
#include "pipe/p_context.h"
#include "pipe/p_state.h"
#include "pipe/p_shader_tokens.h"
#include "util/u_memory.h"
#include "tgsi/tgsi_ureg.h"
#include "cso_cache/cso_context.h"
#include "cso_cache/cso_hash.h"
/* Vertex shader:
* IN[0] = vertex pos
* IN[1] = src tex coord | solid fill color
* IN[2] = mask tex coord
* IN[3] = dst tex coord
* CONST[0] = (2/dst_width, 2/dst_height, 1, 1)
* CONST[1] = (-1, -1, 0, 0)
*
* OUT[0] = vertex pos
* OUT[1] = src tex coord | solid fill color
* OUT[2] = mask tex coord
* OUT[3] = dst tex coord
*/
/* Fragment shader:
* SAMP[0] = src
* SAMP[1] = mask
* SAMP[2] = dst
* IN[0] = pos src | solid fill color
* IN[1] = pos mask
* IN[2] = pos dst
* CONST[0] = (0, 0, 0, 1)
*
* OUT[0] = color
*/
static void
print_fs_traits(int fs_traits)
{
const char *strings[] = {
"FS_COMPOSITE", /* = 1 << 0, */
"FS_MASK", /* = 1 << 1, */
"FS_SOLID_FILL", /* = 1 << 2, */
"FS_LINGRAD_FILL", /* = 1 << 3, */
"FS_RADGRAD_FILL", /* = 1 << 4, */
"FS_CA_FULL", /* = 1 << 5, */ /* src.rgba * mask.rgba */
"FS_CA_SRCALPHA", /* = 1 << 6, */ /* src.aaaa * mask.rgba */
"FS_YUV", /* = 1 << 7, */
"FS_SRC_REPEAT_NONE", /* = 1 << 8, */
"FS_MASK_REPEAT_NONE",/* = 1 << 9, */
"FS_SRC_SWIZZLE_RGB", /* = 1 << 10, */
"FS_MASK_SWIZZLE_RGB",/* = 1 << 11, */
"FS_SRC_SET_ALPHA", /* = 1 << 12, */
"FS_MASK_SET_ALPHA", /* = 1 << 13, */
"FS_SRC_LUMINANCE", /* = 1 << 14, */
"FS_MASK_LUMINANCE", /* = 1 << 15, */
};
int i, k;
debug_printf("%s: ", __func__);
for (i = 0, k = 1; k < (1 << 16); i++, k <<= 1) {
if (fs_traits & k)
debug_printf("%s, ", strings[i]);
}
debug_printf("\n");
}
struct xorg_shaders {
struct xorg_renderer *r;
struct cso_hash *vs_hash;
struct cso_hash *fs_hash;
};
static INLINE void
src_in_mask(struct ureg_program *ureg,
struct ureg_dst dst,
struct ureg_src src,
struct ureg_src mask,
unsigned component_alpha,
unsigned mask_luminance)
{
if (component_alpha == FS_CA_FULL) {
ureg_MUL(ureg, dst, src, mask);
} else if (component_alpha == FS_CA_SRCALPHA) {
ureg_MUL(ureg, dst,
ureg_scalar(src, TGSI_SWIZZLE_W), mask);
}
else {
if (mask_luminance)
ureg_MUL(ureg, dst, src,
ureg_scalar(mask, TGSI_SWIZZLE_X));
else
ureg_MUL(ureg, dst, src,
ureg_scalar(mask, TGSI_SWIZZLE_W));
}
}
static struct ureg_src
vs_normalize_coords(struct ureg_program *ureg, struct ureg_src coords,
struct ureg_src const0, struct ureg_src const1)
{
struct ureg_dst tmp = ureg_DECL_temporary(ureg);
struct ureg_src ret;
ureg_MAD(ureg, tmp, coords, const0, const1);
ret = ureg_src(tmp);
ureg_release_temporary(ureg, tmp);
return ret;
}
static void
linear_gradient(struct ureg_program *ureg,
struct ureg_dst out,
struct ureg_src pos,
struct ureg_src sampler,
struct ureg_src coords,
struct ureg_src const0124,
struct ureg_src matrow0,
struct ureg_src matrow1,
struct ureg_src matrow2)
{
struct ureg_dst temp0 = ureg_DECL_temporary(ureg);
struct ureg_dst temp1 = ureg_DECL_temporary(ureg);
struct ureg_dst temp2 = ureg_DECL_temporary(ureg);
struct ureg_dst temp3 = ureg_DECL_temporary(ureg);
struct ureg_dst temp4 = ureg_DECL_temporary(ureg);
struct ureg_dst temp5 = ureg_DECL_temporary(ureg);
ureg_MOV(ureg,
ureg_writemask(temp0, TGSI_WRITEMASK_XY), pos);
ureg_MOV(ureg,
ureg_writemask(temp0, TGSI_WRITEMASK_Z),
ureg_scalar(const0124, TGSI_SWIZZLE_Y));
ureg_DP3(ureg, temp1, matrow0, ureg_src(temp0));
ureg_DP3(ureg, temp2, matrow1, ureg_src(temp0));
ureg_DP3(ureg, temp3, matrow2, ureg_src(temp0));
ureg_RCP(ureg, temp3, ureg_src(temp3));
ureg_MUL(ureg, temp1, ureg_src(temp1), ureg_src(temp3));
ureg_MUL(ureg, temp2, ureg_src(temp2), ureg_src(temp3));
ureg_MOV(ureg, ureg_writemask(temp4, TGSI_WRITEMASK_X),
ureg_src(temp1));
ureg_MOV(ureg, ureg_writemask(temp4, TGSI_WRITEMASK_Y),
ureg_src(temp2));
ureg_MUL(ureg, temp0,
ureg_scalar(coords, TGSI_SWIZZLE_Y),
ureg_scalar(ureg_src(temp4), TGSI_SWIZZLE_Y));
ureg_MAD(ureg, temp1,
ureg_scalar(coords, TGSI_SWIZZLE_X),
ureg_scalar(ureg_src(temp4), TGSI_SWIZZLE_X),
ureg_src(temp0));
ureg_MUL(ureg, temp2,
ureg_src(temp1),
ureg_scalar(coords, TGSI_SWIZZLE_Z));
ureg_TEX(ureg, out,
TGSI_TEXTURE_1D, ureg_src(temp2), sampler);
ureg_release_temporary(ureg, temp0);
ureg_release_temporary(ureg, temp1);
ureg_release_temporary(ureg, temp2);
ureg_release_temporary(ureg, temp3);
ureg_release_temporary(ureg, temp4);
ureg_release_temporary(ureg, temp5);
}
static void
radial_gradient(struct ureg_program *ureg,
struct ureg_dst out,
struct ureg_src pos,
struct ureg_src sampler,
struct ureg_src coords,
struct ureg_src const0124,
struct ureg_src matrow0,
struct ureg_src matrow1,
struct ureg_src matrow2)
{
struct ureg_dst temp0 = ureg_DECL_temporary(ureg);
struct ureg_dst temp1 = ureg_DECL_temporary(ureg);
struct ureg_dst temp2 = ureg_DECL_temporary(ureg);
struct ureg_dst temp3 = ureg_DECL_temporary(ureg);
struct ureg_dst temp4 = ureg_DECL_temporary(ureg);
struct ureg_dst temp5 = ureg_DECL_temporary(ureg);
ureg_MOV(ureg,
ureg_writemask(temp0, TGSI_WRITEMASK_XY),
pos);
ureg_MOV(ureg,
ureg_writemask(temp0, TGSI_WRITEMASK_Z),
ureg_scalar(const0124, TGSI_SWIZZLE_Y));
ureg_DP3(ureg, temp1, matrow0, ureg_src(temp0));
ureg_DP3(ureg, temp2, matrow1, ureg_src(temp0));
ureg_DP3(ureg, temp3, matrow2, ureg_src(temp0));
ureg_RCP(ureg, temp3, ureg_src(temp3));
ureg_MUL(ureg, temp1, ureg_src(temp1), ureg_src(temp3));
ureg_MUL(ureg, temp2, ureg_src(temp2), ureg_src(temp3));
ureg_MOV(ureg, ureg_writemask(temp5, TGSI_WRITEMASK_X),
ureg_src(temp1));
ureg_MOV(ureg, ureg_writemask(temp5, TGSI_WRITEMASK_Y),
ureg_src(temp2));
ureg_MUL(ureg, temp0, ureg_scalar(coords, TGSI_SWIZZLE_Y),
ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_Y));
ureg_MAD(ureg, temp1,
ureg_scalar(coords, TGSI_SWIZZLE_X),
ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_X),
ureg_src(temp0));
ureg_ADD(ureg, temp1,
ureg_src(temp1), ureg_src(temp1));
ureg_MUL(ureg, temp3,
ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_Y),
ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_Y));
ureg_MAD(ureg, temp4,
ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_X),
ureg_scalar(ureg_src(temp5), TGSI_SWIZZLE_X),
ureg_src(temp3));
ureg_MOV(ureg, temp4, ureg_negate(ureg_src(temp4)));
ureg_MUL(ureg, temp2,
ureg_scalar(coords, TGSI_SWIZZLE_Z),
ureg_src(temp4));
ureg_MUL(ureg, temp0,
ureg_scalar(const0124, TGSI_SWIZZLE_W),
ureg_src(temp2));
ureg_MUL(ureg, temp3,
ureg_src(temp1), ureg_src(temp1));
ureg_SUB(ureg, temp2,
ureg_src(temp3), ureg_src(temp0));
ureg_RSQ(ureg, temp2, ureg_abs(ureg_src(temp2)));
ureg_RCP(ureg, temp2, ureg_src(temp2));
ureg_SUB(ureg, temp1,
ureg_src(temp2), ureg_src(temp1));
ureg_ADD(ureg, temp0,
ureg_scalar(coords, TGSI_SWIZZLE_Z),
ureg_scalar(coords, TGSI_SWIZZLE_Z));
ureg_RCP(ureg, temp0, ureg_src(temp0));
ureg_MUL(ureg, temp2,
ureg_src(temp1), ureg_src(temp0));
ureg_TEX(ureg, out, TGSI_TEXTURE_1D,
ureg_src(temp2), sampler);
ureg_release_temporary(ureg, temp0);
ureg_release_temporary(ureg, temp1);
ureg_release_temporary(ureg, temp2);
ureg_release_temporary(ureg, temp3);
ureg_release_temporary(ureg, temp4);
ureg_release_temporary(ureg, temp5);
}
static void *
create_vs(struct pipe_context *pipe,
unsigned vs_traits)
{
struct ureg_program *ureg;
struct ureg_src src;
struct ureg_dst dst;
struct ureg_src const0, const1;
boolean is_fill = (vs_traits & VS_FILL) != 0;
boolean is_composite = (vs_traits & VS_COMPOSITE) != 0;
boolean has_mask = (vs_traits & VS_MASK) != 0;
boolean is_yuv = (vs_traits & VS_YUV) != 0;
unsigned input_slot = 0;
ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
if (ureg == NULL)
return 0;
const0 = ureg_DECL_constant(ureg, 0);
const1 = ureg_DECL_constant(ureg, 1);
/* it has to be either a fill or a composite op */
debug_assert((is_fill ^ is_composite) ^ is_yuv);
src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
src = vs_normalize_coords(ureg, src,
const0, const1);
ureg_MOV(ureg, dst, src);
if (is_yuv) {
src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 0);
ureg_MOV(ureg, dst, src);
}
if (is_composite) {
src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 0);
ureg_MOV(ureg, dst, src);
}
if (is_fill) {
src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
ureg_MOV(ureg, dst, src);
}
if (has_mask) {
src = ureg_DECL_vs_input(ureg, input_slot++);
dst = ureg_DECL_output(ureg, TGSI_SEMANTIC_GENERIC, 1);
ureg_MOV(ureg, dst, src);
}
ureg_END(ureg);
return ureg_create_shader_and_destroy(ureg, pipe);
}
static void *
create_yuv_shader(struct pipe_context *pipe, struct ureg_program *ureg)
{
struct ureg_src y_sampler, u_sampler, v_sampler;
struct ureg_src pos;
struct ureg_src matrow0, matrow1, matrow2;
struct ureg_dst y, u, v, rgb;
struct ureg_dst out = ureg_DECL_output(ureg,
TGSI_SEMANTIC_COLOR,
0);
pos = ureg_DECL_fs_input(ureg,
TGSI_SEMANTIC_GENERIC,
0,
TGSI_INTERPOLATE_PERSPECTIVE);
rgb = ureg_DECL_temporary(ureg);
y = ureg_DECL_temporary(ureg);
u = ureg_DECL_temporary(ureg);
v = ureg_DECL_temporary(ureg);
y_sampler = ureg_DECL_sampler(ureg, 0);
u_sampler = ureg_DECL_sampler(ureg, 1);
v_sampler = ureg_DECL_sampler(ureg, 2);
matrow0 = ureg_DECL_constant(ureg, 0);
matrow1 = ureg_DECL_constant(ureg, 1);
matrow2 = ureg_DECL_constant(ureg, 2);
ureg_TEX(ureg, y,
TGSI_TEXTURE_2D, pos, y_sampler);
ureg_TEX(ureg, u,
TGSI_TEXTURE_2D, pos, u_sampler);
ureg_TEX(ureg, v,
TGSI_TEXTURE_2D, pos, v_sampler);
ureg_SUB(ureg, u, ureg_src(u),
ureg_scalar(matrow0, TGSI_SWIZZLE_W));
ureg_SUB(ureg, v, ureg_src(v),
ureg_scalar(matrow0, TGSI_SWIZZLE_W));
ureg_MUL(ureg, rgb,
ureg_scalar(ureg_src(y), TGSI_SWIZZLE_X),
matrow0);
ureg_MAD(ureg, rgb,
ureg_scalar(ureg_src(u), TGSI_SWIZZLE_X),
matrow1,
ureg_src(rgb));
ureg_MAD(ureg, rgb,
ureg_scalar(ureg_src(v), TGSI_SWIZZLE_X),
matrow2,
ureg_src(rgb));
/* rgb.a = 1; */
ureg_MOV(ureg, ureg_writemask(rgb, TGSI_WRITEMASK_W),
ureg_scalar(matrow0, TGSI_SWIZZLE_X));
ureg_MOV(ureg, out, ureg_src(rgb));
ureg_release_temporary(ureg, rgb);
ureg_release_temporary(ureg, y);
ureg_release_temporary(ureg, u);
ureg_release_temporary(ureg, v);
ureg_END(ureg);
return ureg_create_shader_and_destroy(ureg, pipe);
}
static INLINE void
xrender_tex(struct ureg_program *ureg,
struct ureg_dst dst,
struct ureg_src coords,
struct ureg_src sampler,
struct ureg_src imm0,
boolean repeat_none,
boolean swizzle,
boolean set_alpha)
{
if (repeat_none) {
struct ureg_dst tmp0 = ureg_DECL_temporary(ureg);
struct ureg_dst tmp1 = ureg_DECL_temporary(ureg);
ureg_SGT(ureg, tmp1, ureg_swizzle(coords,
TGSI_SWIZZLE_X,
TGSI_SWIZZLE_Y,
TGSI_SWIZZLE_X,
TGSI_SWIZZLE_Y),
ureg_scalar(imm0, TGSI_SWIZZLE_X));
ureg_SLT(ureg, tmp0, ureg_swizzle(coords,
TGSI_SWIZZLE_X,
TGSI_SWIZZLE_Y,
TGSI_SWIZZLE_X,
TGSI_SWIZZLE_Y),
ureg_scalar(imm0, TGSI_SWIZZLE_W));
ureg_MIN(ureg, tmp0, ureg_src(tmp0), ureg_src(tmp1));
ureg_MIN(ureg, tmp0, ureg_scalar(ureg_src(tmp0), TGSI_SWIZZLE_X),
ureg_scalar(ureg_src(tmp0), TGSI_SWIZZLE_Y));
ureg_TEX(ureg, tmp1, TGSI_TEXTURE_2D, coords, sampler);
if (swizzle)
ureg_MOV(ureg, tmp1, ureg_swizzle(ureg_src(tmp1),
TGSI_SWIZZLE_Z,
TGSI_SWIZZLE_Y,
TGSI_SWIZZLE_X,
TGSI_SWIZZLE_W));
if (set_alpha)
ureg_MOV(ureg,
ureg_writemask(tmp1, TGSI_WRITEMASK_W),
ureg_scalar(imm0, TGSI_SWIZZLE_W));
ureg_MUL(ureg, dst, ureg_src(tmp1), ureg_src(tmp0));
ureg_release_temporary(ureg, tmp0);
ureg_release_temporary(ureg, tmp1);
} else {
if (swizzle) {
struct ureg_dst tmp = ureg_DECL_temporary(ureg);
ureg_TEX(ureg, tmp, TGSI_TEXTURE_2D, coords, sampler);
ureg_MOV(ureg, dst, ureg_swizzle(ureg_src(tmp),
TGSI_SWIZZLE_Z,
TGSI_SWIZZLE_Y,
TGSI_SWIZZLE_X,
TGSI_SWIZZLE_W));
ureg_release_temporary(ureg, tmp);
} else {
ureg_TEX(ureg, dst, TGSI_TEXTURE_2D, coords, sampler);
}
if (set_alpha)
ureg_MOV(ureg,
ureg_writemask(dst, TGSI_WRITEMASK_W),
ureg_scalar(imm0, TGSI_SWIZZLE_W));
}
}
static void *
create_fs(struct pipe_context *pipe,
unsigned fs_traits)
{
struct ureg_program *ureg;
struct ureg_src /*dst_sampler,*/ src_sampler, mask_sampler;
struct ureg_src /*dst_pos,*/ src_input, mask_pos;
struct ureg_dst src, mask;
struct ureg_dst out;
struct ureg_src imm0 = { 0 };
unsigned has_mask = (fs_traits & FS_MASK) != 0;
unsigned is_fill = (fs_traits & FS_FILL) != 0;
unsigned is_composite = (fs_traits & FS_COMPOSITE) != 0;
unsigned is_solid = (fs_traits & FS_SOLID_FILL) != 0;
unsigned is_lingrad = (fs_traits & FS_LINGRAD_FILL) != 0;
unsigned is_radgrad = (fs_traits & FS_RADGRAD_FILL) != 0;
unsigned comp_alpha_mask = fs_traits & FS_COMPONENT_ALPHA;
unsigned is_yuv = (fs_traits & FS_YUV) != 0;
unsigned src_repeat_none = (fs_traits & FS_SRC_REPEAT_NONE) != 0;
unsigned mask_repeat_none = (fs_traits & FS_MASK_REPEAT_NONE) != 0;
unsigned src_swizzle = (fs_traits & FS_SRC_SWIZZLE_RGB) != 0;
unsigned mask_swizzle = (fs_traits & FS_MASK_SWIZZLE_RGB) != 0;
unsigned src_set_alpha = (fs_traits & FS_SRC_SET_ALPHA) != 0;
unsigned mask_set_alpha = (fs_traits & FS_MASK_SET_ALPHA) != 0;
unsigned src_luminance = (fs_traits & FS_SRC_LUMINANCE) != 0;
unsigned mask_luminance = (fs_traits & FS_MASK_LUMINANCE) != 0;
#if 0
print_fs_traits(fs_traits);
#else
(void)print_fs_traits;
#endif
ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
if (ureg == NULL)
return 0;
/* it has to be either a fill, a composite op or a yuv conversion */
debug_assert((is_fill ^ is_composite) ^ is_yuv);
(void) is_yuv;
out = ureg_DECL_output(ureg,
TGSI_SEMANTIC_COLOR,
0);
if (src_repeat_none || mask_repeat_none ||
src_set_alpha || mask_set_alpha ||
src_luminance) {
imm0 = ureg_imm4f(ureg, 0, 0, 0, 1);
}
if (is_composite) {
src_sampler = ureg_DECL_sampler(ureg, 0);
src_input = ureg_DECL_fs_input(ureg,
TGSI_SEMANTIC_GENERIC,
0,
TGSI_INTERPOLATE_PERSPECTIVE);
} else if (is_fill) {
if (is_solid)
src_input = ureg_DECL_fs_input(ureg,
TGSI_SEMANTIC_COLOR,
0,
TGSI_INTERPOLATE_PERSPECTIVE);
else
src_input = ureg_DECL_fs_input(ureg,
TGSI_SEMANTIC_POSITION,
0,
TGSI_INTERPOLATE_PERSPECTIVE);
} else {
debug_assert(is_yuv);
return create_yuv_shader(pipe, ureg);
}
if (has_mask) {
mask_sampler = ureg_DECL_sampler(ureg, 1);
mask_pos = ureg_DECL_fs_input(ureg,
TGSI_SEMANTIC_GENERIC,
1,
TGSI_INTERPOLATE_PERSPECTIVE);
}
#if 0 /* unused right now */
dst_sampler = ureg_DECL_sampler(ureg, 2);
dst_pos = ureg_DECL_fs_input(ureg,
TGSI_SEMANTIC_POSITION,
2,
TGSI_INTERPOLATE_PERSPECTIVE);
#endif
if (is_composite) {
if (has_mask || src_luminance)
src = ureg_DECL_temporary(ureg);
else
src = out;
xrender_tex(ureg, src, src_input, src_sampler, imm0,
src_repeat_none, src_swizzle, src_set_alpha);
} else if (is_fill) {
if (is_solid) {
if (has_mask || src_luminance)
src = ureg_dst(src_input);
else
ureg_MOV(ureg, out, src_input);
} else if (is_lingrad || is_radgrad) {
struct ureg_src coords, const0124,
matrow0, matrow1, matrow2;
if (has_mask || src_luminance)
src = ureg_DECL_temporary(ureg);
else
src = out;
coords = ureg_DECL_constant(ureg, 0);
const0124 = ureg_DECL_constant(ureg, 1);
matrow0 = ureg_DECL_constant(ureg, 2);
matrow1 = ureg_DECL_constant(ureg, 3);
matrow2 = ureg_DECL_constant(ureg, 4);
if (is_lingrad) {
linear_gradient(ureg, src,
src_input, src_sampler,
coords, const0124,
matrow0, matrow1, matrow2);
} else if (is_radgrad) {
radial_gradient(ureg, src,
src_input, src_sampler,
coords, const0124,
matrow0, matrow1, matrow2);
}
} else
debug_assert(!"Unknown fill type!");
}
if (src_luminance) {
ureg_MOV(ureg, src,
ureg_scalar(ureg_src(src), TGSI_SWIZZLE_X));
ureg_MOV(ureg, ureg_writemask(src, TGSI_WRITEMASK_XYZ),
ureg_scalar(imm0, TGSI_SWIZZLE_X));
if (!has_mask)
ureg_MOV(ureg, out, ureg_src(src));
}
if (has_mask) {
mask = ureg_DECL_temporary(ureg);
xrender_tex(ureg, mask, mask_pos, mask_sampler, imm0,
mask_repeat_none, mask_swizzle, mask_set_alpha);
/* src IN mask */
src_in_mask(ureg, out, ureg_src(src), ureg_src(mask),
comp_alpha_mask, mask_luminance);
ureg_release_temporary(ureg, mask);
}
ureg_END(ureg);
return ureg_create_shader_and_destroy(ureg, pipe);
}
struct xorg_shaders * xorg_shaders_create(struct xorg_renderer *r)
{
struct xorg_shaders *sc = CALLOC_STRUCT(xorg_shaders);
sc->r = r;
sc->vs_hash = cso_hash_create();
sc->fs_hash = cso_hash_create();
return sc;
}
static void
cache_destroy(struct cso_context *cso,
struct cso_hash *hash,
unsigned processor)
{
struct cso_hash_iter iter = cso_hash_first_node(hash);
while (!cso_hash_iter_is_null(iter)) {
void *shader = (void *)cso_hash_iter_data(iter);
if (processor == PIPE_SHADER_FRAGMENT) {
cso_delete_fragment_shader(cso, shader);
} else if (processor == PIPE_SHADER_VERTEX) {
cso_delete_vertex_shader(cso, shader);
}
iter = cso_hash_erase(hash, iter);
}
cso_hash_delete(hash);
}
void xorg_shaders_destroy(struct xorg_shaders *sc)
{
cache_destroy(sc->r->cso, sc->vs_hash,
PIPE_SHADER_VERTEX);
cache_destroy(sc->r->cso, sc->fs_hash,
PIPE_SHADER_FRAGMENT);
FREE(sc);
}
static INLINE void *
shader_from_cache(struct pipe_context *pipe,
unsigned type,
struct cso_hash *hash,
unsigned key)
{
void *shader = 0;
struct cso_hash_iter iter = cso_hash_find(hash, key);
if (cso_hash_iter_is_null(iter)) {
if (type == PIPE_SHADER_VERTEX)
shader = create_vs(pipe, key);
else
shader = create_fs(pipe, key);
cso_hash_insert(hash, key, shader);
} else
shader = (void *)cso_hash_iter_data(iter);
return shader;
}
struct xorg_shader xorg_shaders_get(struct xorg_shaders *sc,
unsigned vs_traits,
unsigned fs_traits)
{
struct xorg_shader shader = { NULL, NULL };
void *vs, *fs;
vs = shader_from_cache(sc->r->pipe, PIPE_SHADER_VERTEX,
sc->vs_hash, vs_traits);
fs = shader_from_cache(sc->r->pipe, PIPE_SHADER_FRAGMENT,
sc->fs_hash, fs_traits);
debug_assert(vs && fs);
if (!vs || !fs)
return shader;
shader.vs = vs;
shader.fs = fs;
return shader;
}

59
src/gallium/state_trackers/xorg/xorg_exa_tgsi.h
View File

@ -1,59 +0,0 @@
#ifndef XORG_EXA_TGSI_H
#define XORG_EXA_TGSI_H
#include "xorg_renderer.h"
enum xorg_vs_traits {
VS_COMPOSITE = 1 << 0,
VS_MASK = 1 << 1,
VS_SOLID_FILL = 1 << 2,
VS_LINGRAD_FILL = 1 << 3,
VS_RADGRAD_FILL = 1 << 4,
VS_YUV = 1 << 5,
VS_FILL = (VS_SOLID_FILL |
VS_LINGRAD_FILL |
VS_RADGRAD_FILL)
};
enum xorg_fs_traits {
FS_COMPOSITE = 1 << 0,
FS_MASK = 1 << 1,
FS_SOLID_FILL = 1 << 2,
FS_LINGRAD_FILL = 1 << 3,
FS_RADGRAD_FILL = 1 << 4,
FS_CA_FULL = 1 << 5, /* src.rgba * mask.rgba */
FS_CA_SRCALPHA = 1 << 6, /* src.aaaa * mask.rgba */
FS_YUV = 1 << 7,
FS_SRC_REPEAT_NONE = 1 << 8,
FS_MASK_REPEAT_NONE = 1 << 9,
FS_SRC_SWIZZLE_RGB = 1 << 10,
FS_MASK_SWIZZLE_RGB = 1 << 11,
FS_SRC_SET_ALPHA = 1 << 12,
FS_MASK_SET_ALPHA = 1 << 13,
FS_SRC_LUMINANCE = 1 << 14,
FS_MASK_LUMINANCE = 1 << 15,
FS_FILL = (FS_SOLID_FILL |
FS_LINGRAD_FILL |
FS_RADGRAD_FILL),
FS_COMPONENT_ALPHA = (FS_CA_FULL |
FS_CA_SRCALPHA)
};
struct xorg_shader {
void *fs;
void *vs;
};
struct xorg_shaders;
struct xorg_shaders *xorg_shaders_create(struct xorg_renderer *renderer);
void xorg_shaders_destroy(struct xorg_shaders *shaders);
struct xorg_shader xorg_shaders_get(struct xorg_shaders *shaders,
unsigned vs_traits,
unsigned fs_traits);
#endif

331
src/gallium/state_trackers/xorg/xorg_output.c
View File

@ -1,331 +0,0 @@
/*
* 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.
*
*
* Author: Alan Hourihane <alanh@tungstengraphics.com>
* Author: Jakob Bornecrantz <wallbraker@gmail.com>
*
*/
#include "xorg-server.h"
#include <xf86.h>
#include <xf86i2c.h>
#include <xf86Crtc.h>
#include <xf86DDC.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "xorg_tracker.h"
struct output_private
{
drmModeConnectorPtr drm_connector;
drmModePropertyBlobPtr edid_blob;
int fd;
int c;
};
static char *output_enum_list[] = {
"Unknown",
"VGA",
"DVI",
"DVI",
"DVI",
"Composite",
"SVIDEO",
"LVDS",
"CTV",
"DIN",
"DP",
"HDMI",
"HDMI",
};
static void
output_create_resources(xf86OutputPtr output)
{
#ifdef RANDR_12_INTERFACE
#endif /* RANDR_12_INTERFACE */
}
static void
output_dpms(xf86OutputPtr output, int mode)
{
}
static xf86OutputStatus
output_detect(xf86OutputPtr output)
{
modesettingPtr ms = modesettingPTR(output->scrn);
struct output_private *priv = output->driver_private;
drmModeConnectorPtr drm_connector;
xf86OutputStatus status;
drm_connector = drmModeGetConnector(ms->fd, priv->drm_connector->connector_id);
if (drm_connector) {
drmModeFreeConnector(priv->drm_connector);
priv->drm_connector = drm_connector;
} else {
drm_connector = priv->drm_connector;
}
switch (drm_connector->connection) {
case DRM_MODE_CONNECTED:
status = XF86OutputStatusConnected;
break;
case DRM_MODE_DISCONNECTED:
status = XF86OutputStatusDisconnected;
break;
default:
status = XF86OutputStatusUnknown;
}
return status;
}
static DisplayModePtr
output_get_modes(xf86OutputPtr output)
{
struct output_private *priv = output->driver_private;
drmModeConnectorPtr drm_connector = priv->drm_connector;
drmModeModeInfoPtr drm_mode = NULL;
drmModePropertyPtr props = NULL;
xf86MonPtr ddc_mon = NULL;
DisplayModePtr modes = NULL, mode = NULL;
int i;
for (i = 0; i < drm_connector->count_props; i++) {
props = drmModeGetProperty(priv->fd, drm_connector->props[i]);
if (!props)
continue;
if (!(props->flags & DRM_MODE_PROP_BLOB))
goto out_free;
if (!strcmp(props->name, "EDID")) {
if (priv->edid_blob)
drmModeFreePropertyBlob(priv->edid_blob);
priv->edid_blob = drmModeGetPropertyBlob(priv->fd,
drm_connector->prop_values[i]);
}
out_free:
drmModeFreeProperty(props);
}
if (priv->edid_blob) {
ddc_mon = xf86InterpretEDID(output->scrn->scrnIndex,
priv->edid_blob->data);
if (ddc_mon && priv->edid_blob->length > 128)
ddc_mon->flags |= MONITOR_EDID_COMPLETE_RAWDATA;
}
xf86OutputSetEDID(output, ddc_mon);
for (i = 0; i < drm_connector->count_modes; i++) {
drm_mode = &drm_connector->modes[i];
if (drm_mode) {
mode = calloc(1, sizeof(DisplayModeRec));
if (!mode)
continue;
mode->Clock = drm_mode->clock;
mode->HDisplay = drm_mode->hdisplay;
mode->HSyncStart = drm_mode->hsync_start;
mode->HSyncEnd = drm_mode->hsync_end;
mode->HTotal = drm_mode->htotal;
mode->VDisplay = drm_mode->vdisplay;
mode->VSyncStart = drm_mode->vsync_start;
mode->VSyncEnd = drm_mode->vsync_end;
mode->VTotal = drm_mode->vtotal;
mode->Flags = drm_mode->flags;
mode->HSkew = drm_mode->hskew;
mode->VScan = drm_mode->vscan;
mode->VRefresh = xf86ModeVRefresh(mode);
mode->Private = (void *)drm_mode;
mode->type = 0;
if (drm_mode->type & DRM_MODE_TYPE_PREFERRED)
mode->type |= M_T_PREFERRED;
if (drm_mode->type & DRM_MODE_TYPE_DRIVER)
mode->type |= M_T_DRIVER;
xf86SetModeDefaultName(mode);
modes = xf86ModesAdd(modes, mode);
xf86PrintModeline(0, mode);
}
}
return modes;
}
static int
output_mode_valid(xf86OutputPtr output, DisplayModePtr pMode)
{
modesettingPtr ms = modesettingPTR(output->scrn);
CustomizerPtr cust = ms->cust;
if (cust && cust->winsys_check_fb_size &&
!cust->winsys_check_fb_size(cust, pMode->HDisplay *
output->scrn->bitsPerPixel / 8,
pMode->VDisplay))
return MODE_BAD;
return MODE_OK;
}
#ifdef RANDR_12_INTERFACE
static Bool
output_set_property(xf86OutputPtr output, Atom property, RRPropertyValuePtr value)
{
return TRUE;
}
#endif /* RANDR_12_INTERFACE */
#ifdef RANDR_13_INTERFACE
static Bool
output_get_property(xf86OutputPtr output, Atom property)
{
return TRUE;
}
#endif /* RANDR_13_INTERFACE */
static void
output_destroy(xf86OutputPtr output)
{
struct output_private *priv = output->driver_private;
if (priv->edid_blob)
drmModeFreePropertyBlob(priv->edid_blob);
drmModeFreeConnector(priv->drm_connector);
free(priv);
output->driver_private = NULL;
}
static const xf86OutputFuncsRec output_funcs = {
.create_resources = output_create_resources,
#ifdef RANDR_12_INTERFACE
.set_property = output_set_property,
#endif
#ifdef RANDR_13_INTERFACE
.get_property = output_get_property,
#endif
.dpms = output_dpms,
.detect = output_detect,
.get_modes = output_get_modes,
.mode_valid = output_mode_valid,
.destroy = output_destroy,
};
void
xorg_output_init(ScrnInfoPtr pScrn)
{
modesettingPtr ms = modesettingPTR(pScrn);
xf86OutputPtr output;
drmModeResPtr res;
drmModeConnectorPtr drm_connector = NULL;
drmModeEncoderPtr drm_encoder = NULL;
struct output_private *priv;
char name[32];
int c, v, p;
res = drmModeGetResources(ms->fd);
if (res == 0) {
DRV_ERROR("Failed drmModeGetResources\n");
return;
}
for (c = 0; c < res->count_connectors; c++) {
drm_connector = drmModeGetConnector(ms->fd, res->connectors[c]);
if (!drm_connector)
goto out;
#if 0
for (p = 0; p < drm_connector->count_props; p++) {
drmModePropertyPtr prop;
prop = drmModeGetProperty(ms->fd, drm_connector->props[p]);
name = NULL;
if (prop) {
ErrorF("VALUES %d\n", prop->count_values);
for (v = 0; v < prop->count_values; v++)
ErrorF("%s %lld\n", prop->name, prop->values[v]);
}
}
#else
(void)p;
(void)v;
#endif
snprintf(name, 32, "%s%d",
output_enum_list[drm_connector->connector_type],
drm_connector->connector_type_id);
priv = calloc(sizeof(*priv), 1);
if (!priv) {
continue;
}
output = xf86OutputCreate(pScrn, &output_funcs, name);
if (!output) {
free(priv);
continue;
}
drm_encoder = drmModeGetEncoder(ms->fd, drm_connector->encoders[0]);
if (drm_encoder) {
output->possible_crtcs = drm_encoder->possible_crtcs;
output->possible_clones = drm_encoder->possible_clones;
} else {
output->possible_crtcs = 0;
output->possible_clones = 0;
}
priv->c = c;
priv->drm_connector = drm_connector;
priv->fd = ms->fd;
output->driver_private = priv;
output->subpixel_order = SubPixelHorizontalRGB;
output->interlaceAllowed = FALSE;
output->doubleScanAllowed = FALSE;
}
out:
drmModeFreeResources(res);
}
unsigned
xorg_output_get_id(xf86OutputPtr output)
{
struct output_private *priv = output->driver_private;
return priv->drm_connector->connector_id;
}
/* vim: set sw=4 ts=8 sts=4: */

547
src/gallium/state_trackers/xorg/xorg_renderer.c
View File

@ -1,547 +0,0 @@
#include "xorg_exa.h"
#include "xorg_renderer.h"
#include "xorg_exa_tgsi.h"
#include "cso_cache/cso_context.h"
#include "util/u_draw_quad.h"
#include "util/u_math.h"
#include "util/u_memory.h"
#include "util/u_sampler.h"
#include "util/u_inlines.h"
#include "util/u_box.h"
#include <math.h>
#define floatsEqual(x, y) (fabs(x - y) <= 0.00001f * MIN2(fabs(x), fabs(y)))
#define floatIsZero(x) (floatsEqual((x) + 1, 1))
#define NUM_COMPONENTS 4
static INLINE boolean is_affine(float *matrix)
{
return floatIsZero(matrix[2]) && floatIsZero(matrix[5])
&& floatsEqual(matrix[8], 1);
}
static INLINE void map_point(float *mat, float x, float y,
float *out_x, float *out_y)
{
if (!mat) {
*out_x = x;
*out_y = y;
return;
}
*out_x = mat[0]*x + mat[3]*y + mat[6];
*out_y = mat[1]*x + mat[4]*y + mat[7];
if (!is_affine(mat)) {
float w = 1/(mat[2]*x + mat[5]*y + mat[8]);
*out_x *= w;
*out_y *= w;
}
}
static INLINE void
renderer_draw(struct xorg_renderer *r)
{
int num_verts = r->buffer_size/(r->attrs_per_vertex * NUM_COMPONENTS);
if (!r->buffer_size)
return;
cso_set_vertex_elements(r->cso, r->attrs_per_vertex, r->velems);
util_draw_user_vertex_buffer(r->cso, r->buffer, PIPE_PRIM_QUADS,
num_verts, r->attrs_per_vertex);
r->buffer_size = 0;
}
static INLINE void
renderer_draw_conditional(struct xorg_renderer *r,
int next_batch)
{
if (r->buffer_size + next_batch >= BUF_SIZE ||
(next_batch == 0 && r->buffer_size)) {
renderer_draw(r);
}
}
static void
renderer_init_state(struct xorg_renderer *r)
{
struct pipe_depth_stencil_alpha_state dsa;
struct pipe_rasterizer_state raster;
unsigned i;
/* set common initial clip state */
memset(&dsa, 0, sizeof(struct pipe_depth_stencil_alpha_state));
cso_set_depth_stencil_alpha(r->cso, &dsa);
/* XXX: move to renderer_init_state? */
memset(&raster, 0, sizeof(struct pipe_rasterizer_state));
raster.half_pixel_center = 1;
raster.bottom_edge_rule = 1;
raster.depth_clip = 1;
cso_set_rasterizer(r->cso, &raster);
/* vertex elements state */
memset(&r->velems[0], 0, sizeof(r->velems[0]) * 3);
for (i = 0; i < 3; i++) {
r->velems[i].src_offset = i * 4 * sizeof(float);
r->velems[i].instance_divisor = 0;
r->velems[i].vertex_buffer_index = 0;
r->velems[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
}
}
static INLINE void
add_vertex_color(struct xorg_renderer *r,
float x, float y,
float color[4])
{
float *vertex = r->buffer + r->buffer_size;
vertex[0] = x;
vertex[1] = y;
vertex[2] = 0.f; /*z*/
vertex[3] = 1.f; /*w*/
vertex[4] = color[0]; /*r*/
vertex[5] = color[1]; /*g*/
vertex[6] = color[2]; /*b*/
vertex[7] = color[3]; /*a*/
r->buffer_size += 8;
}
static INLINE void
add_vertex_1tex(struct xorg_renderer *r,
float x, float y, float s, float t)
{
float *vertex = r->buffer + r->buffer_size;
vertex[0] = x;
vertex[1] = y;
vertex[2] = 0.f; /*z*/
vertex[3] = 1.f; /*w*/
vertex[4] = s; /*s*/
vertex[5] = t; /*t*/
vertex[6] = 0.f; /*r*/
vertex[7] = 1.f; /*q*/
r->buffer_size += 8;
}
static void
add_vertex_data1(struct xorg_renderer *r,
float srcX, float srcY, float dstX, float dstY,
float width, float height,
struct pipe_resource *src, float *src_matrix)
{
float s0, t0, s1, t1, s2, t2, s3, t3;
float pt0[2], pt1[2], pt2[2], pt3[2];
pt0[0] = srcX;
pt0[1] = srcY;
pt1[0] = (srcX + width);
pt1[1] = srcY;
pt2[0] = (srcX + width);
pt2[1] = (srcY + height);
pt3[0] = srcX;
pt3[1] = (srcY + height);
if (src_matrix) {
map_point(src_matrix, pt0[0], pt0[1], &pt0[0], &pt0[1]);
map_point(src_matrix, pt1[0], pt1[1], &pt1[0], &pt1[1]);
map_point(src_matrix, pt2[0], pt2[1], &pt2[0], &pt2[1]);
map_point(src_matrix, pt3[0], pt3[1], &pt3[0], &pt3[1]);
}
s0 = pt0[0] / src->width0;
s1 = pt1[0] / src->width0;
s2 = pt2[0] / src->width0;
s3 = pt3[0] / src->width0;
t0 = pt0[1] / src->height0;
t1 = pt1[1] / src->height0;
t2 = pt2[1] / src->height0;
t3 = pt3[1] / src->height0;
/* 1st vertex */
add_vertex_1tex(r, dstX, dstY, s0, t0);
/* 2nd vertex */
add_vertex_1tex(r, dstX + width, dstY, s1, t1);
/* 3rd vertex */
add_vertex_1tex(r, dstX + width, dstY + height, s2, t2);
/* 4th vertex */
add_vertex_1tex(r, dstX, dstY + height, s3, t3);
}
static INLINE void
add_vertex_2tex(struct xorg_renderer *r,
float x, float y,
float s0, float t0, float s1, float t1)
{
float *vertex = r->buffer + r->buffer_size;
vertex[0] = x;
vertex[1] = y;
vertex[2] = 0.f; /*z*/
vertex[3] = 1.f; /*w*/
vertex[4] = s0; /*s*/
vertex[5] = t0; /*t*/
vertex[6] = 0.f; /*r*/
vertex[7] = 1.f; /*q*/
vertex[8] = s1; /*s*/
vertex[9] = t1; /*t*/
vertex[10] = 0.f; /*r*/
vertex[11] = 1.f; /*q*/
r->buffer_size += 12;
}
static void
add_vertex_data2(struct xorg_renderer *r,
float srcX, float srcY, float maskX, float maskY,
float dstX, float dstY, float width, float height,
struct pipe_resource *src,
struct pipe_resource *mask,
float *src_matrix, float *mask_matrix)
{
float src_s0, src_t0, src_s1, src_t1, src_s2, src_t2, src_s3, src_t3;
float mask_s0, mask_t0, mask_s1, mask_t1, mask_s2, mask_t2, mask_s3, mask_t3;
float spt0[2], spt1[2], spt2[2], spt3[2];
float mpt0[2], mpt1[2], mpt2[2], mpt3[2];
spt0[0] = srcX;
spt0[1] = srcY;
spt1[0] = (srcX + width);
spt1[1] = srcY;
spt2[0] = (srcX + width);
spt2[1] = (srcY + height);
spt3[0] = srcX;
spt3[1] = (srcY + height);
mpt0[0] = maskX;
mpt0[1] = maskY;
mpt1[0] = (maskX + width);
mpt1[1] = maskY;
mpt2[0] = (maskX + width);
mpt2[1] = (maskY + height);
mpt3[0] = maskX;
mpt3[1] = (maskY + height);
if (src_matrix) {
map_point(src_matrix, spt0[0], spt0[1], &spt0[0], &spt0[1]);
map_point(src_matrix, spt1[0], spt1[1], &spt1[0], &spt1[1]);
map_point(src_matrix, spt2[0], spt2[1], &spt2[0], &spt2[1]);
map_point(src_matrix, spt3[0], spt3[1], &spt3[0], &spt3[1]);
}
if (mask_matrix) {
map_point(mask_matrix, mpt0[0], mpt0[1], &mpt0[0], &mpt0[1]);
map_point(mask_matrix, mpt1[0], mpt1[1], &mpt1[0], &mpt1[1]);
map_point(mask_matrix, mpt2[0], mpt2[1], &mpt2[0], &mpt2[1]);
map_point(mask_matrix, mpt3[0], mpt3[1], &mpt3[0], &mpt3[1]);
}
src_s0 = spt0[0] / src->width0;
src_s1 = spt1[0] / src->width0;
src_s2 = spt2[0] / src->width0;
src_s3 = spt3[0] / src->width0;
src_t0 = spt0[1] / src->height0;
src_t1 = spt1[1] / src->height0;
src_t2 = spt2[1] / src->height0;
src_t3 = spt3[1] / src->height0;
mask_s0 = mpt0[0] / mask->width0;
mask_s1 = mpt1[0] / mask->width0;
mask_s2 = mpt2[0] / mask->width0;
mask_s3 = mpt3[0] / mask->width0;
mask_t0 = mpt0[1] / mask->height0;
mask_t1 = mpt1[1] / mask->height0;
mask_t2 = mpt2[1] / mask->height0;
mask_t3 = mpt3[1] / mask->height0;
/* 1st vertex */
add_vertex_2tex(r, dstX, dstY,
src_s0, src_t0, mask_s0, mask_t0);
/* 2nd vertex */
add_vertex_2tex(r, dstX + width, dstY,
src_s1, src_t1, mask_s1, mask_t1);
/* 3rd vertex */
add_vertex_2tex(r, dstX + width, dstY + height,
src_s2, src_t2, mask_s2, mask_t2);
/* 4th vertex */
add_vertex_2tex(r, dstX, dstY + height,
src_s3, src_t3, mask_s3, mask_t3);
}
static void
setup_vertex_data_yuv(struct xorg_renderer *r,
float srcX, float srcY, float srcW, float srcH,
float dstX, float dstY, float dstW, float dstH,
struct pipe_resource **tex)
{
float s0, t0, s1, t1;
float spt0[2], spt1[2];
spt0[0] = srcX;
spt0[1] = srcY;
spt1[0] = srcX + srcW;
spt1[1] = srcY + srcH;
s0 = spt0[0] / tex[0]->width0;
t0 = spt0[1] / tex[0]->height0;
s1 = spt1[0] / tex[0]->width0;
t1 = spt1[1] / tex[0]->height0;
/* 1st vertex */
add_vertex_1tex(r, dstX, dstY, s0, t0);
/* 2nd vertex */
add_vertex_1tex(r, dstX + dstW, dstY,
s1, t0);
/* 3rd vertex */
add_vertex_1tex(r, dstX + dstW, dstY + dstH,
s1, t1);
/* 4th vertex */
add_vertex_1tex(r, dstX, dstY + dstH,
s0, t1);
}
/* Set up framebuffer, viewport and vertex shader constant buffer
* state for a particular destinaton surface. In all our rendering,
* these concepts are linked.
*/
void renderer_bind_destination(struct xorg_renderer *r,
struct pipe_surface *surface,
int width,
int height )
{
struct pipe_framebuffer_state fb;
struct pipe_viewport_state viewport;
/* Framebuffer uses actual surface width/height
*/
memset(&fb, 0, sizeof fb);
fb.width = surface->width;
fb.height = surface->height;
fb.nr_cbufs = 1;
fb.cbufs[0] = surface;
fb.zsbuf = 0;
/* Viewport just touches the bit we're interested in:
*/
viewport.scale[0] = width / 2.f;
viewport.scale[1] = height / 2.f;
viewport.scale[2] = 1.0;
viewport.scale[3] = 1.0;
viewport.translate[0] = width / 2.f;
viewport.translate[1] = height / 2.f;
viewport.translate[2] = 0.0;
viewport.translate[3] = 0.0;
/* Constant buffer set up to match viewport dimensions:
*/
if (r->fb_width != width ||
r->fb_height != height)
{
float vs_consts[8] = {
2.f/width, 2.f/height, 1, 1,
-1, -1, 0, 0
};
r->fb_width = width;
r->fb_height = height;
renderer_set_constants(r, PIPE_SHADER_VERTEX,
vs_consts, sizeof vs_consts);
}
cso_set_framebuffer(r->cso, &fb);
cso_set_viewport(r->cso, &viewport);
}
struct xorg_renderer * renderer_create(struct pipe_context *pipe)
{
struct xorg_renderer *renderer = CALLOC_STRUCT(xorg_renderer);
renderer->pipe = pipe;
renderer->cso = cso_create_context(pipe);
renderer->shaders = xorg_shaders_create(renderer);
renderer_init_state(renderer);
return renderer;
}
void renderer_destroy(struct xorg_renderer *r)
{
struct pipe_resource **vsbuf = &r->vs_const_buffer;
struct pipe_resource **fsbuf = &r->fs_const_buffer;
if (*vsbuf)
pipe_resource_reference(vsbuf, NULL);
if (*fsbuf)
pipe_resource_reference(fsbuf, NULL);
if (r->shaders) {
xorg_shaders_destroy(r->shaders);
r->shaders = NULL;
}
if (r->cso) {
cso_release_all(r->cso);
cso_destroy_context(r->cso);
r->cso = NULL;
}
}
void renderer_set_constants(struct xorg_renderer *r,
int shader_type,
const float *params,
int param_bytes)
{
struct pipe_resource **cbuf =
(shader_type == PIPE_SHADER_VERTEX) ? &r->vs_const_buffer :
&r->fs_const_buffer;
pipe_resource_reference(cbuf, NULL);
*cbuf = pipe_buffer_create(r->pipe->screen,
PIPE_BIND_CONSTANT_BUFFER,
PIPE_USAGE_STATIC,
param_bytes);
if (*cbuf) {
pipe_buffer_write(r->pipe, *cbuf,
0, param_bytes, params);
}
pipe_set_constant_buffer(r->pipe, shader_type, 0, *cbuf);
}
void renderer_draw_yuv(struct xorg_renderer *r,
float src_x, float src_y, float src_w, float src_h,
int dst_x, int dst_y, int dst_w, int dst_h,
struct pipe_resource **textures)
{
const int num_attribs = 2; /*pos + tex coord*/
setup_vertex_data_yuv(r,
src_x, src_y, src_w, src_h,
dst_x, dst_y, dst_w, dst_h,
textures);
cso_set_vertex_elements(r->cso, num_attribs, r->velems);
util_draw_user_vertex_buffer(r->cso, r->buffer,
PIPE_PRIM_QUADS,
4, /* verts */
num_attribs); /* attribs/vert */
r->buffer_size = 0;
}
void renderer_begin_solid(struct xorg_renderer *r)
{
r->buffer_size = 0;
r->attrs_per_vertex = 2;
}
void renderer_solid(struct xorg_renderer *r,
int x0, int y0,
int x1, int y1,
float *color)
{
/*
debug_printf("solid rect[(%d, %d), (%d, %d)], rgba[%f, %f, %f, %f]\n",
x0, y0, x1, y1, color[0], color[1], color[2], color[3]);*/
renderer_draw_conditional(r, 4 * 8);
/* 1st vertex */
add_vertex_color(r, x0, y0, color);
/* 2nd vertex */
add_vertex_color(r, x1, y0, color);
/* 3rd vertex */
add_vertex_color(r, x1, y1, color);
/* 4th vertex */
add_vertex_color(r, x0, y1, color);
}
void renderer_draw_flush(struct xorg_renderer *r)
{
renderer_draw_conditional(r, 0);
}
void renderer_begin_textures(struct xorg_renderer *r,
int num_textures)
{
r->attrs_per_vertex = 1 + num_textures;
r->buffer_size = 0;
}
void renderer_texture(struct xorg_renderer *r,
int *pos,
int width, int height,
struct pipe_sampler_view **sampler_view,
int num_textures,
float *src_matrix,
float *mask_matrix)
{
#if 0
if (src_matrix) {
debug_printf("src_matrix = \n");
debug_printf("%f, %f, %f\n", src_matrix[0], src_matrix[1], src_matrix[2]);
debug_printf("%f, %f, %f\n", src_matrix[3], src_matrix[4], src_matrix[5]);
debug_printf("%f, %f, %f\n", src_matrix[6], src_matrix[7], src_matrix[8]);
}
if (mask_matrix) {
debug_printf("mask_matrix = \n");
debug_printf("%f, %f, %f\n", mask_matrix[0], mask_matrix[1], mask_matrix[2]);
debug_printf("%f, %f, %f\n", mask_matrix[3], mask_matrix[4], mask_matrix[5]);
debug_printf("%f, %f, %f\n", mask_matrix[6], mask_matrix[7], mask_matrix[8]);
}
#endif
switch(r->attrs_per_vertex) {
case 2:
renderer_draw_conditional(r, 4 * 8);
add_vertex_data1(r,
pos[0], pos[1], /* src */
pos[4], pos[5], /* dst */
width, height,
sampler_view[0]->texture, src_matrix);
break;
case 3:
renderer_draw_conditional(r, 4 * 12);
add_vertex_data2(r,
pos[0], pos[1], /* src */
pos[2], pos[3], /* mask */
pos[4], pos[5], /* dst */
width, height,
sampler_view[0]->texture, sampler_view[1]->texture,
src_matrix, mask_matrix);
break;
default:
debug_assert(!"Unsupported number of textures");
break;
}
}

81
src/gallium/state_trackers/xorg/xorg_renderer.h
View File

@ -1,81 +0,0 @@
#ifndef XORG_RENDERER_H
#define XORG_RENDERER_H
#include "pipe/p_context.h"
#include "pipe/p_state.h"
struct xorg_shaders;
struct exa_pixmap_priv;
/* max number of vertices *
* max number of attributes per vertex *
* max number of components per attribute
*
* currently the max is 100 quads
*/
#define BUF_SIZE (100 * 4 * 3 * 4)
struct xorg_renderer {
struct pipe_context *pipe;
struct cso_context *cso;
struct xorg_shaders *shaders;
int fb_width;
int fb_height;
struct pipe_resource *vs_const_buffer;
struct pipe_resource *fs_const_buffer;
float buffer[BUF_SIZE];
int buffer_size;
struct pipe_vertex_element velems[3];
/* number of attributes per vertex for the current
* draw operation */
int attrs_per_vertex;
};
struct xorg_renderer *renderer_create(struct pipe_context *pipe);
void renderer_destroy(struct xorg_renderer *renderer);
void renderer_bind_destination(struct xorg_renderer *r,
struct pipe_surface *surface,
int width,
int height );
void renderer_bind_framebuffer(struct xorg_renderer *r,
struct exa_pixmap_priv *priv);
void renderer_bind_viewport(struct xorg_renderer *r,
struct exa_pixmap_priv *dst);
void renderer_set_constants(struct xorg_renderer *r,
int shader_type,
const float *buffer,
int size);
void renderer_draw_yuv(struct xorg_renderer *r,
float src_x, float src_y, float src_w, float src_h,
int dst_x, int dst_y, int dst_w, int dst_h,
struct pipe_resource **textures);
void renderer_begin_solid(struct xorg_renderer *r);
void renderer_solid(struct xorg_renderer *r,
int x0, int y0,
int x1, int y1,
float *color);
void renderer_begin_textures(struct xorg_renderer *r,
int num_textures);
void renderer_texture(struct xorg_renderer *r,
int *pos,
int width, int height,
struct pipe_sampler_view **textures,
int num_textures,
float *src_matrix,
float *mask_matrix);
void renderer_draw_flush(struct xorg_renderer *r);
#endif

236
src/gallium/state_trackers/xorg/xorg_tracker.h
View File

@ -1,236 +0,0 @@
/*
* 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.
*
*
* Author: Alan Hourihane <alanh@tungstengraphics.com>
* Author: Jakob Bornecrantz <wallbraker@gmail.com>
*
*/
#ifndef _XORG_TRACKER_H_
#define _XORG_TRACKER_H_
#include <stddef.h>
#include <stdint.h>
#include <errno.h>
#include <drm.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <xorg-server.h>
#include <xf86.h>
#include "xf86Crtc.h"
#include <exa.h>
#ifdef DRM_MODE_FEATURE_DIRTYFB
#include <damage.h>
#endif
/* Prevent symbol clash */
#undef Absolute
#include "compat-api.h"
#include "pipe/p_screen.h"
#include "util/u_inlines.h"
#include "util/u_debug.h"
#define DRV_ERROR(msg) xf86DrvMsg(pScrn->scrnIndex, X_ERROR, msg);
struct kms_bo;
struct kms_driver;
struct exa_context;
typedef struct
{
int lastInstance;
int refCount;
ScrnInfoPtr pScrn_1;
ScrnInfoPtr pScrn_2;
} EntRec, *EntPtr;
#define XORG_NR_FENCES 3
enum xorg_throttling_reason {
THROTTLE_RENDER,
THROTTLE_SWAP
};
typedef struct _CustomizerRec
{
Bool dirty_throttling;
Bool swap_throttling;
Bool no_3d;
Bool unhidden_hw_cursor_update;
Bool (*winsys_pre_init) (struct _CustomizerRec *cust, int fd);
Bool (*winsys_screen_init)(struct _CustomizerRec *cust);
Bool (*winsys_screen_close)(struct _CustomizerRec *cust);
Bool (*winsys_enter_vt)(struct _CustomizerRec *cust);
Bool (*winsys_leave_vt)(struct _CustomizerRec *cust);
void (*winsys_context_throttle)(struct _CustomizerRec *cust,
struct pipe_context *pipe,
enum xorg_throttling_reason reason);
Bool (*winsys_check_fb_size) (struct _CustomizerRec *cust,
unsigned long pitch,
unsigned long height);
} CustomizerRec, *CustomizerPtr;
typedef struct _modesettingRec
{
/* drm */
int fd;
unsigned fb_id;
/* X */
EntPtr entityPrivate;
int Chipset;
EntityInfoPtr pEnt;
struct pci_device *PciInfo;
Bool noAccel;
Bool SWCursor;
CursorPtr cursor;
Bool swapThrottling;
Bool dirtyThrottling;
CloseScreenProcPtr CloseScreen;
Bool no3D;
Bool from_3D;
Bool isMaster;
/* Broken-out options. */
OptionInfoPtr Options;
void (*blockHandler)(BLOCKHANDLER_ARGS_DECL);
struct pipe_fence_handle *fence[XORG_NR_FENCES];
CreateScreenResourcesProcPtr createScreenResources;
/* for frontbuffer backing store */
Bool (*destroy_front_buffer)(ScrnInfoPtr pScrn);
Bool (*create_front_buffer)(ScrnInfoPtr pScrn);
Bool (*bind_front_buffer)(ScrnInfoPtr pScrn);
/* kms */
struct kms_driver *kms;
struct kms_bo *root_bo;
uint16_t lut_r[256], lut_g[256], lut_b[256];
/* gallium */
struct pipe_screen *screen;
struct pipe_context *ctx;
boolean d_depth_bits_last;
boolean ds_depth_bits_last;
struct pipe_resource *root_texture;
/* exa */
struct exa_context *exa;
Bool noEvict;
Bool accelerate_2d;
Bool debug_fallback;
CustomizerPtr cust;
#ifdef DRM_MODE_FEATURE_DIRTYFB
DamagePtr damage;
#endif
} modesettingRec, *modesettingPtr;
#define modesettingPTR(p) ((modesettingPtr)((p)->driverPrivate))
CustomizerPtr xorg_customizer(ScrnInfoPtr pScrn);
Bool xorg_has_gallium(ScrnInfoPtr pScrn);
void xorg_flush(ScreenPtr pScreen);
/***********************************************************************
* xorg_exa.c
*/
struct pipe_resource *
xorg_exa_get_texture(PixmapPtr pPixmap);
int
xorg_exa_set_displayed_usage(PixmapPtr pPixmap);
int
xorg_exa_set_shared_usage(PixmapPtr pPixmap);
Bool
xorg_exa_set_texture(PixmapPtr pPixmap, struct pipe_resource *tex);
struct pipe_resource *
xorg_exa_create_root_texture(ScrnInfoPtr pScrn,
int width, int height,
int depth, int bpp);
void *
xorg_exa_init(ScrnInfoPtr pScrn, Bool accel);
void
xorg_exa_close(ScrnInfoPtr pScrn);
/***********************************************************************
* xorg_dri2.c
*/
Bool
xorg_dri2_init(ScreenPtr pScreen);
void
xorg_dri2_close(ScreenPtr pScreen);
/***********************************************************************
* xorg_crtc.c
*/
void
xorg_crtc_init(ScrnInfoPtr pScrn);
void
xorg_crtc_cursor_destroy(xf86CrtcPtr crtc);
/***********************************************************************
* xorg_output.c
*/
void
xorg_output_init(ScrnInfoPtr pScrn);
unsigned
xorg_output_get_id(xf86OutputPtr output);
/***********************************************************************
* xorg_xv.c
*/
void
xorg_xv_init(ScreenPtr pScreen);
/***********************************************************************
* xorg_xvmc.c
*/
void
xorg_xvmc_init(ScreenPtr pScreen, char *name);
#endif /* _XORG_TRACKER_H_ */

50
src/gallium/state_trackers/xorg/xorg_winsys.h
View File

@ -1,50 +0,0 @@
/*
* 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.
*
*
* Author: Alan Hourihane <alanh@tungstengraphics.com>
* Author: Jakob Bornecrantz <wallbraker@gmail.com>
*
*/
/*
* File with all the junk needed to personalize the a xorg driver.
*/
#ifndef _XORG_WINSYS_H_
#define _XORG_WINSYS_H_
#include "xorg-server.h"
#include "xf86.h"
#include "pciaccess.h"
#ifndef XSERVER_LIBPCIACCESS
#error "libpciaccess needed"
#endif
void xorg_tracker_set_functions(ScrnInfoPtr scrn);
const OptionInfoRec * xorg_tracker_available_options(int chipid, int busid);
Bool xorg_tracker_have_modesetting(ScrnInfoPtr pScrn, struct pci_device *device);
#endif

750
src/gallium/state_trackers/xorg/xorg_xv.c
View File

@ -1,750 +0,0 @@
#include "xorg_tracker.h"
#include <xf86xv.h>
#include <X11/extensions/Xv.h>
#include <fourcc.h>
#include "xorg_exa.h"
#include "xorg_renderer.h"
#include "xorg_exa_tgsi.h"
#include "cso_cache/cso_context.h"
#include "util/u_sampler.h"
#include "pipe/p_screen.h"
/*XXX get these from pipe's texture limits */
#define IMAGE_MAX_WIDTH 2048
#define IMAGE_MAX_HEIGHT 2048
#define RES_720P_X 1280
#define RES_720P_Y 720
/* The ITU-R BT.601 conversion matrix for SDTV. */
/* original, matrix, but we transpose it to
* make the shader easier
static const float bt_601[] = {
1.0, 0.0, 1.4075, ,
1.0, -0.3455, -0.7169, 0,
1.0, 1.7790, 0., 0,
};*/
static const float bt_601[] = {
1.0, 1.0, 1.0, 0.5,
0.0, -0.3455, 1.7790, 0,
1.4075, -0.7169, 0., 0,
};
/* The ITU-R BT.709 conversion matrix for HDTV. */
/* original, but we transpose to make the conversion
* in the shader easier
static const float bt_709[] = {
1.0, 0.0, 1.581, 0,
1.0, -0.1881, -0.47, 0,
1.0, 1.8629, 0., 0,
};*/
static const float bt_709[] = {
1.0, 1.0, 1.0, 0.5,
0.0, -0.1881, 1.8629, 0,
1.581,-0.47 , 0.0, 0,
};
#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
static Atom xvBrightness, xvContrast;
#define NUM_TEXTURED_ATTRIBUTES 2
static XF86AttributeRec TexturedAttributes[NUM_TEXTURED_ATTRIBUTES] = {
{XvSettable | XvGettable, -128, 127, "XV_BRIGHTNESS"},
{XvSettable | XvGettable, 0, 255, "XV_CONTRAST"}
};
#define NUM_FORMATS 3
static XF86VideoFormatRec Formats[NUM_FORMATS] = {
{15, TrueColor}, {16, TrueColor}, {24, TrueColor}
};
static XF86VideoEncodingRec DummyEncoding[1] = {
{
0,
"XV_IMAGE",
IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT,
{1, 1}
}
};
#define NUM_IMAGES 3
static XF86ImageRec Images[NUM_IMAGES] = {
XVIMAGE_UYVY,
XVIMAGE_YUY2,
XVIMAGE_YV12,
};
struct xorg_xv_port_priv {
struct xorg_renderer *r;
RegionRec clip;
int brightness;
int contrast;
int current_set;
/* juggle two sets of seperate Y, U and V
* textures */
struct pipe_resource *yuv[2][3];
struct pipe_sampler_view *yuv_views[2][3];
};
static void
stop_video(ScrnInfoPtr pScrn, pointer data, Bool shutdown)
{
struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data;
REGION_EMPTY(pScrn->pScreen, &priv->clip);
}
static int
set_port_attribute(ScrnInfoPtr pScrn,
Atom attribute, INT32 value, pointer data)
{
struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data;
if (attribute == xvBrightness) {
if ((value < -128) || (value > 127))
return BadValue;
priv->brightness = value;
} else if (attribute == xvContrast) {
if ((value < 0) || (value > 255))
return BadValue;
priv->contrast = value;
} else
return BadMatch;
return Success;
}
static int
get_port_attribute(ScrnInfoPtr pScrn,
Atom attribute, INT32 * value, pointer data)
{
struct xorg_xv_port_priv *priv = (struct xorg_xv_port_priv *)data;
if (attribute == xvBrightness)
*value = priv->brightness;
else if (attribute == xvContrast)
*value = priv->contrast;
else
return BadMatch;
return Success;
}
static void
query_best_size(ScrnInfoPtr pScrn,
Bool motion,
short vid_w, short vid_h,
short drw_w, short drw_h,
unsigned int *p_w, unsigned int *p_h, pointer data)
{
if (vid_w > (drw_w << 1))
drw_w = vid_w >> 1;
if (vid_h > (drw_h << 1))
drw_h = vid_h >> 1;
*p_w = drw_w;
*p_h = drw_h;
}
static INLINE struct pipe_resource *
create_component_texture(struct pipe_context *pipe,
int width, int height)
{
struct pipe_screen *screen = pipe->screen;
struct pipe_resource *tex = 0;
struct pipe_resource templ;
memset(&templ, 0, sizeof(templ));
templ.target = PIPE_TEXTURE_2D;
templ.format = PIPE_FORMAT_L8_UNORM;
templ.last_level = 0;
templ.width0 = width;
templ.height0 = height;
templ.depth0 = 1;
templ.array_size = 1;
templ.bind = PIPE_BIND_SAMPLER_VIEW;
tex = screen->resource_create(screen, &templ);
return tex;
}
static int
check_yuv_textures(struct xorg_xv_port_priv *priv, int width, int height)
{
struct pipe_resource **dst = priv->yuv[priv->current_set];
struct pipe_sampler_view **dst_view = priv->yuv_views[priv->current_set];
struct pipe_sampler_view view_templ;
struct pipe_context *pipe = priv->r->pipe;
if (!dst[0] ||
dst[0]->width0 != width ||
dst[0]->height0 != height) {
pipe_resource_reference(&dst[0], NULL);
pipe_sampler_view_reference(&dst_view[0], NULL);
}
if (!dst[1] ||
dst[1]->width0 != width ||
dst[1]->height0 != height) {
pipe_resource_reference(&dst[1], NULL);
pipe_sampler_view_reference(&dst_view[1], NULL);
}
if (!dst[2] ||
dst[2]->width0 != width ||
dst[2]->height0 != height) {
pipe_resource_reference(&dst[2], NULL);
pipe_sampler_view_reference(&dst_view[2], NULL);
}
if (!dst[0]) {
dst[0] = create_component_texture(priv->r->pipe, width, height);
if (dst[0]) {
u_sampler_view_default_template(&view_templ,
dst[0],
dst[0]->format);
dst_view[0] = pipe->create_sampler_view(pipe, dst[0], &view_templ);
}
}
if (!dst[1]) {
dst[1] = create_component_texture(priv->r->pipe, width, height);
if (dst[1]) {
u_sampler_view_default_template(&view_templ,
dst[1],
dst[1]->format);
dst_view[1] = pipe->create_sampler_view(pipe, dst[1], &view_templ);
}
}
if (!dst[2]) {
dst[2] = create_component_texture(priv->r->pipe, width, height);
if (dst[2]) {
u_sampler_view_default_template(&view_templ,
dst[2],
dst[2]->format);
dst_view[2] = pipe->create_sampler_view(pipe, dst[2], &view_templ);
}
}
if (!dst[0] || !dst[1] || !dst[2] || !dst_view[0] || !dst_view[1] || !dst_view[2] )
return BadAlloc;
return Success;
}
static int
query_image_attributes(ScrnInfoPtr pScrn,
int id,
unsigned short *w, unsigned short *h,
int *pitches, int *offsets)
{
int size, tmp;
if (*w > IMAGE_MAX_WIDTH)
*w = IMAGE_MAX_WIDTH;
if (*h > IMAGE_MAX_HEIGHT)
*h = IMAGE_MAX_HEIGHT;
*w = (*w + 1) & ~1;
if (offsets)
offsets[0] = 0;
switch (id) {
case FOURCC_YV12:
*h = (*h + 1) & ~1;
size = (*w + 3) & ~3;
if (pitches) {
pitches[0] = size;
}
size *= *h;
if (offsets) {
offsets[1] = size;
}
tmp = ((*w >> 1) + 3) & ~3;
if (pitches) {
pitches[1] = pitches[2] = tmp;
}
tmp *= (*h >> 1);
size += tmp;
if (offsets) {
offsets[2] = size;
}
size += tmp;
break;
case FOURCC_UYVY:
case FOURCC_YUY2:
default:
size = *w << 1;
if (pitches)
pitches[0] = size;
size *= *h;
break;
}
return size;
}
static void
copy_packed_data(ScrnInfoPtr pScrn,
struct xorg_xv_port_priv *port,
int id,
unsigned char *buf,
int left,
int top,
unsigned short w, unsigned short h)
{
int i, j;
struct pipe_resource **dst = port->yuv[port->current_set];
struct pipe_transfer *ytrans, *utrans, *vtrans;
struct pipe_context *pipe = port->r->pipe;
char *ymap, *vmap, *umap;
unsigned char y1, y2, u, v;
int yidx, uidx, vidx;
int y_array_size = w * h;
ymap = pipe_transfer_map(pipe, dst[0],
0, 0,
PIPE_TRANSFER_WRITE,
left, top, w, h, &ytrans);
umap = pipe_transfer_map(pipe, dst[1],
0, 0,
PIPE_TRANSFER_WRITE,
left, top, w, h, &utrans);
vmap = pipe_transfer_map(pipe, dst[2],
0, 0,
PIPE_TRANSFER_WRITE,
left, top, w, h, &vtrans);
yidx = uidx = vidx = 0;
switch (id) {
case FOURCC_YV12: {
int pitches[3], offsets[3];
unsigned char *y, *u, *v;
query_image_attributes(pScrn, FOURCC_YV12,
&w, &h, pitches, offsets);
y = buf + offsets[0];
v = buf + offsets[1];
u = buf + offsets[2];
for (i = 0; i < h; ++i) {
for (j = 0; j < w; ++j) {
int yoffset = (w*i+j);
int ii = (i|1), jj = (j|1);
int vuoffset = (w/2)*(ii/2) + (jj/2);
ymap[yidx++] = y[yoffset];
umap[uidx++] = u[vuoffset];
vmap[vidx++] = v[vuoffset];
}
}
}
break;
case FOURCC_UYVY:
for (i = 0; i < y_array_size; i +=2 ) {
/* extracting two pixels */
u = buf[0];
y1 = buf[1];
v = buf[2];
y2 = buf[3];
buf += 4;
ymap[yidx++] = y1;
ymap[yidx++] = y2;
umap[uidx++] = u;
umap[uidx++] = u;
vmap[vidx++] = v;
vmap[vidx++] = v;
}
break;
case FOURCC_YUY2:
for (i = 0; i < y_array_size; i +=2 ) {
/* extracting two pixels */
y1 = buf[0];
u = buf[1];
y2 = buf[2];
v = buf[3];
buf += 4;
ymap[yidx++] = y1;
ymap[yidx++] = y2;
umap[uidx++] = u;
umap[uidx++] = u;
vmap[vidx++] = v;
vmap[vidx++] = v;
}
break;
default:
debug_assert(!"Unsupported yuv format!");
break;
}
pipe->transfer_unmap(pipe, ytrans);
pipe->transfer_unmap(pipe, utrans);
pipe->transfer_unmap(pipe, vtrans);
}
static void
setup_fs_video_constants(struct xorg_renderer *r, boolean hdtv)
{
const int param_bytes = 12 * sizeof(float);
const float *video_constants = (hdtv) ? bt_709 : bt_601;
renderer_set_constants(r, PIPE_SHADER_FRAGMENT,
video_constants, param_bytes);
}
static void
draw_yuv(struct xorg_xv_port_priv *port,
float src_x, float src_y, float src_w, float src_h,
int dst_x, int dst_y, int dst_w, int dst_h)
{
struct pipe_resource **textures = port->yuv[port->current_set];
/*debug_printf(" draw_yuv([%d, %d, %d ,%d], [%d, %d, %d, %d])\n",
src_x, src_y, src_w, src_h,
dst_x, dst_y, dst_w, dst_h);*/
renderer_draw_yuv(port->r,
src_x, src_y, src_w, src_h,
dst_x, dst_y, dst_w, dst_h,
textures);
}
static void
bind_blend_state(struct xorg_xv_port_priv *port)
{
struct pipe_blend_state blend;
memset(&blend, 0, sizeof(struct pipe_blend_state));
blend.rt[0].blend_enable = 0;
blend.rt[0].colormask = PIPE_MASK_RGBA;
/* porter&duff src */
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;
cso_set_blend(port->r->cso, &blend);
}
static void
bind_shaders(struct xorg_xv_port_priv *port)
{
unsigned vs_traits = 0, fs_traits = 0;
struct xorg_shader shader;
vs_traits |= VS_YUV;
fs_traits |= FS_YUV;
shader = xorg_shaders_get(port->r->shaders, vs_traits, fs_traits);
cso_set_vertex_shader_handle(port->r->cso, shader.vs);
cso_set_fragment_shader_handle(port->r->cso, shader.fs);
}
static void
bind_samplers(struct xorg_xv_port_priv *port)
{
struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];
struct pipe_sampler_state sampler;
struct pipe_sampler_view **dst_views = port->yuv_views[port->current_set];
memset(&sampler, 0, sizeof(struct pipe_sampler_state));
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;
sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
sampler.normalized_coords = 1;
samplers[0] = &sampler;
samplers[1] = &sampler;
samplers[2] = &sampler;
cso_set_samplers(port->r->cso, PIPE_SHADER_FRAGMENT, 3,
(const struct pipe_sampler_state **)samplers);
cso_set_sampler_views(port->r->cso, PIPE_SHADER_FRAGMENT, 3, dst_views);
}
static int
display_video(ScrnInfoPtr pScrn, struct xorg_xv_port_priv *pPriv, int id,
RegionPtr dstRegion,
int src_x, int src_y, int src_w, int src_h,
int dstX, int dstY, int dst_w, int dst_h,
PixmapPtr pPixmap)
{
modesettingPtr ms = modesettingPTR(pScrn);
BoxPtr pbox;
int nbox;
Bool hdtv;
int x, y, w, h;
struct exa_pixmap_priv *dst;
struct pipe_surface *dst_surf = NULL;
exaMoveInPixmap(pPixmap);
dst = exaGetPixmapDriverPrivate(pPixmap);
/*debug_printf("display_video([%d, %d, %d, %d], [%d, %d, %d, %d])\n",
src_x, src_y, src_w, src_h, dstX, dstY, dst_w, dst_h);*/
if (dst && !dst->tex) {
xorg_exa_set_shared_usage(pPixmap);
pScrn->pScreen->ModifyPixmapHeader(pPixmap, 0, 0, 0, 0, 0, NULL);
}
if (!dst || !dst->tex)
XORG_FALLBACK("Xv destination %s", !dst ? "!dst" : "!dst->tex");
dst_surf = xorg_gpu_surface(pPriv->r->pipe, dst);
hdtv = ((src_w >= RES_720P_X) && (src_h >= RES_720P_Y));
#ifdef COMPOSITE
REGION_TRANSLATE(pScrn->pScreen, dstRegion, -pPixmap->screen_x,
-pPixmap->screen_y);
#endif
pbox = REGION_RECTS(dstRegion);
nbox = REGION_NUM_RECTS(dstRegion);
renderer_bind_destination(pPriv->r, dst_surf,
dst_surf->width, dst_surf->height);
bind_blend_state(pPriv);
bind_shaders(pPriv);
bind_samplers(pPriv);
setup_fs_video_constants(pPriv->r, hdtv);
DamageDamageRegion(&pPixmap->drawable, dstRegion);
while (nbox--) {
int box_x1 = pbox->x1;
int box_y1 = pbox->y1;
int box_x2 = pbox->x2;
int box_y2 = pbox->y2;
float diff_x = (float)src_w / (float)dst_w;
float diff_y = (float)src_h / (float)dst_h;
float offset_x = box_x1 - dstX;
float offset_y = box_y1 - dstY;
float offset_w;
float offset_h;
#ifdef COMPOSITE
offset_x += pPixmap->screen_x;
offset_y += pPixmap->screen_y;
#endif
x = box_x1;
y = box_y1;
w = box_x2 - box_x1;
h = box_y2 - box_y1;
offset_w = dst_w - w;
offset_h = dst_h - h;
draw_yuv(pPriv,
(float) src_x + offset_x*diff_x, (float) src_y + offset_y*diff_y,
(float) src_w - offset_w*diff_x, (float) src_h - offset_h*diff_y,
x, y, w, h);
pbox++;
}
DamageRegionProcessPending(&pPixmap->drawable);
pipe_surface_reference(&dst_surf, NULL);
return TRUE;
}
static int
put_image(ScrnInfoPtr pScrn,
short src_x, short src_y,
short drw_x, short drw_y,
short src_w, short src_h,
short drw_w, short drw_h,
int id, unsigned char *buf,
short width, short height,
Bool sync, RegionPtr clipBoxes, pointer data,
DrawablePtr pDraw)
{
struct xorg_xv_port_priv *pPriv = (struct xorg_xv_port_priv *) data;
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
PixmapPtr pPixmap;
INT32 x1, x2, y1, y2;
BoxRec dstBox;
int ret;
/* Clip */
x1 = src_x;
x2 = src_x + src_w;
y1 = src_y;
y2 = src_y + src_h;
dstBox.x1 = drw_x;
dstBox.x2 = drw_x + drw_w;
dstBox.y1 = drw_y;
dstBox.y2 = drw_y + drw_h;
if (!xf86XVClipVideoHelper(&dstBox, &x1, &x2, &y1, &y2, clipBoxes,
width, height))
return Success;
ret = check_yuv_textures(pPriv, width, height);
if (ret)
return ret;
copy_packed_data(pScrn, pPriv, id, buf,
src_x, src_y, width, height);
if (pDraw->type == DRAWABLE_WINDOW) {
pPixmap = (*pScreen->GetWindowPixmap)((WindowPtr)pDraw);
} else {
pPixmap = (PixmapPtr)pDraw;
}
display_video(pScrn, pPriv, id, clipBoxes,
src_x, src_y, src_w, src_h,
drw_x, drw_y,
drw_w, drw_h, pPixmap);
pPriv->current_set = (pPriv->current_set + 1) & 1;
return Success;
}
static struct xorg_xv_port_priv *
port_priv_create(struct xorg_renderer *r)
{
struct xorg_xv_port_priv *priv = NULL;
priv = calloc(1, sizeof(struct xorg_xv_port_priv));
if (!priv)
return NULL;
priv->r = r;
REGION_NULL(pScreen, &priv->clip);
debug_assert(priv && priv->r);
return priv;
}
static XF86VideoAdaptorPtr
xorg_setup_textured_adapter(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
XF86VideoAdaptorPtr adapt;
XF86AttributePtr attrs;
DevUnion *dev_unions;
int nports = 16, i;
int nattributes;
nattributes = NUM_TEXTURED_ATTRIBUTES;
debug_assert(ms->exa);
debug_assert(ms->exa->renderer);
adapt = calloc(1, sizeof(XF86VideoAdaptorRec));
dev_unions = calloc(nports, sizeof(DevUnion));
attrs = calloc(nattributes, sizeof(XF86AttributeRec));
if (adapt == NULL || dev_unions == NULL || attrs == NULL) {
free(adapt);
free(dev_unions);
free(attrs);
return NULL;
}
adapt->type = XvWindowMask | XvInputMask | XvImageMask;
adapt->flags = 0;
adapt->name = "Gallium3D Textured Video";
adapt->nEncodings = 1;
adapt->pEncodings = DummyEncoding;
adapt->nFormats = NUM_FORMATS;
adapt->pFormats = Formats;
adapt->nPorts = 0;
adapt->pPortPrivates = dev_unions;
adapt->nAttributes = nattributes;
adapt->pAttributes = attrs;
memcpy(attrs, TexturedAttributes, nattributes * sizeof(XF86AttributeRec));
adapt->nImages = NUM_IMAGES;
adapt->pImages = Images;
adapt->PutVideo = NULL;
adapt->PutStill = NULL;
adapt->GetVideo = NULL;
adapt->GetStill = NULL;
adapt->StopVideo = stop_video;
adapt->SetPortAttribute = set_port_attribute;
adapt->GetPortAttribute = get_port_attribute;
adapt->QueryBestSize = query_best_size;
adapt->PutImage = put_image;
adapt->QueryImageAttributes = query_image_attributes;
for (i = 0; i < nports; i++) {
struct xorg_xv_port_priv *priv =
port_priv_create(ms->exa->renderer);
adapt->pPortPrivates[i].ptr = (pointer) (priv);
adapt->nPorts++;
}
return adapt;
}
void
xorg_xv_init(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
/*modesettingPtr ms = modesettingPTR(pScrn);*/
XF86VideoAdaptorPtr *adaptors, *new_adaptors = NULL;
XF86VideoAdaptorPtr textured_adapter;
int num_adaptors;
num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
new_adaptors = malloc((num_adaptors + 1) * sizeof(XF86VideoAdaptorPtr *));
if (new_adaptors == NULL)
return;
memcpy(new_adaptors, adaptors, num_adaptors * sizeof(XF86VideoAdaptorPtr));
adaptors = new_adaptors;
/* Add the adaptors supported by our hardware. First, set up the atoms
* that will be used by both output adaptors.
*/
xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
xvContrast = MAKE_ATOM("XV_CONTRAST");
textured_adapter = xorg_setup_textured_adapter(pScreen);
debug_assert(textured_adapter);
if (textured_adapter) {
adaptors[num_adaptors++] = textured_adapter;
}
if (num_adaptors) {
xf86XVScreenInit(pScreen, adaptors, num_adaptors);
if (textured_adapter)
xorg_xvmc_init(pScreen, textured_adapter->name);
} else {
xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
"Disabling Xv because no adaptors could be initialized.\n");
}
free(adaptors);
}

119
src/gallium/state_trackers/xorg/xorg_xvmc.c
View File

@ -1,119 +0,0 @@
#include "xorg_tracker.h"
#include <xf86.h>
#include <xf86xv.h>
#include <xf86xvmc.h>
#include <X11/extensions/Xv.h>
#include <X11/extensions/XvMC.h>
#include <fourcc.h>
#define FOURCC_RGB 0x0000003
#define XVIMAGE_RGB \
{ \
FOURCC_RGB, \
XvRGB, \
LSBFirst, \
{ \
'R', 'G', 'B', 0x00, \
0x00,0x00,0x00,0x10,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71 \
}, \
32, \
XvPacked, \
1, \
24, 0x00FF0000, 0x0000FF00, 0x000000FF, \
0, 0, 0, \
0, 0, 0, \
0, 0, 0, \
{ \
'B','G','R','X', \
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 \
}, \
XvTopToBottom \
}
static int subpicture_index_list[] = {
FOURCC_RGB,
FOURCC_IA44,
FOURCC_AI44
};
static XF86MCImageIDList subpicture_list =
{
sizeof(subpicture_index_list)/sizeof(*subpicture_index_list),
subpicture_index_list
};
static XF86MCSurfaceInfoRec yv12_mpeg2_surface =
{
FOURCC_I420,
XVMC_CHROMA_FORMAT_420,
0,
2048, 2048, 2048, 2048,
XVMC_IDCT | XVMC_MPEG_2,
XVMC_SUBPICTURE_INDEPENDENT_SCALING | XVMC_BACKEND_SUBPICTURE,
&subpicture_list
};
static const XF86MCSurfaceInfoRec uyvy_mpeg2_surface =
{
FOURCC_UYVY,
XVMC_CHROMA_FORMAT_422,
0,
2048, 2048, 2048, 2048,
XVMC_IDCT | XVMC_MPEG_2,
XVMC_SUBPICTURE_INDEPENDENT_SCALING | XVMC_BACKEND_SUBPICTURE,
&subpicture_list
};
static XF86MCSurfaceInfoPtr surfaces[] =
{
(XF86MCSurfaceInfoPtr)&yv12_mpeg2_surface,
(XF86MCSurfaceInfoPtr)&uyvy_mpeg2_surface
};
static const XF86ImageRec rgb_subpicture = XVIMAGE_RGB;
static const XF86ImageRec ia44_subpicture = XVIMAGE_IA44;
static const XF86ImageRec ai44_subpicture = XVIMAGE_AI44;
static XF86ImagePtr subpictures[] =
{
(XF86ImagePtr)&rgb_subpicture,
(XF86ImagePtr)&ia44_subpicture,
(XF86ImagePtr)&ai44_subpicture
};
static const XF86MCAdaptorRec adaptor_template =
{
"",
sizeof(surfaces)/sizeof(*surfaces),
surfaces,
sizeof(subpictures)/sizeof(*subpictures),
subpictures,
(xf86XvMCCreateContextProcPtr)NULL,
(xf86XvMCDestroyContextProcPtr)NULL,
(xf86XvMCCreateSurfaceProcPtr)NULL,
(xf86XvMCDestroySurfaceProcPtr)NULL,
(xf86XvMCCreateSubpictureProcPtr)NULL,
(xf86XvMCDestroySubpictureProcPtr)NULL
};
void
xorg_xvmc_init(ScreenPtr pScreen, char *name)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
XF86MCAdaptorPtr adaptorXvMC = xf86XvMCCreateAdaptorRec();
if (!adaptorXvMC)
return;
*adaptorXvMC = adaptor_template;
adaptorXvMC->name = name;
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"[XvMC] Associated with %s.\n", name);
if (!xf86XvMCScreenInit(pScreen, 1, &adaptorXvMC))
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"[XvMC] Failed to initialize extension.\n");
else
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
"[XvMC] Extension initialized.\n");
xf86XvMCDestroyAdaptorRec(adaptorXvMC);
}