path: root/xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_video.c

/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_video.c,v 1.1 2000/11/02 16:55:47 tsi Exp $ */
/*
 * Copyright 2000 Stuart R. Anderson and Metro Link, Inc.
 *
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation on
 * 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 NON-INFRINGEMENT. IN NO EVENT SHALL
 * ATI, PRECISION INSIGHT AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/*
 * Authors:
 *   Stuart R. Anderson <anderson@metrolink.com>
 *
 * Credits:
 *
 *   This code is derived primarily from the GATOS Project run by Stea Greene.
 *   The initial version of this code was done by Vladimir Dergacheb.
 *
 *   This code was simplified from the GATOS code primarily because I didn't
 *   have the right hardware handy to test anything beyond simple overlays,
 *   and because I wanted to complete it in a short time frame that I had
 *   available.
 *
 *   My apologies to Vladimir as there is more good work in his code that
 *   should be brought forward.
 *
 *   RADEON ALERT !
 *   This is an extremely quick port to the Radeon, it hasn't been tested
 *   thoroughly, although it appears to work.
 */

#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86Resources.h"
#include "xf86_ansic.h"
#include "compiler.h"
#include "xf86PciInfo.h"
#include "xf86Pci.h"
#include "xf86fbman.h"
#include "regionstr.h"

#include "xf86xv.h"
#include "xf86Cursor.h"
#include "Xv.h"
#include "xaalocal.h"
#include "dixstruct.h"
#include "fourcc.h"

#include "radeon.h"
#include "radeon_reg.h"

/*
 * For Debug
#define OUTREG(addr, val)   { xf86DrvMsgVerb(pScrn->scrnIndex,X_INFO,1,"OUTREG(%s,%x)\n",#addr,val) ;MMIO_OUT32(RADEONMMIO, addr, val);}
*/

#define OFF_DELAY       250  /* milliseconds */
#define FREE_DELAY      15000

#define OFF_TIMER       0x01
#define FREE_TIMER      0x02
#define CLIENT_VIDEO_ON 0x04

#define TIMER_MASK      (OFF_TIMER | FREE_TIMER)

#ifndef XvExtension
void RADEONInitVideo(ScreenPtr pScreen) {}
#else
static XF86VideoAdaptorPtr RADEONSetupImageVideo(ScreenPtr);
static int RADEONSetPortAttribute(ScrnInfoPtr, Atom, INT32, pointer);
static int RADEONGetPortAttribute(ScrnInfoPtr, Atom ,INT32 *, pointer);

static void RADEONStopVideo(ScrnInfoPtr, pointer, Bool);
static void RADEONQueryBestSize(ScrnInfoPtr, Bool,
	short, short, short, short, unsigned int *, unsigned int *, pointer);
static int RADEONPutImage( ScrnInfoPtr,
	short, short, short, short, short, short, short, short,
	int, unsigned char*, short, short, Bool, RegionPtr, pointer);
static int RADEONQueryImageAttributes(ScrnInfoPtr,
	int, unsigned short *, unsigned short *,  int *, int *);

#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)

#define IMAGE_MAX_WIDTH         2048
#define IMAGE_MAX_HEIGHT        2048
#define Y_BUF_SIZE              (IMAGE_MAX_WIDTH * IMAGE_MAX_HEIGHT)

static Atom xvColorKey;

typedef struct {
	int             videoStatus;
	unsigned char   brightness;
	unsigned char   contrast;

	RegionRec       clip;
	CARD32          colorKey;
	CARD8           overlay_pixel_size;
	CARD8           current_buffer;
	int             overlay_pad;
	CARD32          overlay_id;
	CARD32          overlay_width;

	CARD32          scale_cntl;
	CARD32          video_format;
	FBLinearPtr     linear;
	} RADEONPortPrivRec, *RADEONPortPrivPtr;

void RADEONInitVideo(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL;
    XF86VideoAdaptorPtr newAdaptor = NULL;
    int num_adaptors;

    RADEONTRACE(("RADEONInitVideo called\n"));

    /* Determine if the card supports this */
    if (pScrn->bitsPerPixel != 8)
    {
	newAdaptor = RADEONSetupImageVideo(pScreen);
    }

    num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);

    if(newAdaptor) {
	if(!num_adaptors) {
	    num_adaptors = 1;
	    adaptors = &newAdaptor;
	} else {
	    newAdaptors =  /* need to free this someplace */
		xalloc((num_adaptors + 1) * sizeof(XF86VideoAdaptorPtr*));
	    if(newAdaptors) {
		memcpy(newAdaptors, adaptors, num_adaptors *
					sizeof(XF86VideoAdaptorPtr));
		newAdaptors[num_adaptors] = newAdaptor;
		adaptors = newAdaptors;
		num_adaptors++;
	    }
	}
    }

    if(num_adaptors)
	xf86XVScreenInit(pScreen, adaptors, num_adaptors);

    if(newAdaptors)
	xfree(newAdaptors);
}

