Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 988 insertions, 0 deletions

diff --git a/xorg-server/hw/kdrive/ati/ati_video.c b/xorg-server/hw/kdrive/ati/ati_video.c
new file mode 100644
index 000000000..ca0ab464a
--- /dev/null
+++ b/xorg-server/hw/kdrive/ati/ati_video.c
@@ -0,0 +1,988 @@
+/*
+ * Copyright © 2004 Keith Packard
+ * Copyright © 2005 Eric Anholt
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Eric Anholt not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Eric Anholt makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * ERIC ANHOLT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL ERIC ANHOLT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Based on mach64video.c by Keith Packard.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <kdrive-config.h>
+#endif
+#include "ati.h"
+#include "ati_dma.h"
+#include "ati_draw.h"
+#include "ati_reg.h"
+#include "kaa.h"
+
+#include <X11/extensions/Xv.h>
+#include "fourcc.h"
+
+#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
+
+static Atom xvBrightness, xvSaturation;
+
+extern CARD8 ATIBltRop[16];
+
+#define IMAGE_MAX_WIDTH		2048
+#define IMAGE_MAX_HEIGHT	2048
+
+static void
+ATIStopVideo(KdScreenInfo *screen, pointer data, Bool exit)
+{
+	ScreenPtr pScreen = screen->pScreen;
+	ATIPortPrivPtr pPortPriv = (ATIPortPrivPtr)data;
+
+	REGION_EMPTY(screen->pScreen, &pPortPriv->clip);   
+
+	if (pPortPriv->off_screen) {
+		KdOffscreenFree (pScreen, pPortPriv->off_screen);
+		pPortPriv->off_screen = 0;
+	}
+}
+
+static int
+ATISetPortAttribute(KdScreenInfo *screen, Atom attribute, int value,
+    pointer data)
+{
+	return BadMatch;
+}
+
+static int
+ATIGetPortAttribute(KdScreenInfo *screen, Atom attribute, int *value,
+    pointer data)
+{
+	return BadMatch;
+}
+
+static void
+ATIQueryBestSize(KdScreenInfo *screen, Bool motion, short vid_w, short vid_h,
+    short drw_w, short drw_h, unsigned int *p_w, unsigned int *p_h,
+    pointer data)
+{
+	*p_w = drw_w;
+	*p_h = drw_h;
+}
+
+/* ATIClipVideo -  
+
+   Takes the dst box in standard X BoxRec form (top and left
+   edges inclusive, bottom and right exclusive).  The new dst
+   box is returned.  The source boundaries are given (x1, y1 
+   inclusive, x2, y2 exclusive) and returned are the new source 
+   boundaries in 16.16 fixed point. 
+*/
+
+static void
+ATIClipVideo(BoxPtr dst, INT32 *x1, INT32 *x2, INT32 *y1, INT32 *y2,
+    BoxPtr extents, INT32 width, INT32 height)
+{
+	INT32 vscale, hscale, delta;
+	int diff;
+
+	hscale = ((*x2 - *x1) << 16) / (dst->x2 - dst->x1);
+	vscale = ((*y2 - *y1) << 16) / (dst->y2 - dst->y1);
+
+	*x1 <<= 16; *x2 <<= 16;
+	*y1 <<= 16; *y2 <<= 16;
+
+	diff = extents->x1 - dst->x1;
+	if (diff > 0) {
+		dst->x1 = extents->x1;
+		*x1 += diff * hscale;
+	}
+	diff = dst->x2 - extents->x2;
+	if (diff > 0) {
+		dst->x2 = extents->x2;
+		*x2 -= diff * hscale;
+	}
+	diff = extents->y1 - dst->y1;
+	if (diff > 0) {
+		dst->y1 = extents->y1;
+		*y1 += diff * vscale;
+	}
+	diff = dst->y2 - extents->y2;
+	if (diff > 0) {
+		dst->y2 = extents->y2;
+		*y2 -= diff * vscale;
+	}
+
+	if (*x1 < 0) {
+		diff =  (- *x1 + hscale - 1)/ hscale;
+		dst->x1 += diff;
+		*x1 += diff * hscale;
+	}
+	delta = *x2 - (width << 16);
+	if (delta > 0) {
+		diff = (delta + hscale - 1)/ hscale;
+		dst->x2 -= diff;
+		*x2 -= diff * hscale;
+	}
+	if (*y1 < 0) {
+		diff =  (- *y1 + vscale - 1)/ vscale;
+		dst->y1 += diff;
+		*y1 += diff * vscale;
+	}
+	delta = *y2 - (height << 16);
+	if (delta > 0) {
+		diff = (delta + vscale - 1)/ vscale;
+		dst->y2 -= diff;
+		*y2 -= diff * vscale;
+	}
+}
+
+static void
+R128DisplayVideo(KdScreenInfo *screen, ATIPortPrivPtr pPortPriv)
+{
+	ScreenPtr pScreen = screen->pScreen;
+	KdScreenPriv(pScreen);
+	ATIScreenInfo(pScreenPriv);
+	CARD32 dstDatatype, srcDatatype;
+	CARD32 dst_offset, dst_pitch;
+	int dstxoff, dstyoff;
+	PixmapPtr pPixmap = pPortPriv->pPixmap;
+	int bpp = pPixmap->drawable.bitsPerPixel;
+	RING_LOCALS;
+
+	BoxPtr pBox = REGION_RECTS(&pPortPriv->clip);
+	int nBox = REGION_NUM_RECTS(&pPortPriv->clip);
+
+	if (pPortPriv->id == FOURCC_UYVY)
+		srcDatatype = R128_DATATYPE_YVYU_422;
+	else
+		srcDatatype = R128_DATATYPE_VYUY_422;
+
+	switch (bpp)
+	{
+	case 16:
+		if (pPixmap->drawable.depth == 15)
+			dstDatatype = R128_DATATYPE_ARGB1555;
+		else
+			dstDatatype = R128_DATATYPE_RGB565;
+		break;
+	case 32:
+		dstDatatype = R128_DATATYPE_ARGB8888;
+		break;
+	default:
+		return;
+	}
+
+	dst_offset = ((CARD8 *)pPixmap->devPrivate.ptr -
+	    pScreenPriv->screen->memory_base);
+	dst_pitch = pPixmap->devKind;
+#ifdef COMPOSITE
+	dstxoff = -pPixmap->screen_x + pPixmap->drawable.x;
+	dstyoff = -pPixmap->screen_y + pPixmap->drawable.y;
+#else
+	dstxoff = 0;
+	dstyoff = 0;
+#endif
+
+	BEGIN_DMA(18);
+	OUT_REG(ATI_REG_DST_PITCH_OFFSET,
+	    ((dst_pitch / bpp) << 21) | (dst_offset >> 5));
+	OUT_REG(ATI_REG_DP_GUI_MASTER_CNTL,
+	    ATI_GMC_DST_PITCH_OFFSET_CNTL |
+	    ATI_GMC_BRUSH_NONE |
+	    (dstDatatype << 8) |
+	    ATI_GMC_SRC_DATATYPE_COLOR |
+	    (ATIBltRop[GXcopy] << 16) |
+	    R128_GMC_3D_FCN_EN |
+	    ATI_GMC_CLR_CMP_CNTL_DIS |
+	    R128_GMC_AUX_CLIP_DIS);
+	OUT_REG(ATI_REG_DP_CNTL, 
+	    ATI_DST_X_LEFT_TO_RIGHT | ATI_DST_Y_TOP_TO_BOTTOM );
+	OUT_REG(R128_REG_SCALE_3D_CNTL,
+	    R128_SCALE_3D_SCALE |
+	    R128_SBLEND_ONE |
+	    R128_DBLEND_ZERO);
+	OUT_REG(R128_REG_TEX_CNTL_C, R128_TEX_CACHE_FLUSH);
+	OUT_REG(R128_REG_SCALE_3D_DATATYPE, srcDatatype);
+
+	OUT_RING(DMA_PACKET0(R128_REG_SCALE_PITCH, 5));
+	OUT_RING_REG(R128_REG_SCALE_PITCH, pPortPriv->src_pitch / 16);
+	OUT_RING_REG(R128_REG_SCALE_X_INC,
+	    (pPortPriv->src_w << 16) / pPortPriv->dst_w);
+	OUT_RING_REG(R128_REG_SCALE_Y_INC,
+	    (pPortPriv->src_h << 16) / pPortPriv->dst_h);
+	OUT_RING_REG(R128_REG_SCALE_HACC, 0x0);
+	OUT_RING_REG(R128_REG_SCALE_VACC, 0x0);
+
+	END_DMA();
+
+	while (nBox--) {
+		int srcX, srcY, dstX, dstY, srcw, srch, dstw, dsth;
+
+		dstX = pBox->x1 + dstxoff;
+		dstY = pBox->y1 + dstyoff;
+		dstw = pBox->x2 - pBox->x1;
+		dsth = pBox->y2 - pBox->y1;
+		srcX = (pBox->x1 - pPortPriv->dst_x1) *
+		    pPortPriv->src_w / pPortPriv->dst_w;
+		srcY = (pBox->y1 - pPortPriv->dst_y1) *
+		    pPortPriv->src_h / pPortPriv->dst_h;
+		srcw = pPortPriv->src_w - srcX;
+		srch = pPortPriv->src_h - srcY;
+
+		BEGIN_DMA(6);
+		OUT_RING(DMA_PACKET0(R128_REG_SCALE_SRC_HEIGHT_WIDTH, 2));
+		OUT_RING_REG(R128_REG_SCALE_SRC_HEIGHT_WIDTH,
+		    (srch << 16) | srcw);
+		OUT_RING_REG(R128_REG_SCALE_OFFSET_0, pPortPriv->src_offset +
+		    srcY * pPortPriv->src_pitch + srcX * 2);
+
+		OUT_RING(DMA_PACKET0(R128_REG_SCALE_DST_X_Y, 2));
+		OUT_RING_REG(R128_REG_SCALE_DST_X_Y, (dstX << 16) | dstY);
+		OUT_RING_REG(R128_REG_SCALE_DST_HEIGHT_WIDTH,
+		    (dsth << 16) | dstw);
+		END_DMA();
+		pBox++;
+	}
+#ifdef DAMAGEEXT
+	/* XXX: Shouldn't this be in kxv.c instead? */
+	DamageDamageRegion(pPortPriv->pDraw, &pPortPriv->clip);
+#endif
+	kaaMarkSync(pScreen);
+}
+
+union intfloat {
+	float f;
+	CARD32 i;
+};
+
+struct blend_vertex {
+	union intfloat x, y;
+	union intfloat s0, t0;
+};
+
+#define VTX_DWORD_COUNT 4
+
+#define VTX_OUT(vtx)		\
+do {				\
+	OUT_RING(vtx.x.i);	\
+	OUT_RING(vtx.y.i);	\
+	OUT_RING(vtx.s0.i);	\
+	OUT_RING(vtx.t0.i);	\
+} while (0)
+
+static void
+RadeonDisplayVideo(KdScreenInfo *screen, ATIPortPrivPtr pPortPriv)
+{
+	ScreenPtr pScreen = screen->pScreen;
+	KdScreenPriv(pScreen);
+	ATICardInfo(pScreenPriv);
+	ATIScreenInfo(pScreenPriv);
+	struct blend_vertex vtx[4];
+	PixmapPtr pPixmap = pPortPriv->pPixmap;
+	CARD32 txformat;
+	CARD32 dst_offset, dst_pitch, dst_format;
+	int dstxoff, dstyoff, pixel_shift;
+	RING_LOCALS;
+
+	BoxPtr pBox = REGION_RECTS(&pPortPriv->clip);
+	int nBox = REGION_NUM_RECTS(&pPortPriv->clip);
+
+	switch (pPixmap->drawable.bitsPerPixel) {
+	case 16:
+		if (pPixmap->drawable.depth == 15)
+			dst_format = RADEON_COLOR_FORMAT_ARGB1555;
+		else
+			dst_format = RADEON_COLOR_FORMAT_RGB565;
+		pixel_shift = 1;
+		break;
+	case 32:
+		dst_format = RADEON_COLOR_FORMAT_ARGB8888;
+		pixel_shift = 2;
+		break;
+	default:
+		return;
+	}
+
+	dst_offset = ((CARD8 *)pPixmap->devPrivate.ptr -
+	    pScreenPriv->screen->memory_base);
+	dst_pitch = pPixmap->devKind;
+
+#ifdef COMPOSITE
+	dstxoff = -pPixmap->screen_x + pPixmap->drawable.x;
+	dstyoff = -pPixmap->screen_y + pPixmap->drawable.y;
+#else
+	dstxoff = 0;
+	dstyoff = 0;
+#endif
+
+	/* Same for R100/R200 */
+	if (pPortPriv->id == FOURCC_UYVY)
+		txformat = RADEON_TXFORMAT_YVYU422;
+	else
+		txformat = RADEON_TXFORMAT_VYUY422;
+
+	txformat |= RADEON_TXFORMAT_NON_POWER2;
+
+	RadeonSwitchTo3D(atis);
+
+	BEGIN_DMA(8);
+
+	OUT_RING(DMA_PACKET0(RADEON_REG_PP_CNTL, 3));
+	OUT_RING_REG(RADEON_REG_PP_CNTL,
+	    RADEON_TEX_0_ENABLE | RADEON_TEX_BLEND_0_ENABLE);
+	OUT_RING_REG(RADEON_REG_RB3D_CNTL,
+	    dst_format | RADEON_ALPHA_BLEND_ENABLE);
+	OUT_RING_REG(RADEON_REG_RB3D_COLOROFFSET, dst_offset);
+
+	OUT_REG(RADEON_REG_RB3D_COLORPITCH, dst_pitch >> pixel_shift);
+
+	OUT_REG(RADEON_REG_RB3D_BLENDCNTL,
+	    RADEON_SBLEND_GL_ONE | RADEON_DBLEND_GL_ZERO);
+
+	END_DMA();
+
+	if (atic->is_r200) {
+		BEGIN_DMA(17);
+
+		OUT_REG(R200_REG_SE_VTX_FMT_0, R200_VTX_XY);
+		OUT_REG(R200_REG_SE_VTX_FMT_1,
+		    (2 << R200_VTX_TEX0_COMP_CNT_SHIFT));
+
+		OUT_RING(DMA_PACKET0(R200_REG_PP_TXFILTER_0, 5));
+		OUT_RING_REG(R200_REG_PP_TXFILTER_0,
+		    R200_MAG_FILTER_LINEAR |
+		    R200_MIN_FILTER_LINEAR |
+		    R200_YUV_TO_RGB);
+		OUT_RING_REG(R200_REG_PP_TXFORMAT_0, txformat);
+		OUT_RING_REG(R200_REG_PP_TXFORMAT_X_0, 0);
+		OUT_RING_REG(R200_REG_PP_TXSIZE_0,
+		    (pPixmap->drawable.width - 1) |
+		    ((pPixmap->drawable.height - 1) << RADEON_TEX_VSIZE_SHIFT));
+		OUT_RING_REG(R200_REG_PP_TXPITCH_0, pPortPriv->src_pitch - 32);
+
+		OUT_REG(R200_PP_TXOFFSET_0, pPortPriv->src_offset);
+
+		OUT_RING(DMA_PACKET0(R200_REG_PP_TXCBLEND_0, 4));
+		OUT_RING_REG(R200_REG_PP_TXCBLEND_0,
+		    R200_TXC_ARG_A_ZERO |
+		    R200_TXC_ARG_B_ZERO |
+		    R200_TXC_ARG_C_R0_COLOR |
+		    R200_TXC_OP_MADD);
+		OUT_RING_REG(R200_REG_PP_TXCBLEND2_0,
+		    R200_TXC_CLAMP_0_1 | R200_TXC_OUTPUT_REG_R0);
+		OUT_RING_REG(R200_REG_PP_TXABLEND_0,
+		    R200_TXA_ARG_A_ZERO |
+		    R200_TXA_ARG_B_ZERO |
+		    R200_TXA_ARG_C_R0_ALPHA |
+		    R200_TXA_OP_MADD);
+		OUT_RING_REG(R200_REG_PP_TXABLEND2_0,
+		    R200_TXA_CLAMP_0_1 | R200_TXA_OUTPUT_REG_R0);
+
+		END_DMA();
+	} else {
+//		BEGIN_DMA(11);
+		BEGIN_DMA(9);
+
+		OUT_RING(DMA_PACKET0(RADEON_REG_PP_TXFILTER_0, 5));
+		OUT_RING_REG(RADEON_REG_PP_TXFILTER_0, RADEON_MAG_FILTER_LINEAR |
+		    RADEON_MIN_FILTER_LINEAR |
+		    RADEON_YUV_TO_RGB);
+		OUT_RING_REG(RADEON_REG_PP_TXFORMAT_0, txformat);
+		OUT_RING_REG(RADEON_REG_PP_TXOFFSET_0, pPortPriv->src_offset);
+		OUT_RING_REG(RADEON_REG_PP_TXCBLEND_0,
+		    RADEON_COLOR_ARG_A_ZERO |
+		    RADEON_COLOR_ARG_B_ZERO |
+		    RADEON_COLOR_ARG_C_T0_COLOR |
+		    RADEON_BLEND_CTL_ADD |
+		    RADEON_CLAMP_TX);
+		OUT_RING_REG(RADEON_REG_PP_TXABLEND_0,
+		    RADEON_ALPHA_ARG_A_ZERO |
+		    RADEON_ALPHA_ARG_B_ZERO |
+		    RADEON_ALPHA_ARG_C_T0_ALPHA |
+		    RADEON_BLEND_CTL_ADD |
+		    RADEON_CLAMP_TX);
+
+		OUT_RING(DMA_PACKET0(RADEON_REG_PP_TEX_SIZE_0, 2));
+		OUT_RING_REG(RADEON_REG_PP_TEX_SIZE_0,
+		    (pPixmap->drawable.width - 1) |
+		    ((pPixmap->drawable.height - 1) << RADEON_TEX_VSIZE_SHIFT));
+		OUT_RING_REG(RADEON_REG_PP_TEX_PITCH_0,
+		    pPortPriv->src_pitch - 32);
+
+//	        OUT_RING_REG(ATI_REG_WAIT_UNTIL, ATI_WAIT_CRTC_VLINE);
+
+		END_DMA();
+	}
+
+	while (nBox--) {
+		float srcX, srcY, dstX, dstY, srcw, srch, dstw, dsth;
+
+		dstX = pBox->x1 + dstxoff;
+		dstY = pBox->y1 + dstyoff;
+		dstw = pBox->x2 - pBox->x1;
+		dsth = pBox->y2 - pBox->y1;
+		srcX = (pBox->x1 - pPortPriv->dst_x1) *
+		    pPortPriv->src_w / pPortPriv->dst_w;
+		srcY = (pBox->y1 - pPortPriv->dst_y1) *
+		    pPortPriv->src_h / pPortPriv->dst_h;
+		srcw = pPortPriv->src_w * (dstw / pPortPriv->dst_w);
+		srch = pPortPriv->src_h * (dsth / pPortPriv->dst_h);
+
+		/*
+		 * rectangle:
+		 *
+		 *  +---------2
+		 *  |         |
+		 *  |         |
+		 *  0---------1
+		 */
+		
+		vtx[0].x.f = dstX;
+		vtx[0].y.f = dstY + dsth;
+		vtx[0].s0.f = srcX;
+		vtx[0].t0.f = srcY + srch;
+
+		vtx[1].x.f = dstX + dstw;
+		vtx[1].y.f = dstY + dsth;
+		vtx[1].s0.f = srcX + srcw;
+		vtx[1].t0.f = srcY + srch;
+
+		vtx[2].x.f = dstX + dstw;
+		vtx[2].y.f = dstY;
+		vtx[2].s0.f = srcX + srcw;
+		vtx[2].t0.f = srcY;
+
+		if (atic->is_r100) {
+			BEGIN_DMA(3 * VTX_DWORD_COUNT + 3);
+			OUT_RING(DMA_PACKET3(RADEON_CP_PACKET3_3D_DRAW_IMMD,
+			    3 * VTX_DWORD_COUNT + 2));
+			OUT_RING(RADEON_CP_VC_FRMT_XY |
+			    RADEON_CP_VC_FRMT_ST0);
+			OUT_RING(RADEON_CP_VC_CNTL_PRIM_TYPE_RECT_LIST |
+			    RADEON_CP_VC_CNTL_PRIM_WALK_RING |
+			    RADEON_CP_VC_CNTL_MAOS_ENABLE |
+			    RADEON_CP_VC_CNTL_VTX_FMT_RADEON_MODE |
+			    (3 << RADEON_CP_VC_CNTL_NUM_SHIFT));
+		} else {
+			BEGIN_DMA(3 * VTX_DWORD_COUNT + 2);
+			OUT_RING(DMA_PACKET3(R200_CP_PACKET3_3D_DRAW_IMMD_2,
+			    3 * VTX_DWORD_COUNT + 1));
+			OUT_RING(RADEON_CP_VC_CNTL_PRIM_TYPE_RECT_LIST |
+			    RADEON_CP_VC_CNTL_PRIM_WALK_RING |
+			    (3 << RADEON_CP_VC_CNTL_NUM_SHIFT));
+		}
+
+		VTX_OUT(vtx[0]);
+		VTX_OUT(vtx[1]);
+		VTX_OUT(vtx[2]);
+		END_DMA();
+
+		pBox++;
+	}
+#ifdef DAMAGEEXT
+	/* XXX: Shouldn't this be in kxv.c instead? */
+	DamageDamageRegion(pPortPriv->pDraw, &pPortPriv->clip);
+#endif
+	kaaMarkSync(pScreen);
+}
+
+static void
+ATIVideoSave(ScreenPtr pScreen, KdOffscreenArea *area)
+{
+	KdScreenPriv(pScreen);
+	ATIScreenInfo(pScreenPriv);
+	ATIPortPrivPtr pPortPriv = atis->pAdaptor->pPortPrivates[0].ptr;
+
+	if (pPortPriv->off_screen == area)
+		pPortPriv->off_screen = 0;
+}
+
+static int
+ATIPutImage(KdScreenInfo *screen, DrawablePtr pDraw,
+	       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)
+{
+	ScreenPtr pScreen = screen->pScreen;
+	KdScreenPriv(pScreen);
+	ATICardInfo(pScreenPriv);
+	ATIScreenInfo(pScreenPriv);
+	ATIPortPrivPtr pPortPriv = (ATIPortPrivPtr)data;
+	char *mmio = atic->reg_base;
+	INT32 x1, x2, y1, y2;
+	int randr = RR_Rotate_0 /* XXX */;
+	int srcPitch, srcPitch2, dstPitch;
+	int top, left, npixels, nlines, size;
+	BoxRec dstBox;
+	int dst_width = width, dst_height = height;
+	int rot_x1, rot_y1, rot_x2, rot_y2;
+	int dst_x1, dst_y1, dst_x2, dst_y2;
+	int rot_src_w, rot_src_h, rot_drw_w, rot_drw_h;
+
+	/* 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;
+
+	ATIClipVideo(&dstBox, &x1, &x2, &y1, &y2,
+	    REGION_EXTENTS(pScreen, clipBoxes), width, height);
+
+	src_w = (x2 - x1) >> 16;
+	src_h = (y2 - y1) >> 16;
+	drw_w = dstBox.x2 - dstBox.x1;
+	drw_h = dstBox.y2 - dstBox.y1;
+
+	if ((x1 >= x2) || (y1 >= y2))
+		return Success;
+
+	if (mmio == NULL)
+		return BadAlloc;
+
+	if (randr & (RR_Rotate_0|RR_Rotate_180)) {
+		dst_width = width;
+		dst_height = height;
+		rot_src_w = src_w;
+		rot_src_h = src_h;
+		rot_drw_w = drw_w;
+		rot_drw_h = drw_h;
+	} else {
+		dst_width = height;
+		dst_height = width;
+		rot_src_w = src_h;
+		rot_src_h = src_w;
+		rot_drw_w = drw_h;
+		rot_drw_h = drw_w;
+	}
+
+	switch (randr & RR_Rotate_All) {
+	case RR_Rotate_0:
+	default:
+		dst_x1 = dstBox.x1;
+		dst_y1 = dstBox.y1;
+		dst_x2 = dstBox.x2;
+		dst_y2 = dstBox.y2;
+		rot_x1 = x1;
+		rot_y1 = y1;
+		rot_x2 = x2;
+		rot_y2 = y2;
+		break;
+	case RR_Rotate_90:
+		dst_x1 = dstBox.y1;
+		dst_y1 = screen->height - dstBox.x2;
+		dst_x2 = dstBox.y2;
+		dst_y2 = screen->height - dstBox.x1;
+		rot_x1 = y1;
+		rot_y1 = (src_w << 16) - x2;
+		rot_x2 = y2;
+		rot_y2 = (src_w << 16) - x1;
+		break;
+	case RR_Rotate_180:
+		dst_x1 = screen->width - dstBox.x2;
+		dst_y1 = screen->height - dstBox.y2;
+		dst_x2 = screen->width - dstBox.x1;
+		dst_y2 = screen->height - dstBox.y1;
+		rot_x1 = (src_w << 16) - x2;
+		rot_y1 = (src_h << 16) - y2;
+		rot_x2 = (src_w << 16) - x1;
+		rot_y2 = (src_h << 16) - y1;
+		break;
+	case RR_Rotate_270:
+		dst_x1 = screen->width - dstBox.y2;
+		dst_y1 = dstBox.x1;
+		dst_x2 = screen->width - dstBox.y1;
+		dst_y2 = dstBox.x2;
+		rot_x1 = (src_h << 16) - y2;
+		rot_y1 = x1;
+		rot_x2 = (src_h << 16) - y1;
+		rot_y2 = x2;
+		break;
+	}
+
+	switch(id) {
+	case FOURCC_YV12:
+	case FOURCC_I420:
+		dstPitch = ((dst_width << 1) + 15) & ~15;
+		srcPitch = (width + 3) & ~3;
+		srcPitch2 = ((width >> 1) + 3) & ~3;
+		size = dstPitch * dst_height;
+		break;
+	case FOURCC_UYVY:
+	case FOURCC_YUY2:
+	default:
+		dstPitch = ((dst_width << 1) + 15) & ~15;
+		srcPitch = (width << 1);
+		srcPitch2 = 0;
+		size = dstPitch * dst_height;
+		break;
+	}
+
+	if (pPortPriv->off_screen != NULL && size != pPortPriv->size) {
+		KdOffscreenFree(screen->pScreen, pPortPriv->off_screen);
+		pPortPriv->off_screen = 0;
+	}
+
+	if (pPortPriv->off_screen == NULL) {
+		pPortPriv->off_screen = KdOffscreenAlloc(screen->pScreen,
+		    size * 2, 64, TRUE, ATIVideoSave, pPortPriv);
+		if (pPortPriv->off_screen == NULL)
+			return BadAlloc;
+	}
+
+
+	if (pDraw->type == DRAWABLE_WINDOW)
+		pPortPriv->pPixmap =
+		    (*pScreen->GetWindowPixmap)((WindowPtr)pDraw);
+	else
+		pPortPriv->pPixmap = (PixmapPtr)pDraw;
+
+	/* Migrate the pixmap to offscreen if necessary. */
+	if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap))
+		kaaMoveInPixmap(pPortPriv->pPixmap);
+
+	if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap)) {
+		return BadAlloc;
+	}
+
+	pPortPriv->src_offset = pPortPriv->off_screen->offset;
+	pPortPriv->src_addr = (CARD8 *)(pScreenPriv->screen->memory_base +
+	    pPortPriv->src_offset);
+	pPortPriv->src_pitch = dstPitch;
+	pPortPriv->size = size;
+	pPortPriv->pDraw = pDraw;
+
+	/* copy data */
+	top = rot_y1 >> 16;
+	left = (rot_x1 >> 16) & ~1;
+	npixels = ((((rot_x2 + 0xffff) >> 16) + 1) & ~1) - left;
+
+	/* Since we're probably overwriting the area that might still be used
+	 * for the last PutImage request, wait for idle.
+	 */
+	ATIWaitIdle(atis);
+
+	switch(id) {
+	case FOURCC_YV12:
+	case FOURCC_I420:
+		top &= ~1;
+		nlines = ((((rot_y2 + 0xffff) >> 16) + 1) & ~1) - top;
+		KdXVCopyPlanarData(screen, buf, pPortPriv->src_addr, randr,
+		    srcPitch, srcPitch2, dstPitch, rot_src_w, rot_src_h,
+		    height, top, left, nlines, npixels, id);
+		break;
+	case FOURCC_UYVY:
+	case FOURCC_YUY2:
+	default:
+		nlines = ((rot_y2 + 0xffff) >> 16) - top;
+		KdXVCopyPackedData(screen, buf, pPortPriv->src_addr, randr,
+		    srcPitch, dstPitch, rot_src_w, rot_src_h, top, left,
+		    nlines, npixels);
+		break;
+	}
+
+	/* update cliplist */
+	if (!REGION_EQUAL(screen->pScreen, &pPortPriv->clip, clipBoxes)) {
+		REGION_COPY(screen->pScreen, &pPortPriv->clip, clipBoxes);
+	}
+
+	pPortPriv->id = id;
+	pPortPriv->src_x1 = rot_x1;
+	pPortPriv->src_y1 = rot_y1;
+	pPortPriv->src_x2 = rot_x2;
+	pPortPriv->src_y2 = rot_y2;
+	pPortPriv->src_w = rot_src_w;
+	pPortPriv->src_h = rot_src_h;
+	pPortPriv->dst_x1 = dst_x1;
+	pPortPriv->dst_y1 = dst_y1;
+	pPortPriv->dst_x2 = dst_x2;
+	pPortPriv->dst_y2 = dst_y2;
+	pPortPriv->dst_w = rot_drw_w;
+	pPortPriv->dst_h = rot_drw_h;
+
+	if (atic->is_radeon)
+		RadeonDisplayVideo(screen, pPortPriv);
+	else
+		R128DisplayVideo(screen, pPortPriv);
+
+	return Success;
+}
+
+static int
+ATIReputImage(KdScreenInfo *screen, DrawablePtr pDraw, short drw_x, short drw_y,
+    RegionPtr clipBoxes, pointer data)
+{
+	ScreenPtr pScreen = screen->pScreen;
+	KdScreenPriv(pScreen);
+	ATICardInfo(pScreenPriv);
+	ATIPortPrivPtr	pPortPriv = (ATIPortPrivPtr)data;
+	BoxPtr pOldExtents = REGION_EXTENTS(screen->pScreen, &pPortPriv->clip);
+	BoxPtr pNewExtents = REGION_EXTENTS(screen->pScreen, clipBoxes);
+
+	if (pOldExtents->x1 != pNewExtents->x1 ||
+	    pOldExtents->x2 != pNewExtents->x2 ||
+	    pOldExtents->y1 != pNewExtents->y1 ||
+	    pOldExtents->y2 != pNewExtents->y2)
+		return BadMatch;
+
+	if (pDraw->type == DRAWABLE_WINDOW)
+		pPortPriv->pPixmap =
+		    (*pScreen->GetWindowPixmap)((WindowPtr)pDraw);
+	else
+		pPortPriv->pPixmap = (PixmapPtr)pDraw;
+
+	if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap))
+		kaaMoveInPixmap(pPortPriv->pPixmap);
+
+	if (!kaaPixmapIsOffscreen(pPortPriv->pPixmap)) {
+		ErrorF("err\n");
+		return BadAlloc;
+	}
+
+
+	/* update cliplist */
+	if (!REGION_EQUAL(screen->pScreen, &pPortPriv->clip, clipBoxes))
+		REGION_COPY(screen->pScreen, &pPortPriv->clip, clipBoxes);
+
+	/* XXX: What do the drw_x and drw_y here mean for us? */
+
+	if (atic->is_radeon)
+		RadeonDisplayVideo(screen, pPortPriv);
+	else
+		R128DisplayVideo(screen, pPortPriv);
+
+	return Success;
+}
+
+static int
+ATIQueryImageAttributes(KdScreenInfo *screen, 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:
+	case FOURCC_I420:
+		*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;
+}
+
+
+/* client libraries expect an encoding */
+static KdVideoEncodingRec DummyEncoding[1] =
+{
+	{
+		0,
+		"XV_IMAGE",
+		IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT,
+		{1, 1}
+	}
+};
+
+#define NUM_FORMATS 3
+
+static KdVideoFormatRec Formats[NUM_FORMATS] = 
+{
+	{15, TrueColor}, {16, TrueColor}, {24, TrueColor}
+};
+
+#define NUM_ATTRIBUTES 0
+
+static KdAttributeRec Attributes[NUM_ATTRIBUTES] =
+{
+};
+
+#define NUM_IMAGES 4
+
+static KdImageRec Images[NUM_IMAGES] =
+{
+	XVIMAGE_YUY2,
+	XVIMAGE_YV12,
+	XVIMAGE_I420,
+	XVIMAGE_UYVY
+};
+
+static KdVideoAdaptorPtr 
+ATISetupImageVideo(ScreenPtr pScreen)
+{
+	KdScreenPriv(pScreen);
+	ATIScreenInfo(pScreenPriv);
+	KdVideoAdaptorPtr adapt;
+	ATIPortPrivPtr pPortPriv;
+	int i;
+
+	atis->num_texture_ports = 16;
+
+	adapt = xcalloc(1, sizeof(KdVideoAdaptorRec) + atis->num_texture_ports *
+	    (sizeof(ATIPortPrivRec) + sizeof(DevUnion)));
+	if (adapt == NULL)
+		return NULL;
+
+	adapt->type = XvWindowMask | XvInputMask | XvImageMask;
+	adapt->flags = VIDEO_CLIP_TO_VIEWPORT;
+	adapt->name = "ATI Texture Video";
+	adapt->nEncodings = 1;
+	adapt->pEncodings = DummyEncoding;
+	adapt->nFormats = NUM_FORMATS;
+	adapt->pFormats = Formats;
+	adapt->nPorts = atis->num_texture_ports;
+	adapt->pPortPrivates = (DevUnion*)(&adapt[1]);
+
+	pPortPriv =
+	    (ATIPortPrivPtr)(&adapt->pPortPrivates[atis->num_texture_ports]);
+
+	for (i = 0; i < atis->num_texture_ports; i++)
+		adapt->pPortPrivates[i].ptr = &pPortPriv[i];
+
+	adapt->nAttributes = NUM_ATTRIBUTES;
+	adapt->pAttributes = Attributes;
+	adapt->pImages = Images;
+	adapt->nImages = NUM_IMAGES;
+	adapt->PutVideo = NULL;
+	adapt->PutStill = NULL;
+	adapt->GetVideo = NULL;
+	adapt->GetStill = NULL;
+	adapt->StopVideo = ATIStopVideo;
+	adapt->SetPortAttribute = ATISetPortAttribute;
+	adapt->GetPortAttribute = ATIGetPortAttribute;
+	adapt->QueryBestSize = ATIQueryBestSize;
+	adapt->PutImage = ATIPutImage;
+	adapt->ReputImage = ATIReputImage;
+	adapt->QueryImageAttributes = ATIQueryImageAttributes;
+
+	/* gotta uninit this someplace */
+	REGION_INIT(pScreen, &pPortPriv->clip, NullBox, 0); 
+
+	atis->pAdaptor = adapt;
+
+	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
+	xvSaturation = MAKE_ATOM("XV_SATURATION");
+
+	return adapt;
+}
+
+Bool ATIInitVideo(ScreenPtr pScreen)
+{
+	KdScreenPriv(pScreen);
+	ATIScreenInfo(pScreenPriv);
+	ATICardInfo(pScreenPriv);
+	KdScreenInfo *screen = pScreenPriv->screen;
+	KdVideoAdaptorPtr *adaptors, *newAdaptors = NULL;
+	KdVideoAdaptorPtr newAdaptor = NULL;
+	int num_adaptors;
+    
+	atis->pAdaptor = NULL;
+
+	if (atic->reg_base == NULL)
+		return FALSE;
+	if (atic->is_r300)
+		return FALSE;
+
+	num_adaptors = KdXVListGenericAdaptors(screen, &adaptors);
+
+	newAdaptor = ATISetupImageVideo(pScreen);
+
+	if (newAdaptor)  {
+		if (!num_adaptors) {
+			num_adaptors = 1;
+			adaptors = &newAdaptor;
+		} else {
+			newAdaptors = xalloc((num_adaptors + 1) * 
+			    sizeof(KdVideoAdaptorPtr *));
+			if (newAdaptors) {
+				memcpy(newAdaptors, adaptors, num_adaptors *
+				    sizeof(KdVideoAdaptorPtr));
+				newAdaptors[num_adaptors] = newAdaptor;
+				adaptors = newAdaptors;
+				num_adaptors++;
+			}
+		}
+	}
+
+	if (num_adaptors)
+		KdXVScreenInit(pScreen, adaptors, num_adaptors);
+
+	if (newAdaptors)
+		xfree(newAdaptors);
+
+	return TRUE;
+}
+
+void
+ATIFiniVideo(ScreenPtr pScreen)
+{
+	KdScreenPriv(pScreen);
+	ATIScreenInfo(pScreenPriv);
+	KdVideoAdaptorPtr adapt = atis->pAdaptor;
+	ATIPortPrivPtr pPortPriv;
+	int i;
+
+	if (!adapt)
+		return;
+
+	for (i = 0; i < atis->num_texture_ports; i++) {
+		pPortPriv = (ATIPortPrivPtr)(&adapt->pPortPrivates[i].ptr);
+		REGION_UNINIT(pScreen, &pPortPriv->clip);
+	}
+	xfree(adapt);
+	atis->pAdaptor = NULL;
+}