/* client libraries expect an encoding */
static XF86VideoEncodingRec DummyEncoding[1] =
{
 {
   0,
   "XV_IMAGE",
   IMAGE_MAX_WIDTH, IMAGE_MAX_HEIGHT,
   {1, 1}
 }
};

#define NUM_FORMATS 3

static XF86VideoFormatRec Formats[NUM_FORMATS] =
{
  {15, TrueColor},
  {16, TrueColor},
  {32, TrueColor}
};

#define NUM_ATTRIBUTES 1

static XF86AttributeRec Attributes[NUM_ATTRIBUTES] =
{
   {XvSettable | XvGettable, 0, (1<<24)-1, "XV_COLORKEY"},
};

#define NUM_IMAGES 3

static XF86ImageRec Images[NUM_IMAGES] =
{
	XVIMAGE_YUY2,
	XVIMAGE_YV12,
	XVIMAGE_UYVY
};

static void
RADEONResetVideo(ScrnInfoPtr pScrn)
{
    RADEONInfoPtr   info      = RADEONPTR(pScrn);
    unsigned char *RADEONMMIO = info->MMIO;
    RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;

    RADEONTRACE(("RADEONResetVideo called\n"));

    /* Initialize some of the HW here */
    OUTREG(RADEON_OV0_EXCLUSIVE_HORZ,0); /* disable exclusive mode */
    OUTREG(RADEON_OV0_VIDEO_KEY_MSK,0xffff);
    OUTREG(RADEON_OV0_KEY_CNTL, RADEON_GRAPHIC_KEY_FN_NE);
    OUTREG(RADEON_OV0_GRAPHICS_KEY_CLR,pPriv->colorKey);
    /* Only using one buffer for now
    OUTREG(RADEON_OV0_AUTO_FLIP_CNTL,pAPriv->Port[0].auto_flip_cntl);
    */
    switch(pScrn->depth){
    case 8:
	OUTREG(RADEON_OV0_GRAPHICS_KEY_MSK,0xff);
	break;
    case 15:
	OUTREG(RADEON_OV0_GRAPHICS_KEY_MSK,0x7fff);
	break;
    case 16:
	OUTREG(RADEON_OV0_GRAPHICS_KEY_MSK,0xffff);
	break;
    case 24:
	OUTREG(RADEON_OV0_GRAPHICS_KEY_MSK,0xffffff);
	break;
    case 32:
	OUTREG(RADEON_OV0_GRAPHICS_KEY_MSK,0xffffffff);
	break;
    }

    OUTREG(RADEON_OV0_REG_LOAD_CNTL,0x0);
    OUTREG(RADEON_OV0_DEINTERLACE_PATTERN,0xAAAAA);
    OUTREG(RADEON_OV0_P1_V_ACCUM_INIT,(2<<20)|1);
    OUTREG(RADEON_OV0_P23_V_ACCUM_INIT,(2<<20)|1);
    OUTREG(RADEON_OV0_P1_H_ACCUM_INIT,(3<<28));
    OUTREG(RADEON_OV0_P23_H_ACCUM_INIT,(2<<28));
    OUTREG(RADEON_OV0_STEP_BY,1|(1<<8));
    OUTREG(RADEON_OV0_FILTER_CNTL,0xf); /* use hardcoded coeff's */
    OUTREG(RADEON_OV0_FILTER_CNTL,0x0); /* use programmable coeff's */
    OUTREG(RADEON_OV0_FOUR_TAP_COEF_0   , 0x00002000);
    OUTREG(RADEON_OV0_FOUR_TAP_COEF_1   , 0x0D06200D);
    OUTREG(RADEON_OV0_FOUR_TAP_COEF_2   , 0x0D0A1C0D);
    OUTREG(RADEON_OV0_FOUR_TAP_COEF_3   , 0x0C0E1A0C);
    OUTREG(RADEON_OV0_FOUR_TAP_COEF_4   , 0x0C14140C);
    OUTREG(RADEON_OV0_COLOUR_CNTL,(1<<12)|(1<<20));
    OUTREG(RADEON_OV0_TEST,0);
    OUTREG(RADEON_OV0_SCALE_CNTL,pPriv->scale_cntl|pPriv->video_format);
    OUTREG(RADEON_CAP0_TRIG_CNTL,0);
}

static XF86VideoAdaptorPtr
RADEONSetupImageVideo(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    RADEONInfoPtr info = RADEONPTR(pScrn);
    XF86VideoAdaptorPtr adapt;
    RADEONPortPrivPtr pPriv;

    RADEONTRACE(("RADEONSetupImageVideo called\n"));

    if(!(adapt = xcalloc(1, sizeof(XF86VideoAdaptorRec) +
			    sizeof(RADEONPortPrivRec) +
			    sizeof(DevUnion))))
	return NULL;

    adapt->type = XvWindowMask | XvInputMask | XvImageMask;
    adapt->flags = VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT;
    adapt->name = "RADEON Video Overlay";
    adapt->nEncodings = 1;
    adapt->pEncodings = DummyEncoding;
    adapt->nFormats = NUM_FORMATS;
    adapt->pFormats = Formats;
    adapt->nPorts = 1;
    adapt->pPortPrivates = (DevUnion*)(&adapt[1]);

    pPriv = (RADEONPortPrivPtr)(&adapt->pPortPrivates[1]);

    adapt->pPortPrivates[0].ptr = (pointer)(pPriv);
    adapt->pAttributes = Attributes;
    adapt->nImages = NUM_IMAGES;
    adapt->nAttributes = NUM_ATTRIBUTES;
    adapt->pImages = Images;
    adapt->PutVideo = NULL;
    adapt->PutStill = NULL;
    adapt->GetVideo = NULL;
    adapt->GetStill = NULL;
    adapt->StopVideo = RADEONStopVideo;
    adapt->SetPortAttribute = RADEONSetPortAttribute;
    adapt->GetPortAttribute = RADEONGetPortAttribute;
    adapt->QueryBestSize = RADEONQueryBestSize;
    adapt->PutImage = RADEONPutImage;
    adapt->QueryImageAttributes = RADEONQueryImageAttributes;

    /* gotta uninit this someplace */
    REGION_INIT(pScreen, &pPriv->clip, NullBox, 0);

    info->adaptor = adapt;

    pPriv->colorKey = 0x01; /* a touch of blue */
    pPriv->video_format = RADEON_SCALER_SOURCE_VYUY422;
    pPriv->scale_cntl = RADEON_SCALER_PRG_LOAD_START|RADEON_SCALER_DOUBLE_BUFFER;
    pPriv->scale_cntl|= RADEON_SCALER_SMART_SWITCH|RADEON_SCALER_PIX_EXPAND;
    pPriv->scale_cntl|= RADEON_SCALER_SMART_SWITCH;

    xvColorKey   = MAKE_ATOM("XV_COLORKEY");

    RADEONResetVideo(pScrn);

    return adapt;
}

static Bool
RegionsEqual(RegionPtr A, RegionPtr B)
{
    int *dataA, *dataB;
    int num;

    num = REGION_NUM_RECTS(A);
    if(num != REGION_NUM_RECTS(B))
	return FALSE;

    if((A->extents.x1 != B->extents.x1) ||
       (A->extents.x2 != B->extents.x2) ||
       (A->extents.y1 != B->extents.y1) ||
       (A->extents.y2 != B->extents.y2))
	return FALSE;

    dataA = (int*)REGION_RECTS(A);
    dataB = (int*)REGION_RECTS(B);

    while(num--) {
	if((dataA[0] != dataB[0]) || (dataA[1] != dataB[1]))
	   return FALSE;
	dataA += 2;
	dataB += 2;
    }

    return TRUE;
}

static void
RADEONStopVideo(ScrnInfoPtr pScrn, pointer data, Bool Exit)
{
    RADEONInfoPtr   info      = RADEONPTR(pScrn);
    unsigned char *RADEONMMIO = info->MMIO;
    RADEONPortPrivPtr pPriv = (RADEONPortPrivPtr) data;

    RADEONTRACE(("RADEONStopVideo called\n"));

    REGION_EMPTY(pScrn->pScreen, &pPriv->clip);

    if (Exit) {
	if(pPriv->videoStatus & CLIENT_VIDEO_ON) {
	    OUTREG(RADEON_OV0_SCALE_CNTL,pPriv->scale_cntl|pPriv->video_format);
	}
	if(pPriv->linear) {
	    xf86FreeOffscreenLinear(pPriv->linear);
	    pPriv->linear = NULL;
	 }
     pPriv->videoStatus = 0;
  } else {
     if(pPriv->videoStatus & CLIENT_VIDEO_ON) {
     }
  }
}

static int
RADEONSetPortAttribute(
  ScrnInfoPtr pScrn,
  Atom attribute,
  INT32 value,
  pointer data
)
{
    RADEONInfoPtr   info      = RADEONPTR(pScrn);
    unsigned char *RADEONMMIO = info->MMIO;
    RADEONPortPrivPtr pPriv = (RADEONPortPrivPtr) data;

    RADEONTRACE(("RADEONSetPortAttribute called\n"));

    if (attribute == xvColorKey) {
	pPriv->colorKey = value;
	OUTREG(RADEON_OV0_GRAPHICS_KEY_CLR,pPriv->colorKey);
	RADEONTRACE(("Setting ColorKey to %d\n", pPriv->colorKey));
	return Success;
    }

    return Success;
}

static int
RADEONGetPortAttribute(
  ScrnInfoPtr pScrn,
  Atom attribute,
  INT32 *value,
  pointer data
)
{
    RADEONPortPrivPtr pPriv = (RADEONPortPrivPtr) data;

    RADEONTRACE(("RADEONGetPortAttribute called\n"));

    if (attribute == xvColorKey) {
	RADEONTRACE(("Getting ColorKey %d\n", pPriv->colorKey));
	*value = pPriv->colorKey;
	return Success;
    }

    return Success;
}

static void
RADEONQueryBestSize(
  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
)
{
   RADEONTRACE(("RADEONQueryBestSize called\n"));
  *p_w = drw_w;
  *p_h = drw_h;
}

static void
RADEONDisplayVideo(
    ScrnInfoPtr pScrn,
    short width, short height,
    int xa, int ya, int xb, int yb,
    short src_w, short src_h,
    short drw_w, short drw_h,
    int fboffset
)
{
    RADEONInfoPtr   info      = RADEONPTR(pScrn);
    unsigned char *RADEONMMIO = info->MMIO;
    RADEONPortPrivPtr pPriv = info->adaptor->pPortPrivates[0].ptr;
    int step_by, vert_inc, horz_inc;

    RADEONTRACE(("RADEONDisplayVideo called\n"));

    /* calculate step_by factor */
    step_by=src_w/(drw_w*2);
    switch(step_by){
	case 0:
	    OUTREG(RADEON_OV0_STEP_BY,0x101);
	    step_by=1;
	    break;
	case 1:
	    OUTREG(RADEON_OV0_STEP_BY,0x202);
	    step_by=2;
	    break;
	case 2:
	case 3:
	    OUTREG(RADEON_OV0_STEP_BY,0x303);
	    step_by=4;
	    break;
	default:
	    OUTREG(RADEON_OV0_STEP_BY,0x404);
	    step_by=8;
	    break;
    }

    vert_inc=(src_h<<12)/(drw_h);
    horz_inc=(src_w<<12)/(drw_w*step_by);

    OUTREG(RADEON_OV0_Y_X_START,((xa))|(ya<<16)|(1<<31));
    OUTREG(RADEON_OV0_Y_X_END,((xb))|((yb)<<16));
    OUTREG(RADEON_OV0_H_INC,(horz_inc)|((horz_inc<<15)));
    OUTREG(RADEON_OV0_V_INC,(vert_inc<<8));
    OUTREG(RADEON_OV0_P1_BLANK_LINES_AT_TOP,0xfff|((src_h-1)<<16));
    OUTREG(RADEON_OV0_P23_BLANK_LINES_AT_TOP,0xfff|((src_h-1)<<16));
    OUTREG(RADEON_OV0_VID_BUF_PITCH0_VALUE,width<<1);
    OUTREG(RADEON_OV0_VID_BUF_PITCH1_VALUE,width<<1);
    OUTREG(RADEON_OV0_P1_X_START_END,(src_w-1)|((xa&0xf)<<16));
    OUTREG(RADEON_OV0_P2_X_START_END,(src_w-1)|((xa&0xf)<<16));
    OUTREG(RADEON_OV0_P3_X_START_END,(src_w-1)|((xa&0xf)<<16));

    OUTREG(RADEON_OV0_VID_BUF0_BASE_ADRS,(fboffset)&(~0xf));
    OUTREG(RADEON_OV0_VID_BUF1_BASE_ADRS,(fboffset)&(~0xf));
    OUTREG(RADEON_OV0_VID_BUF2_BASE_ADRS,(fboffset)&(~0xf));

#if 0
    /* Enable this when double buffering is implemented */
    OUTREG(RADEON_OV0_VID_BUF3_BASE_ADRS,(fboffset2)&(~0xf));
    OUTREG(RADEON_OV0_VID_BUF4_BASE_ADRS,(fboffset2)&(~0xf));
    OUTREG(RADEON_OV0_VID_BUF5_BASE_ADRS,(fboffset2)&(~0xf));
#endif

    OUTREG(RADEON_OV0_SCALE_CNTL,pPriv->scale_cntl|RADEON_SCALER_ENABLE|pPriv->video_format);
}

static void
RADEONCopyData(
  unsigned char *src,
  unsigned char *dst,
  int srcPitch,
  int dstPitch,
  int h,
  int w
  )
{
    w <<= 1;
    while(h--) {
	memcpy(dst, src, w);
	src += srcPitch;
	dst += dstPitch;
    }
}

static void
RADEONCopyMungedData(
   unsigned char *src1,
   unsigned char *src2,
   unsigned char *src3,
   unsigned char *dst1,
   int srcPitch,
   int srcPitch2,
   int dstPitch,
   int h,
   int w
   )
{
   CARD32 *dst = (CARD32*)dst1;
   int i, j;

   dstPitch >>= 2;
   w >>= 1;

   for(j = 0; j < h; j++) {
	for(i = 0; i < w; i++) {
	    dst[i] = src1[i << 1] | (src1[(i << 1) + 1] << 16) |
		     (src3[i] << 8) | (src2[i] << 24);
	}
	dst += dstPitch;
	src1 += srcPitch;
	if(j & 1) {
	    src2 += srcPitch2;
	    src3 += srcPitch2;
	}
   }
}

static FBLinearPtr
RADEONAllocateMemory(
  ScrnInfoPtr pScrn,
  FBLinearPtr linear,
  int size
)
{
   ScreenPtr pScreen;
   FBLinearPtr new_linear;

   RADEONTRACE(("RADEONAllocateMemory(%x,%d) called\n",linear,size));

   if(linear) {
	if(linear->size >= size)
	   return linear;

	if(xf86ResizeOffscreenLinear(linear, size))
	   return linear;

	xf86FreeOffscreenLinear(linear);
   }

   pScreen = screenInfo.screens[pScrn->scrnIndex];

   new_linear = xf86AllocateOffscreenLinear(pScreen, size, 4,
					    NULL, NULL, NULL);

   if(!new_linear) {
	int max_size;

	xf86QueryLargestOffscreenLinear(pScreen, &max_size, 4,
				       PRIORITY_EXTREME);

	if(max_size < size) return NULL;

	xf86PurgeUnlockedOffscreenAreas(pScreen);
	new_linear = xf86AllocateOffscreenLinear(pScreen, size, 4,
						 NULL, NULL, NULL);
   }

   RADEONTRACE(("returning %x(%x)\n",new_linear,new_linear->offset));

   return new_linear;
}

static int
RADEONPutImage(
  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
)
{
    RADEONInfoPtr   info      = RADEONPTR(pScrn);
    unsigned char *RADEONMMIO = info->MMIO;
    RADEONPortPrivPtr pPriv = (RADEONPortPrivPtr)data;
    INT32 xa, xb, ya, yb;
    INT32 d_x,d_y,d_width,d_height;
    int srcPitch = 0, srcPitch2 = 0;
    int dstPitch = 0;
    int offset,offset2 = 0,offset3 = 0,fboffset;
    int top, left, npixels, nlines, size;
    CARD32 video_format;

    RADEONTRACE(("RADEONPutImage called\n"));

    switch(id) {
    case FOURCC_YV12:
    case FOURCC_UYVY:
	video_format=RADEON_SCALER_SOURCE_VYUY422;
	break;
    case FOURCC_YUY2:
	video_format=RADEON_SCALER_SOURCE_YVYU422;
	break;
    default:
	return BadValue;
    }

   /* Clip */
    d_x=drw_x;
    d_y=drw_y;
    d_width=drw_w;
    d_height=drw_h;
    if(drw_x<0){
	    drw_w+=drw_x;
	    drw_x=0;
	    }
    if(drw_y<0){
	    drw_h+=drw_y;
	    drw_y=0;
	    }
    if(drw_x+drw_w>pScrn->pScreen->width){
	    drw_w=pScrn->pScreen->width-drw_x;
	    }
    if(drw_y+drw_h>pScrn->pScreen->height){
	    drw_h=pScrn->pScreen->height-drw_y;
	    }
    if((drw_w<=0)||(drw_h<=0)){
	    /* this should not happen,
		    since we are outside of visible screen,
		     but just in case */
	    return Success;
	    }

    xa = src_x;
    xb = src_x + src_w;
    ya = src_y;
    yb = src_y + src_h;

    dstPitch = width*info->CurrentLayout.pixel_bytes;
    srcPitch=width;

    switch(id) {
    case FOURCC_YV12:
	 size =  width * height * 2; /* 16bpp */
	 break;
    case FOURCC_UYVY:
    case FOURCC_YUY2:
    default:
	 size = width * height * 1.5;
	 break;
    }

    if(!(pPriv->linear = RADEONAllocateMemory(pScrn, pPriv->linear,size)))
	return BadAlloc;

    /* copy data */
    top = ya >> 16;
    left = (xa >> 16) & ~1;
    npixels = ((((xb + 0xffff) >> 16) + 1) & ~1) - left;

    switch(id) {
    case FOURCC_YV12:
	srcPitch = (width + 3) & ~3;
	offset2 = srcPitch * height;
	srcPitch2 = ((width >> 1) + 3) & ~3;
	offset3 = (srcPitch2 * (height >> 1)) + offset2;
	nlines = ((((yb + 0xffff) >> 16) + 1) & ~1) - top;
	break;
    case FOURCC_UYVY:
    case FOURCC_YUY2:
    default:
	buf += (top * srcPitch) + left;
	nlines = ((yb + 0xffff) >> 16) - top;
	srcPitch = (width << 1);
	break;
    }
    nlines=src_h;
    npixels=src_w;
    if(npixels>width) npixels=width;
    if(nlines>height) nlines=height;

    /* adjust source rectangle */
    src_x+=((drw_x-d_x)*src_w)/d_width;
    src_y+=((drw_y-d_y)*src_h)/d_height;

    src_w=(src_w * drw_w)/d_width;
    src_h=(src_h * drw_h)/d_height;

    offset=(src_x+src_y*width)*info->CurrentLayout.pixel_bytes;
    fboffset=pPriv->linear->offset*info->CurrentLayout.pixel_bytes;

    if(!(INREG(RADEON_CRTC_STATUS)&2)){
	xf86DrvMsg(pScrn->scrnIndex,X_INFO,"too fast");
	return Success;
	}

    RADEONDisplayVideo(pScrn, width, height,
	    drw_x, drw_y, drw_x+drw_w, drw_y+drw_h,
	    src_w, src_h, drw_w, drw_h, fboffset);

    /* update cliplist */
    if(!RegionsEqual(&pPriv->clip, clipBoxes)) {
	REGION_COPY(pScreen, &pPriv->clip, clipBoxes);
	/* draw these */
	XAAFillSolidRects(pScrn, pPriv->colorKey, GXcopy, ~0,
					REGION_NUM_RECTS(clipBoxes),
					REGION_RECTS(clipBoxes));
    }


    switch(id) {
    case FOURCC_YV12:
	RADEONCopyMungedData(buf + (top * srcPitch) + (left >> 1),
	    buf + offset2, buf + offset3, info->FB+fboffset,
	    srcPitch, srcPitch2, dstPitch, nlines, npixels);
	break;
    case FOURCC_UYVY:
    case FOURCC_YUY2:
    default:
	RADEONCopyData(buf,info->FB+fboffset,srcPitch,dstPitch,
	    nlines,npixels);
	 break;
    }

    pPriv->videoStatus = CLIENT_VIDEO_ON;
    return Success;
}

static int
RADEONQueryImageAttributes(
  ScrnInfoPtr pScrn,
  int id,
  unsigned short *w, unsigned short *h,
  int *pitches, int *offsets
)
{
    int size, tmp;
    RADEONTRACE(("RADEONQueryImageAtrributes called\n"));

    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;
}
#endif