/*
 * Copyright 2007 Arthur Huillet
 *
 * 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 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 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 "config.h"

#include <xorg-server.h>
#include <extinit.h>

#ifdef __SSE2__
#include <immintrin.h>
#endif

#include "xf86xv.h"
#include <X11/extensions/Xv.h>
#include "exa.h"
#include "damage.h"
#include "dixstruct.h"
#include "fourcc.h"
#include "regionstr.h"

#include "nv_include.h"
#include "nv_dma.h"

#include "vl_hwmc.h"

#include "hwdefs/nv_m2mf.xml.h"

#define IMAGE_MAX_W 2046
#define IMAGE_MAX_H 2046

#define TEX_IMAGE_MAX_W 4096
#define TEX_IMAGE_MAX_H 4096

#define OFF_DELAY 	500  /* milliseconds */
#define FREE_DELAY 	5000

#define NUM_BLIT_PORTS 16
#define NUM_TEXTURE_PORTS 32


#define NVStopOverlay(X) (((pNv->Architecture == NV_ARCH_04) ? NV04StopOverlay(X) : NV10StopOverlay(X)))

/* Value taken by pPriv -> currentHostBuffer when we failed to allocate the two private buffers in TT memory, so that we can catch this case
and attempt no other allocation afterwards (performance reasons) */
#define NO_PRIV_HOST_BUFFER_AVAILABLE 9999

/* NVPutImage action flags */
enum {
	IS_YV12 = 1,
	IS_YUY2 = 2,
	CONVERT_TO_YUY2=4,
	USE_OVERLAY=8,
	USE_TEXTURE=16,
	SWAP_UV=32,
	IS_RGB=64, //I am not sure how long we will support it
};

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

Atom xvBrightness, xvContrast, xvColorKey, xvSaturation;
Atom xvHue, xvAutopaintColorKey, xvSetDefaults, xvDoubleBuffer;
Atom xvITURBT709, xvSyncToVBlank, xvOnCRTCNb;

/* client libraries expect an encoding */
static XF86VideoEncodingRec DummyEncoding =
{
	0,
	"XV_IMAGE",
	IMAGE_MAX_W, IMAGE_MAX_H,
	{1, 1}
};

static XF86VideoEncodingRec DummyEncodingTex =
{
	0,
	"XV_IMAGE",
	TEX_IMAGE_MAX_W, TEX_IMAGE_MAX_H,
	{1, 1}
};

static XF86VideoEncodingRec DummyEncodingNV50 =
{
	0,
	"XV_IMAGE",
	8192, 8192,
	{1, 1}
};

#define NUM_FORMATS_ALL 6

XF86VideoFormatRec NVFormats[NUM_FORMATS_ALL] =
{
	{15, TrueColor}, {16, TrueColor}, {24, TrueColor},
	{15, DirectColor}, {16, DirectColor}, {24, DirectColor}
};

#define NUM_FORMATS_NV50 8
XF86VideoFormatRec NV50Formats[NUM_FORMATS_NV50] =
{
	{15, TrueColor}, {16, TrueColor}, {24, TrueColor}, {30, TrueColor},
	{15, DirectColor}, {16, DirectColor}, {24, DirectColor}, {30, DirectColor}
};

#define NUM_NV04_OVERLAY_ATTRIBUTES 4
XF86AttributeRec NV04OverlayAttributes[NUM_NV04_OVERLAY_ATTRIBUTES] =
{
	    {XvSettable | XvGettable, -512, 511, "XV_BRIGHTNESS"},
	    {XvSettable | XvGettable, 0, (1 << 24) - 1, "XV_COLORKEY"},
	    {XvSettable | XvGettable, 0, 1, "XV_AUTOPAINT_COLORKEY"},
	    {XvSettable             , 0, 0, "XV_SET_DEFAULTS"},
};


#define NUM_NV10_OVERLAY_ATTRIBUTES 10
XF86AttributeRec NV10OverlayAttributes[NUM_NV10_OVERLAY_ATTRIBUTES] =
{
	{XvSettable | XvGettable, 0, 1, "XV_DOUBLE_BUFFER"},
	{XvSettable | XvGettable, 0, (1 << 24) - 1, "XV_COLORKEY"},
	{XvSettable | XvGettable, 0, 1, "XV_AUTOPAINT_COLORKEY"},
	{XvSettable             , 0, 0, "XV_SET_DEFAULTS"},
	{XvSettable | XvGettable, -512, 511, "XV_BRIGHTNESS"},
	{XvSettable | XvGettable, 0, 8191, "XV_CONTRAST"},
	{XvSettable | XvGettable, 0, 8191, "XV_SATURATION"},
	{XvSettable | XvGettable, 0, 360, "XV_HUE"},
	{XvSettable | XvGettable, 0, 1, "XV_ITURBT_709"},
	{XvSettable | XvGettable, 0, 1, "XV_ON_CRTC_NB"},
};

#define NUM_BLIT_ATTRIBUTES 2
XF86AttributeRec NVBlitAttributes[NUM_BLIT_ATTRIBUTES] =
{
	{XvSettable             , 0, 0, "XV_SET_DEFAULTS"},
	{XvSettable | XvGettable, 0, 1, "XV_SYNC_TO_VBLANK"}
};

#define NUM_TEXTURED_ATTRIBUTES 2
XF86AttributeRec NVTexturedAttributes[NUM_TEXTURED_ATTRIBUTES] =
{
	{XvSettable             , 0, 0, "XV_SET_DEFAULTS"},
	{XvSettable | XvGettable, 0, 1, "XV_SYNC_TO_VBLANK"}
};

#define NUM_TEXTURED_ATTRIBUTES_NV50 7
XF86AttributeRec NVTexturedAttributesNV50[NUM_TEXTURED_ATTRIBUTES_NV50] =
{
	{ XvSettable             , 0, 0, "XV_SET_DEFAULTS" },
	{ XvSettable | XvGettable, 0, 1, "XV_SYNC_TO_VBLANK" },
	{ XvSettable | XvGettable, -1000, 1000, "XV_BRIGHTNESS" },
	{ XvSettable | XvGettable, -1000, 1000, "XV_CONTRAST" },
	{ XvSettable | XvGettable, -1000, 1000, "XV_SATURATION" },
	{ XvSettable | XvGettable, -1000, 1000, "XV_HUE" },
	{ XvSettable | XvGettable, 0, 1, "XV_ITURBT_709" }
};

#define NUM_IMAGES_YUV 4
#define NUM_IMAGES_ALL 5

#define FOURCC_RGB 0x0000003
#define XVIMAGE_RGB \
   { \
        FOURCC_RGB, \
        XvRGB, \
        LSBFirst, \
        { 0x03, 0x00, 0x00, 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 XF86ImageRec NVImages[NUM_IMAGES_ALL] =
{
	XVIMAGE_YUY2,
	XVIMAGE_YV12,
	XVIMAGE_UYVY,
	XVIMAGE_I420,
	XVIMAGE_RGB
};

static void
box_intersect(BoxPtr dest, BoxPtr a, BoxPtr b)
{
	dest->x1 = a->x1 > b->x1 ? a->x1 : b->x1;
	dest->x2 = a->x2 < b->x2 ? a->x2 : b->x2;
	if (dest->x1 >= dest->x2) {
		dest->x1 = dest->x2 = dest->y1 = dest->y2 = 0;
		return;
	}

	dest->y1 = a->y1 > b->y1 ? a->y1 : b->y1;
	dest->y2 = a->y2 < b->y2 ? a->y2 : b->y2;
	if (dest->y1 >= dest->y2)
		dest->x1 = dest->x2 = dest->y1 = dest->y2 = 0;
}

static int
box_area(BoxPtr box)
{
    return (int) (box->x2 - box->x1) * (int) (box->y2 - box->y1);
}

static void
rr_crtc_box(RRCrtcPtr crtc, BoxPtr crtc_box)
{
	if (crtc->mode) {
		crtc_box->x1 = crtc->x;
		crtc_box->y1 = crtc->y;
		switch (crtc->rotation) {
		case RR_Rotate_0:
		case RR_Rotate_180:
		default:
			crtc_box->x2 = crtc->x + crtc->mode->mode.width;
			crtc_box->y2 = crtc->y + crtc->mode->mode.height;
			break;
		case RR_Rotate_90:
		case RR_Rotate_270:
			crtc_box->x2 = crtc->x + crtc->mode->mode.height;
			crtc_box->y2 = crtc->y + crtc->mode->mode.width;
			break;
		}
	} else
		crtc_box->x1 = crtc_box->x2 = crtc_box->y1 = crtc_box->y2 = 0;
}

static Bool
rr_crtc_on(RRCrtcPtr crtc, Bool crtc_is_xf86_hint)
{
	if (!crtc) {
		return FALSE;
	}
	if (crtc_is_xf86_hint && crtc->devPrivate) {
		return xf86_crtc_on(crtc->devPrivate);
	} else {
		return !!crtc->mode;
	}
}

/*
 * Return the crtc covering 'box'. If two crtcs cover a portion of
 * 'box', then prefer the crtc with greater coverage.
 */
static RRCrtcPtr
rr_crtc_covering_box(ScreenPtr pScreen, BoxPtr box, Bool screen_is_xf86_hint)
{
	rrScrPrivPtr pScrPriv;
	RRCrtcPtr crtc, best_crtc, primary_crtc;
	int coverage, best_coverage;
	int c;
	BoxRec crtc_box, cover_box;
	RROutputPtr primary_output;

	best_crtc = NULL;
	best_coverage = 0;
	primary_crtc = NULL;
	primary_output = NULL;

	if (!dixPrivateKeyRegistered(rrPrivKey))
		return NULL;

	pScrPriv = rrGetScrPriv(pScreen);

	if (!pScrPriv)
		return NULL;

	primary_output = RRFirstOutput(pScreen);
	if (primary_output && primary_output->crtc)
		primary_crtc = primary_output->crtc->devPrivate;

	for (c = 0; c < pScrPriv->numCrtcs; c++) {
		crtc = pScrPriv->crtcs[c];

		/* If the CRTC is off, treat it as not covering */
		if (!rr_crtc_on(crtc, screen_is_xf86_hint))
			continue;

		rr_crtc_box(crtc, &crtc_box);
		box_intersect(&cover_box, &crtc_box, box);
		coverage = box_area(&cover_box);
		if (coverage > best_coverage ||
		   (crtc == primary_crtc && coverage == best_coverage)) {
			best_crtc = crtc;
			best_coverage = coverage;
		}
	}

	return best_crtc;
}

#if ABI_VIDEODRV_VERSION >= SET_ABI_VERSION(23, 0)
static RRCrtcPtr
rr_crtc_covering_box_on_secondary(ScreenPtr pScreen, BoxPtr box)
{
	if (!pScreen->isGPU) {
		ScreenPtr secondary;
		RRCrtcPtr crtc = NULL;

		xorg_list_for_each_entry(secondary, &pScreen->secondary_list, secondary_head) {
			if (!secondary->is_output_secondary)
				continue;

			crtc = rr_crtc_covering_box(secondary, box, FALSE);
			if (crtc)
				return crtc;
		}
	}

	return NULL;
}
#endif

RRCrtcPtr
randr_crtc_covering_drawable(DrawablePtr pDraw)
{
	ScreenPtr pScreen = pDraw->pScreen;
	RRCrtcPtr crtc = NULL;
	BoxRec box;

	box.x1 = pDraw->x;
	box.y1 = pDraw->y;
	box.x2 = box.x1 + pDraw->width;
	box.y2 = box.y1 + pDraw->height;

	crtc = rr_crtc_covering_box(pScreen, &box, TRUE);
#if ABI_VIDEODRV_VERSION >= SET_ABI_VERSION(23, 0)
	if (!crtc) {
		crtc = rr_crtc_covering_box_on_secondary(pScreen, &box);
	}
#endif
	return crtc;
}

xf86CrtcPtr
nouveau_pick_best_crtc(ScrnInfoPtr pScrn,
                       int x, int y, int w, int h)
{
    ScreenPtr pScreen = pScrn->pScreen;
    RRCrtcPtr crtc = NULL;
    BoxRec box;

    if (!pScrn->vtSema)
	return NULL;

    box.x1 = x;
    box.x2 = x + w;
    box.y1 = y;
    box.y2 = y + h;

    crtc = rr_crtc_covering_box(pScreen, &box, TRUE);
    if (crtc) {
	return crtc->devPrivate;
    }
    return NULL;
}

unsigned int
nv_window_belongs_to_crtc(ScrnInfoPtr pScrn, int x, int y, int w, int h)
{
	xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
	unsigned int mask = 0;
	int i;

	for (i = 0; i < xf86_config->num_crtc; i++) {
		xf86CrtcPtr crtc = xf86_config->crtc[i];

		if (!xf86_crtc_on(crtc))
			continue;

		if ((x < (crtc->x + crtc->mode.HDisplay)) &&
		    (y < (crtc->y + crtc->mode.VDisplay)) &&
		    ((x + w) > crtc->x) &&
		    ((y + h) > crtc->y))
		    mask |= 1 << i;
	}

	return mask;
}

/**
 * NVSetPortDefaults
 * set attributes of port "pPriv" to compiled-in (except for colorKey) defaults
 * this function does not care about the kind of adapter the port is for
 *
 * @param pScrn screen to get the default colorKey from
 * @param pPriv port to reset to defaults
 */
void
NVSetPortDefaults (ScrnInfoPtr pScrn, NVPortPrivPtr pPriv)
{
	NVPtr pNv = NVPTR(pScrn);

	pPriv->brightness		= 0;
	pPriv->contrast			= 4096;
	pPriv->saturation		= 4096;
	pPriv->hue			= 0;
	pPriv->colorKey			= pNv->videoKey;
	pPriv->autopaintColorKey	= TRUE;
	pPriv->doubleBuffer		= pNv->Architecture != NV_ARCH_04;
	pPriv->iturbt_709		= FALSE;
	pPriv->currentHostBuffer	= 0;
}

static int
nouveau_xv_bo_realloc(ScrnInfoPtr pScrn, unsigned flags, unsigned size,
		      struct nouveau_bo **pbo)
{
	union nouveau_bo_config config = {};
	NVPtr pNv = NVPTR(pScrn);

	if (*pbo) {
		if ((*pbo)->size >= size)
			return 0;
		nouveau_bo_ref(NULL, pbo);
	}

	if (flags & NOUVEAU_BO_VRAM) {
		if (pNv->Architecture == NV_TESLA)
			config.nv50.memtype = 0x70;
		else
		if (pNv->Architecture >= NV_FERMI)
			config.nvc0.memtype = 0xfe;
	}
	flags |= NOUVEAU_BO_MAP;

	return nouveau_bo_new(pNv->dev, flags, 0, size, &config, pbo);
}

/**
 * NVFreePortMemory
 * frees memory held by a given port
 *
 * @param pScrn screen whose port wants to free memory
 * @param pPriv port to free memory of
 */
static void
NVFreePortMemory(ScrnInfoPtr pScrn, NVPortPrivPtr pPriv)
{
	nouveau_bo_ref(NULL, &pPriv->video_mem);
	nouveau_bo_ref(NULL, &pPriv->TT_mem_chunk[0]);
	nouveau_bo_ref(NULL, &pPriv->TT_mem_chunk[1]);
}

/**
 * NVFreeOverlayMemory
 * frees memory held by the overlay port
 *
 * @param pScrn screen whose overlay port wants to free memory
 */
static void
NVFreeOverlayMemory(ScrnInfoPtr pScrn)
{
	NVPtr	pNv = NVPTR(pScrn);
	NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);

	NVFreePortMemory(pScrn, pPriv);
#if NVOVL_SUPPORT
	/* "power cycle" the overlay */
	nvWriteMC(pNv, NV_PMC_ENABLE,
		  (nvReadMC(pNv, NV_PMC_ENABLE) & 0xEFFFFFFF));
	nvWriteMC(pNv, NV_PMC_ENABLE,
		  (nvReadMC(pNv, NV_PMC_ENABLE) | 0x10000000));
#endif
}

/**
 * NVFreeBlitMemory
 * frees memory held by the blit port
 *
 * @param pScrn screen whose blit port wants to free memory
 */
static void
NVFreeBlitMemory(ScrnInfoPtr pScrn)
{
	NVPtr	pNv = NVPTR(pScrn);
	NVPortPrivPtr pPriv = GET_BLIT_PRIVATE(pNv);

	NVFreePortMemory(pScrn, pPriv);
}

/**
 * NVVideoTimerCallback
 * callback function which perform cleanup tasks (stop overlay, free memory).
 * within the driver
 * purpose and use is unknown
 */
void
NVVideoTimerCallback(ScrnInfoPtr pScrn, Time currentTime)
{
	NVPtr         pNv = NVPTR(pScrn);
	NVPortPrivPtr pOverPriv = NULL;
	NVPortPrivPtr pBlitPriv = NULL;
	Bool needCallback = FALSE;

	if (!pScrn->vtSema)
		return;

	if (pNv->overlayAdaptor) {
		pOverPriv = GET_OVERLAY_PRIVATE(pNv);
		if (!pOverPriv->videoStatus)
			pOverPriv = NULL;
	}

	if (pNv->blitAdaptor) {
		pBlitPriv = GET_BLIT_PRIVATE(pNv);
		if (!pBlitPriv->videoStatus)
			pBlitPriv = NULL;
	}

	if (pOverPriv) {
		if (pOverPriv->videoTime < currentTime) {
			if (pOverPriv->videoStatus & OFF_TIMER) {
				NVStopOverlay(pScrn);
				pOverPriv->videoStatus = FREE_TIMER;
				pOverPriv->videoTime = currentTime + FREE_DELAY;
				needCallback = TRUE;
			} else
			if (pOverPriv->videoStatus & FREE_TIMER) {
				NVFreeOverlayMemory(pScrn);
				pOverPriv->videoStatus = 0;
			}
		} else {
			needCallback = TRUE;
		}
	}

	if (pBlitPriv) {
		if (pBlitPriv->videoTime < currentTime) {
			NVFreeBlitMemory(pScrn);
			pBlitPriv->videoStatus = 0;
		} else {
			needCallback = TRUE;
		}
	}

	pNv->VideoTimerCallback = needCallback ? NVVideoTimerCallback : NULL;
}

/*
 * StopVideo
 */
static void
NVStopOverlayVideo(ScrnInfoPtr pScrn, void *data, Bool Exit)
{
	NVPtr         pNv   = NVPTR(pScrn);
	NVPortPrivPtr pPriv = (NVPortPrivPtr)data;

	if (pPriv->grabbedByV4L)
		return;

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

	if(Exit) {
		if (pPriv->videoStatus & CLIENT_VIDEO_ON)
			NVStopOverlay(pScrn);
		NVFreeOverlayMemory(pScrn);
		pPriv->videoStatus = 0;
	} else {
		if (pPriv->videoStatus & CLIENT_VIDEO_ON) {
			pPriv->videoStatus = OFF_TIMER | CLIENT_VIDEO_ON;
			pPriv->videoTime = currentTime.milliseconds + OFF_DELAY;
			pNv->VideoTimerCallback = NVVideoTimerCallback;
		}
	}
}

/**
 * QueryBestSize
 * used by client applications to ask the driver:
 * how would you actually scale a video of dimensions
 * vid_w, vid_h, if i wanted you to scale it to dimensions
 * drw_w, drw_h?
 * function stores actual scaling size in pointers p_w, p_h.
 *
 *
 * @param pScrn unused
 * @param motion unused
 * @param vid_w width of source video
 * @param vid_h height of source video
 * @param drw_w desired scaled width as requested by client
 * @param drw_h desired scaled height as requested by client
 * @param p_w actual scaled width as the driver is capable of
 * @param p_h actual scaled height as the driver is capable of
 * @param data unused
 */
static void
NVQueryBestSize(ScrnInfoPtr pScrn, Bool motion,
		short vid_w, short vid_h,
		short drw_w, short drw_h,
		unsigned int *p_w, unsigned int *p_h,
		void *data)
{
	if(vid_w > (drw_w << 3))
		drw_w = vid_w >> 3;
	if(vid_h > (drw_h << 3))
		drw_h = vid_h >> 3;

	*p_w = drw_w;
	*p_h = drw_h;
}

/**
 * NVCopyData420
 * used to convert YV12 to YUY2 for the blitter and NV04 overlay.
 * The U and V samples generated are linearly interpolated on the vertical
 * axis for better quality
 *
 * @param src1 source buffer of luma
 * @param src2 source buffer of chroma1
 * @param src3 source buffer of chroma2
 * @param dst1 destination buffer
 * @param srcPitch pitch of src1
 * @param srcPitch2 pitch of src2, src3
 * @param dstPitch pitch of dst1
 * @param h number of lines to copy
 * @param w length of lines to copy
 */
static inline void
NVCopyData420(unsigned char *src1, unsigned char *src2, unsigned char *src3,
	      unsigned char *dst1, int srcPitch, int srcPitch2, int dstPitch,
	      int h, int w)
{
	CARD32 *dst;
	CARD8 *s1, *s2, *s3;
	int i, j;

#define su(X) (((j & 1) && j < (h-1)) ? ((unsigned)((signed int)s2[X] +        \
		(signed int)(s2 + srcPitch2)[X]) / 2) : (s2[X]))
#define sv(X) (((j & 1) && j < (h-1)) ? ((unsigned)((signed int)s3[X] +        \
		(signed int)(s3 + srcPitch2)[X]) / 2) : (s3[X]))

	w >>= 1;

	for (j = 0; j < h; j++) {
		dst = (CARD32*)dst1;
		s1 = src1;  s2 = src2;  s3 = src3;
		i = w;

		while (i > 4) {
#if X_BYTE_ORDER == X_BIG_ENDIAN
		dst[0] = (s1[0] << 24) | (s1[1] << 8) | (sv(0) << 16) | su(0);
		dst[1] = (s1[2] << 24) | (s1[3] << 8) | (sv(1) << 16) | su(1);
		dst[2] = (s1[4] << 24) | (s1[5] << 8) | (sv(2) << 16) | su(2);
		dst[3] = (s1[6] << 24) | (s1[7] << 8) | (sv(3) << 16) | su(3);
#else
		dst[0] = s1[0] | (s1[1] << 16) | (sv(0) << 8) | (su(0) << 24);
		dst[1] = s1[2] | (s1[3] << 16) | (sv(1) << 8) | (su(1) << 24);
		dst[2] = s1[4] | (s1[5] << 16) | (sv(2) << 8) | (su(2) << 24);
		dst[3] = s1[6] | (s1[7] << 16) | (sv(3) << 8) | (su(3) << 24);
#endif
		dst += 4; s2 += 4; s3 += 4; s1 += 8;
		i -= 4;
		}

		while (i--) {
#if X_BYTE_ORDER == X_BIG_ENDIAN
		dst[0] = (s1[0] << 24) | (s1[1] << 8) | (sv(0) << 16) | su(0);
#else
		dst[0] = s1[0] | (s1[1] << 16) | (sv(0) << 8) | (su(0) << 24);
#endif
		dst++; s2++; s3++;
		s1 += 2;
		}

		dst1 += dstPitch;
		src1 += srcPitch;
		if (j & 1) {
			src2 += srcPitch2;
			src3 += srcPitch2;
		}
	}
}

/**
 * NVCopyNV12ColorPlanes
 * Used to convert YV12 color planes to NV12 (interleaved UV) for the overlay
 *
 * @param src1 source buffer of chroma1
 * @param dst1 destination buffer
 * @param h number of lines to copy
 * @param w length of lines to copy
 * @param id source pixel format (YV12 or I420)
 */
static inline void
NVCopyNV12ColorPlanes(unsigned char *src1, unsigned char *src2,
		      unsigned char *dst, int dstPitch, int srcPitch2,
		      int h, int w)
{
	int i, j, l, e;

	w >>= 1;
	h >>= 1;
#ifdef __SSE2__
	l = w >> 3;
	e = w & 7;
#else
	l = w >> 1;
	e = w & 1;
#endif

	for (j = 0; j < h; j++) {
		unsigned char *us = src1;
		unsigned char *vs = src2;
		unsigned int *vuvud = (unsigned int *) dst;
		unsigned short *vud;

		for (i = 0; i < l; i++) {
#ifdef __SSE2__
			_mm_storeu_si128(
				(void*)vuvud,
				_mm_unpacklo_epi8(
					_mm_loadl_epi64((void*)vs),
					_mm_loadl_epi64((void*)us)));
			vuvud+=4;
			us+=8;
			vs+=8;
#else /* __SSE2__ */
#  if X_BYTE_ORDER == X_BIG_ENDIAN
			*vuvud++ = (vs[0]<<24) | (us[0]<<16) | (vs[1]<<8) | us[1];
#  else
			*vuvud++ = vs[0] | (us[0]<<8) | (vs[1]<<16) | (us[1]<<24);
#  endif
			us+=2;
			vs+=2;
#endif /* __SSE2__ */
		}

		vud = (unsigned short *)vuvud;
		for (i = 0; i < e; i++) {
#if X_BYTE_ORDER == X_BIG_ENDIAN
			vud[i] = us[i] | (vs[i]<<8);
#else
			vud[i] = vs[i] | (us[i]<<8);
#endif
		}

		dst += dstPitch;
		src1 += srcPitch2;
		src2 += srcPitch2;
	}

}


static int
NV_set_dimensions(ScrnInfoPtr pScrn, int action_flags, INT32 *xa, INT32 *xb,
		  INT32 *ya, INT32 *yb, short *src_x, short *src_y,
		  short *src_w, short *src_h, short *drw_x, short *drw_y,
		  short *drw_w, short *drw_h, int *left, int *top, int *right,
		  int *bottom, BoxRec *dstBox, int *npixels, int *nlines,
		  RegionPtr clipBoxes, short width, short height)
{
	NVPtr pNv = NVPTR(pScrn);

	if (action_flags & USE_OVERLAY) {
		switch (pNv->Architecture) {
		case NV_ARCH_04:
			/* NV0x overlay can't scale down. at all. */
			if (*drw_w < *src_w)
				*drw_w = *src_w;
			if (*drw_h < *src_h)
				*drw_h = *src_h;
			break;
		case NV_ARCH_30:
			/* According to DirectFB, NV3x can't scale down by
			 * a ratio > 2
			 */
			if (*drw_w < (*src_w) >> 1)
				*drw_w = *src_w;
			if (*drw_h < (*src_h) >> 1)
				*drw_h = *src_h;
			break;
		default: /*NV10, NV20*/
			/* NV1x overlay can't scale down by a ratio > 8 */
			if (*drw_w < (*src_w) >> 3)
				*drw_w = *src_w >> 3;
			if (*drw_h < (*src_h >> 3))
				*drw_h = *src_h >> 3;
		}
	}

	/* Clip */
	*xa = *src_x;
	*xb = *src_x + *src_w;
	*ya = *src_y;
	*yb = *src_y + *src_h;

	dstBox->x1 = *drw_x;
	dstBox->x2 = *drw_x + *drw_w;
	dstBox->y1 = *drw_y;
	dstBox->y2 = *drw_y + *drw_h;

	/* In randr 1.2 mode VIDEO_CLIP_TO_VIEWPORT is broken (hence it is not
	 * set in the overlay adapter flags) since pScrn->frame{X,Y}1 do not get
	 * updated. Hence manual clipping against the CRTC dimensions
	 */
	if (action_flags & USE_OVERLAY) {
		NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);
		unsigned id = pPriv->overlayCRTC;
		xf86CrtcPtr crtc = XF86_CRTC_CONFIG_PTR(pScrn)->crtc[id];
		RegionRec VPReg;
		BoxRec VPBox;

		VPBox.x1 = crtc->x;
		VPBox.y1 = crtc->y;
		VPBox.x2 = crtc->x + crtc->mode.HDisplay;
		VPBox.y2 = crtc->y + crtc->mode.VDisplay;

		REGION_INIT(pScreen, &VPReg, &VPBox, 1);
		REGION_INTERSECT(pScreen, clipBoxes, clipBoxes, &VPReg);
		REGION_UNINIT(pScreen, &VPReg);
	}

	if (!xf86XVClipVideoHelper(dstBox, xa, xb, ya, yb, clipBoxes,
				   width, height))
		return -1;

	if (action_flags & USE_OVERLAY)	{
		xf86CrtcConfigPtr xf86_config =
			XF86_CRTC_CONFIG_PTR(pScrn);
		NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);

		dstBox->x1 -= xf86_config->crtc[pPriv->overlayCRTC]->x;
		dstBox->x2 -= xf86_config->crtc[pPriv->overlayCRTC]->x;
		dstBox->y1 -= xf86_config->crtc[pPriv->overlayCRTC]->y;
		dstBox->y2 -= xf86_config->crtc[pPriv->overlayCRTC]->y;
	}

	/* Convert fixed point to integer, as xf86XVClipVideoHelper probably
	 * turns its parameter into fixed point values
	 */
	*left = (*xa) >> 16;
	if (*left < 0)
		*left = 0;

	*top = (*ya) >> 16;
	if (*top < 0)
		*top = 0;

	*right = (*xb) >> 16;
	if (*right > width)
		*right = width;

	*bottom = (*yb) >> 16;
	if (*bottom > height)
		*bottom = height;

	if (action_flags & IS_YV12) {
		/* even "left", even "top", even number of pixels per line
		 * and even number of lines
		 */
		*left &= ~1;
		*npixels = ((*right + 1) & ~1) - *left;
		*top &= ~1;
		*nlines = ((*bottom + 1) & ~1) - *top;
	} else
	if (action_flags & IS_YUY2) {
		/* even "left" */
		*left &= ~1;
		/* even number of pixels per line */
		*npixels = ((*right + 1) & ~1) - *left;
		*nlines = *bottom - *top;
		/* 16bpp */
		*left <<= 1;
	} else
	if (action_flags & IS_RGB) {
		*npixels = *right - *left;
		*nlines = *bottom - *top;
		/* 32bpp */
		*left <<= 2;
	}

	return 0;
}

static int
NV_calculate_pitches_and_mem_size(NVPtr pNv, int action_flags, int *srcPitch,
				  int *srcPitch2, int *dstPitch, int *s2offset,
				  int *s3offset, int *uv_offset,
				  int *newFBSize, int *newTTSize,
				  int *line_len, int npixels, int nlines,
				  int width, int height)
{
	int tmp;

	if (pNv->Architecture >= NV_TESLA) {
		npixels = (npixels + 7) & ~7;
		nlines = (nlines + 7) & ~7;
	}

	if (action_flags & IS_YV12) {
		*srcPitch = (width + 3) & ~3;	/* of luma */
		*s2offset = *srcPitch * height;
		*srcPitch2 = ((width >> 1) + 3) & ~3; /*of chroma*/
		*s3offset = (*srcPitch2 * (height >> 1)) + *s2offset;
		*dstPitch = (npixels + 63) & ~63; /*luma and chroma pitch*/
		*line_len = npixels;
		*uv_offset = nlines * *dstPitch;
		*newFBSize = *uv_offset + (nlines >> 1) * *dstPitch;
		*newTTSize = *uv_offset + (nlines >> 1) * *dstPitch;
	} else
	if (action_flags & IS_YUY2) {
		*srcPitch = width << 1; /* one luma, one chroma per pixel */
		*dstPitch = ((npixels << 1) + 63) & ~63;
		*line_len = npixels << 1;
		*newFBSize = nlines * *dstPitch;
		*newTTSize = nlines * *line_len;
	} else
	if (action_flags & IS_RGB) {
		/* one R, one G, one B, one X per pixel */
		*srcPitch = width << 2;
		*dstPitch = ((npixels << 2) + 63) & ~63;
		*line_len = npixels << 2;
		*newFBSize = nlines * *dstPitch;
		*newTTSize = nlines * *dstPitch;
	}

	if (action_flags & CONVERT_TO_YUY2) {
		*dstPitch = ((npixels << 1) + 63) & ~63;
		*line_len = npixels << 1;
		*newFBSize = nlines * *dstPitch;
		*newTTSize = nlines * *line_len;
		*uv_offset = 0;
	}

	if (action_flags & SWAP_UV)  {
		/* I420 swaps U and V */
		tmp = *s2offset;
		*s2offset = *s3offset;
		*s3offset = tmp;
	}

	/* Overlay double buffering... */
	if (action_flags & USE_OVERLAY)
                (*newFBSize) <<= 1;

	return 0;
}


/**
 * NV_set_action_flags
 * This function computes the action flags from the input image,
 * that is, it decides what NVPutImage and its helpers must do.
 * This eases readability by avoiding lots of switch-case statements in the
 * core NVPutImage
 */
static void
NV_set_action_flags(ScrnInfoPtr pScrn, DrawablePtr pDraw, NVPortPrivPtr pPriv,
		    int id, short drw_x, short drw_y, short drw_w, short drw_h,
		    int *action_flags)
{
	NVPtr pNv = NVPTR(pScrn);

#define USING_OVERLAY (*action_flags & USE_OVERLAY)
#define USING_TEXTURE (*action_flags & USE_TEXTURE)
#define USING_BLITTER ((!(*action_flags & USE_OVERLAY)) &&                     \
		       (!(*action_flags & USE_TEXTURE)))

	*action_flags = 0;

	/* Pixel format-related bits */
	if (id == FOURCC_YUY2 || id == FOURCC_UYVY)
		*action_flags |= IS_YUY2;

	if (id == FOURCC_YV12 || id == FOURCC_I420)
		*action_flags |= IS_YV12;

	if (id == FOURCC_RGB) /*How long will we support it?*/
		*action_flags |= IS_RGB;

	if (id == FOURCC_I420) /* I420 is YV12 with swapped UV */
		*action_flags |= SWAP_UV;

	/* Desired adapter */
	if (!pPriv->blitter && !pPriv->texture)
		*action_flags |= USE_OVERLAY;

	if (!pPriv->blitter && pPriv->texture)
		*action_flags |= USE_TEXTURE;

	/* Adapter fallbacks (when the desired one can't be used)*/
#ifdef COMPOSITE
	{
		PixmapPtr ppix = NVGetDrawablePixmap(pDraw);

		/* this is whether ppix is in the viewable fb, not related to
		   the EXA "offscreen" stuff */
		if (!nouveau_exa_pixmap_is_onscreen(ppix))
			*action_flags &= ~USE_OVERLAY;
	}
#endif

#ifdef NVOVL_SUPPORT
	if (USING_OVERLAY) {
		char crtc = nv_window_belongs_to_crtc(pScrn, drw_x, drw_y,
						      drw_w, drw_h);

		if ((crtc & (1 << 0)) && (crtc & (1 << 1))) {
			/* The overlay cannot be used on two CRTCs at a time,
			 * so we need to fallback on the blitter
			 */
			*action_flags &= ~USE_OVERLAY;
		} else
		if ((crtc & (1 << 0))) {
			/* We need to put the overlay on CRTC0 - if it's not
			 * already here
			 */
			if (pPriv->overlayCRTC == 1) {
				NVWriteCRTC(pNv, 0, NV_PCRTC_ENGINE_CTRL,
					    NVReadCRTC(pNv, 0, NV_PCRTC_ENGINE_CTRL) |
					    NV_CRTC_FSEL_OVERLAY);
				NVWriteCRTC(pNv, 1, NV_PCRTC_ENGINE_CTRL,
					    NVReadCRTC(pNv, 1, NV_PCRTC_ENGINE_CTRL) &
					    ~NV_CRTC_FSEL_OVERLAY);
				pPriv->overlayCRTC = 0;
			}
		} else
		if ((crtc & (1 << 1))) {
			if (pPriv->overlayCRTC == 0) {
				NVWriteCRTC(pNv, 1, NV_PCRTC_ENGINE_CTRL,
					    NVReadCRTC(pNv, 1, NV_PCRTC_ENGINE_CTRL) |
					    NV_CRTC_FSEL_OVERLAY);
				NVWriteCRTC(pNv, 0, NV_PCRTC_ENGINE_CTRL,
					    NVReadCRTC(pNv, 0, NV_PCRTC_ENGINE_CTRL) &
					    ~NV_CRTC_FSEL_OVERLAY);
				pPriv->overlayCRTC = 1;
			}
		}

		if (XF86_CRTC_CONFIG_PTR(pScrn)->crtc[pPriv->overlayCRTC]
						 ->rotation != RR_Rotate_0)
			*action_flags &= ~USE_OVERLAY;
	}
#endif

	/* At this point the adapter we're going to use is _known_.
	 * You cannot change it now.
	 */

	/* Card/adapter format restrictions */
	if (USING_BLITTER) {
		/* The blitter does not handle YV12 natively */
		if (id == FOURCC_YV12 || id == FOURCC_I420)
			*action_flags |= CONVERT_TO_YUY2;
	}

	if (USING_OVERLAY && (pNv->Architecture == NV_ARCH_04)) {
		/* NV04-05 don't support YV12, only YUY2 and ITU-R BT.601 */
		if (*action_flags & IS_YV12)
			*action_flags |= CONVERT_TO_YUY2;
	}

	if (USING_OVERLAY && (pNv->Architecture == NV_ARCH_10 ||
			      pNv->Architecture == NV_ARCH_20)) {
		/* No YV12 overlay on NV10, 11, 15, 20, NFORCE */
		switch (pNv->dev->chipset) {
		case 0x10:
		case 0x11:
		case 0x15:
		case 0x1a: /*XXX: unsure about nforce */
		case 0x20:
			*action_flags |= CONVERT_TO_YUY2;
			break;
		default:
			break;
		}
	}
}


/**
 * NVPutImage
 * PutImage is "the" important function of the Xv extension.
 * a client (e.g. video player) calls this function for every
 * image (of the video) to be displayed. this function then
 * scales and displays the image.
 *
 * @param pScrn screen which hold the port where the image is put
 * @param src_x source point in the source image to start displaying from
 * @param src_y see above
 * @param src_w width of the source image to display
 * @param src_h see above
 * @param drw_x  screen point to display to
 * @param drw_y
 * @param drw_w width of the screen drawable
 * @param drw_h
 * @param id pixel format of image
 * @param buf pointer to buffer containing the source image
 * @param width total width of the source image we are passed
 * @param height
 * @param Sync unused
 * @param clipBoxes ??
 * @param data pointer to port
 * @param pDraw drawable pointer
 */
static int
NVPutImage(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, void *data, DrawablePtr pDraw)
{
	NVPortPrivPtr pPriv = (NVPortPrivPtr)data;
	NVPtr pNv = NVPTR(pScrn);
	PixmapPtr ppix;
	/* source box */
	INT32 xa = 0, xb = 0, ya = 0, yb = 0;
	/* size to allocate in VRAM and in GART respectively */
	int newFBSize = 0, newTTSize = 0;
	/* card VRAM offsets, source offsets for U and V planes */
	int offset = 0, uv_offset = 0, s2offset = 0, s3offset = 0;
	/* source pitch, source pitch of U and V planes in case of YV12,
	 * VRAM destination pitch
	 */
	int srcPitch = 0, srcPitch2 = 0, dstPitch = 0;
	/* position of the given source data (using src_*), number of pixels
	 * and lines we are interested in
	 */
	int top = 0, left = 0, right = 0, bottom = 0, npixels = 0, nlines = 0;
	Bool skip = FALSE;
	BoxRec dstBox;
	CARD32 tmp = 0;
	int line_len = 0; /* length of a line, like npixels, but in bytes */
	struct nouveau_bo *destination_buffer = NULL;
	int action_flags; /* what shall we do? */
	unsigned char *map;
	int ret, i;

	if (pPriv->grabbedByV4L)
		return Success;

	if (width > pPriv->max_image_dim || height > pPriv->max_image_dim)
		return BadMatch;

	NV_set_action_flags(pScrn, pDraw, pPriv, id, drw_x, drw_y, drw_w,
			    drw_h, &action_flags);

	if (NV_set_dimensions(pScrn, action_flags, &xa, &xb, &ya, &yb,
			      &src_x,  &src_y, &src_w, &src_h,
			      &drw_x, &drw_y, &drw_w, &drw_h,
			      &left, &top, &right, &bottom, &dstBox,
			      &npixels, &nlines, clipBoxes, width, height))
		return Success;

	if (NV_calculate_pitches_and_mem_size(pNv, action_flags, &srcPitch,
					      &srcPitch2, &dstPitch, &s2offset,
					      &s3offset, &uv_offset,
					      &newFBSize, &newTTSize,
					      &line_len, npixels, nlines,
					      width, height))
		return BadImplementation;

	/* There are some cases (tvtime with overscan for example) where the
	 * input image is larger (width/height) than the source rectangle for
	 * the overlay (src_w, src_h). In those cases, we try to do something
	 * optimal by uploading only the necessary data.
	 */
	if (action_flags & IS_YUY2 || action_flags & IS_RGB)
		buf += (top * srcPitch) + left;

	if (action_flags & IS_YV12) {
		tmp = ((top >> 1) * srcPitch2) + (left >> 1);
		s2offset += tmp;
		s3offset += tmp;
	}

	ret = nouveau_xv_bo_realloc(pScrn, NOUVEAU_BO_VRAM, newFBSize,
				    &pPriv->video_mem);
	if (ret)
		return BadAlloc;

#ifdef NVOVL_SUPPORT
	if (action_flags & USE_OVERLAY) {
		ret = nouveau_bo_pin(pPriv->video_mem, NOUVEAU_BO_VRAM);
		if (ret) {
			nouveau_bo_ref(NULL, &pPriv->video_mem);
			return BadAlloc;
		}
	}
#endif

	/* The overlay supports hardware double buffering. We handle this here*/
	offset = 0;
#ifdef NVOVL_SUPPORT
	if (pPriv->doubleBuffer) {
		int mask = 1 << (pPriv->currentBuffer << 2);

		/* overwrite the newest buffer if there's not one free */
		if (nvReadVIDEO(pNv, NV_PVIDEO_BUFFER) & mask) {
			if (!pPriv->currentBuffer)
				offset += newFBSize >> 1;
			skip = TRUE;
		} else {
			if (pPriv->currentBuffer)
				offset += newFBSize >> 1;
		}
	}
#endif

	/* Now we take a decision regarding the way we send the data to the
	 * card.
	 *
	 * Either we use double buffering of "private" TT memory
	 * Either we rely on X's GARTScratch
	 * Either we fallback on CPU copy
	 */

	/* Try to allocate host-side double buffers, unless we have already
	 * failed
	 */

	/* We take only nlines * line_len bytes - that is, only the pixel
	 * data we are interested in - because the stuff in the GART is
	 * written contiguously
	 */
	if (pPriv->currentHostBuffer != NO_PRIV_HOST_BUFFER_AVAILABLE) {
		ret = nouveau_xv_bo_realloc(pScrn, NOUVEAU_BO_GART, newTTSize,
					    &pPriv->TT_mem_chunk[0]);
		if (ret == 0) {
			ret = nouveau_xv_bo_realloc(pScrn, NOUVEAU_BO_GART,
						    newTTSize,
						    &pPriv->TT_mem_chunk[1]);
			if (ret) {
				nouveau_bo_ref(NULL, &pPriv->TT_mem_chunk[0]);
				pPriv->currentHostBuffer =
					NO_PRIV_HOST_BUFFER_AVAILABLE;
			}
		} else {
			pPriv->currentHostBuffer =
				NO_PRIV_HOST_BUFFER_AVAILABLE;
		}
	}

	if (pPriv->currentHostBuffer != NO_PRIV_HOST_BUFFER_AVAILABLE) {
		destination_buffer =
			pPriv->TT_mem_chunk[pPriv->currentHostBuffer];
	}
	if (!destination_buffer) {
		if (pNv->Architecture >= NV_TESLA) {
			NOUVEAU_ERR("No scratch buffer for tiled upload\n");
			return BadAlloc;
		}

		goto CPU_copy;
	}

	if (newTTSize <= destination_buffer->size) {
		unsigned char *dst;

		/* Upload to GART */
		nouveau_bo_map(destination_buffer, NOUVEAU_BO_WR, pNv->client);
		dst = destination_buffer->map;

		if (action_flags & IS_YV12) {
			if (action_flags & CONVERT_TO_YUY2) {
				NVCopyData420(buf + (top * srcPitch) + left,
					      buf + s2offset, buf + s3offset,
					      dst, srcPitch, srcPitch2,
					      line_len, nlines, npixels);
			} else {
				/* Native YV12 */
				unsigned char *tbuf = buf + top *
						      srcPitch + left;
				unsigned char *tdst = dst;

				/* luma upload */
				for (i = 0; i < nlines; i++) {
					memcpy(tdst, tbuf, line_len);
					tdst += line_len;
					tbuf += srcPitch;
				}
				dst += line_len * nlines;

				NVCopyNV12ColorPlanes(buf + s2offset,
						      buf + s3offset, dst,
						      line_len, srcPitch2,
						      nlines, npixels);
			}
		} else {
			for (i = 0; i < nlines; i++) {
				memcpy(dst, buf, line_len);
				dst += line_len;
				buf += srcPitch;
			}
		}

		if (uv_offset) {
			NVAccelM2MF(pNv, line_len, nlines / 2, 1,
				    line_len * nlines, uv_offset,
				    destination_buffer, NOUVEAU_BO_GART,
				    line_len, nlines >> 1, 0, 0,
				    pPriv->video_mem, NOUVEAU_BO_VRAM,
				    dstPitch, nlines >> 1, 0, 0);
		}

		NVAccelM2MF(pNv, line_len, nlines, 1, 0, 0,
			    destination_buffer, NOUVEAU_BO_GART,
			    line_len, nlines, 0, 0,
			    pPriv->video_mem, NOUVEAU_BO_VRAM,
			    dstPitch, nlines, 0, 0);

	} else {
CPU_copy:
		nouveau_bo_map(pPriv->video_mem, NOUVEAU_BO_WR, pNv->client);
		map = pPriv->video_mem->map + offset;

		if (action_flags & IS_YV12) {
			if (action_flags & CONVERT_TO_YUY2) {
				NVCopyData420(buf + (top * srcPitch) + left,
					      buf + s2offset, buf + s3offset,
					      map, srcPitch, srcPitch2,
					      dstPitch, nlines, npixels);
			} else {
				unsigned char *tbuf =
					buf + left + top * srcPitch;

				for (i = 0; i < nlines; i++) {
					int dwords = npixels << 1;

					while (dwords & ~0x03) {
						*map = *tbuf;
						*(map + 1) = *(tbuf + 1);
						*(map + 2) = *(tbuf + 2);
						*(map + 3) = *(tbuf + 3);
						map += 4;
						tbuf += 4;
						dwords -= 4;
					}

					switch (dwords) {
					case 3: *(map + 2) = *(tbuf + 2);
					case 2: *(map + 1) = *(tbuf + 1);
					case 1: *map = *tbuf;
					}

					map += dstPitch - (npixels << 1);
					tbuf += srcPitch - (npixels << 1);
				}

				NVCopyNV12ColorPlanes(buf + s2offset,
						      buf + s3offset,
						      map, dstPitch, srcPitch2,
						      nlines, npixels);
			}
		} else {
			/* YUY2 and RGB */
			for (i = 0; i < nlines; i++) {
				int dwords = npixels << 1;

				while (dwords & ~0x03) {
					*map = *buf;
					*(map + 1) = *(buf + 1);
					*(map + 2) = *(buf + 2);
					*(map + 3) = *(buf + 3);
					map += 4;
					buf += 4;
					dwords -= 4;
				}

				switch (dwords) {
				case 3: *(map + 2) = *(buf + 2);
				case 2: *(map + 1) = *(buf + 1);
				case 1: *map = *buf;
				}

				map += dstPitch - (npixels << 1);
				buf += srcPitch - (npixels << 1);
			}
		}
	}

	if (skip)
		return Success;

	if (pPriv->currentHostBuffer != NO_PRIV_HOST_BUFFER_AVAILABLE)
		pPriv->currentHostBuffer ^= 1;

	/* If we're not using the hw overlay, we're rendering into a pixmap
	 * and need to take a couple of additional steps...
	 */
	if (!(action_flags & USE_OVERLAY)) {
		ppix = NVGetDrawablePixmap(pDraw);

		/* Ensure pixmap is in offscreen memory */
		pNv->exa_force_cp = TRUE;
		exaMoveInPixmap(ppix);
		pNv->exa_force_cp = FALSE;

		if (!exaGetPixmapDriverPrivate(ppix))
			return BadAlloc;

#ifdef COMPOSITE
		/* Convert screen coords to pixmap coords */
		if (ppix->screen_x || ppix->screen_y) {
			REGION_TRANSLATE(pScrn->pScreen, clipBoxes,
					 -ppix->screen_x, -ppix->screen_y);
			dstBox.x1 -= ppix->screen_x;
			dstBox.x2 -= ppix->screen_x;
			dstBox.y1 -= ppix->screen_y;
			dstBox.y2 -= ppix->screen_y;
		}
#endif
	}

	if (action_flags & USE_OVERLAY) {
		if (pNv->Architecture == NV_ARCH_04) {
			NV04PutOverlayImage(pScrn, pPriv->video_mem, offset,
					    id, dstPitch, &dstBox, 0, 0,
					    xb, yb, npixels, nlines,
					    src_w, src_h, drw_w, drw_h,
					    clipBoxes);
		} else {
			NV10PutOverlayImage(pScrn, pPriv->video_mem, offset,
					    uv_offset, id, dstPitch, &dstBox,
					    0, 0, xb, yb,
					    npixels, nlines, src_w, src_h,
					    drw_w, drw_h, clipBoxes);
		}

		pPriv->currentBuffer ^= 1;
	} else 
	if (action_flags & USE_TEXTURE) {
		ret = BadImplementation;

		if (pNv->Architecture == NV_ARCH_30) {
			ret = NV30PutTextureImage(pScrn, pPriv->video_mem,
						  offset, uv_offset,
						  id, dstPitch, &dstBox, 0, 0,
						  xb, yb, npixels, nlines,
						  src_w, src_h, drw_w, drw_h,
						  clipBoxes, ppix, pPriv);
		} else
		if (pNv->Architecture == NV_ARCH_40) {
			ret = NV40PutTextureImage(pScrn, pPriv->video_mem, 
						  offset, uv_offset,
						  id, dstPitch, &dstBox, 0, 0,
						  xb, yb, npixels, nlines,
						  src_w, src_h, drw_w, drw_h,
						  clipBoxes, ppix, pPriv);
		} else
		if (pNv->Architecture == NV_TESLA) {
			ret = nv50_xv_image_put(pScrn, pPriv->video_mem,
						offset, uv_offset,
						id, dstPitch, &dstBox, 0, 0,
						xb, yb, npixels, nlines,
						src_w, src_h, drw_w, drw_h,
						clipBoxes, ppix, pPriv);
		} else {
			ret = nvc0_xv_image_put(pScrn, pPriv->video_mem,
						offset, uv_offset,
						id, dstPitch, &dstBox, 0, 0,
						xb, yb, npixels, nlines,
						src_w, src_h, drw_w, drw_h,
						clipBoxes, ppix, pPriv);
		}

		if (ret != Success)
			return ret;
	} else {
		ret = NVPutBlitImage(pScrn, pPriv->video_mem, offset, id,
				     dstPitch, &dstBox, 0, 0, xb, yb, npixels,
				     nlines, src_w, src_h, drw_w, drw_h,
				     clipBoxes, ppix);
		if (ret != Success)
			return ret;
	}

#ifdef COMPOSITE
	/* Damage tracking */
	if (!(action_flags & USE_OVERLAY))
		DamageDamageRegion(&ppix->drawable, clipBoxes);
#endif

	return Success;
}

/**
 * QueryImageAttributes
 *
 * calculates
 * - size (memory required to store image),
 * - pitches,
 * - offsets
 * of image
 * depending on colorspace (id) and dimensions (w,h) of image
 * values of
 * - w,
 * - h
 * may be adjusted as needed
 *
 * @param pScrn unused
 * @param id colorspace of image
 * @param w pointer to width of image
 * @param h pointer to height of image
 * @param pitches pitches[i] = length of a scanline in plane[i]
 * @param offsets offsets[i] = offset of plane i from the beginning of the image
 * @return size of the memory required for the XvImage queried
 */
static int
NVQueryImageAttributes(ScrnInfoPtr pScrn, int id,
		       unsigned short *w, unsigned short *h,
		       int *pitches, int *offsets)
{
	int size, tmp;

	*w = (*w + 1) & ~1; // width rounded up to an even number
	if (offsets)
		offsets[0] = 0;

	switch (id) {
	case FOURCC_YV12:
	case FOURCC_I420:
		*h = (*h + 1) & ~1; // height rounded up to an even number
		size = (*w + 3) & ~3; // width rounded up to a multiple of 4
		if (pitches)
			pitches[0] = size; // width rounded up to a multiple of 4
		size *= *h;
		if (offsets)
			offsets[1] = size; // number of pixels in "rounded up" image
		tmp = ((*w >> 1) + 3) & ~3; // width/2 rounded up to a multiple of 4
		if (pitches)
			pitches[1] = pitches[2] = tmp; // width/2 rounded up to a multiple of 4
		tmp *= (*h >> 1); // 1/4*number of pixels in "rounded up" image
		size += tmp; // 5/4*number of pixels in "rounded up" image
		if (offsets)
			offsets[2] = size; // 5/4*number of pixels in "rounded up" image
		size += tmp; // = 3/2*number of pixels in "rounded up" image
		break;
	case FOURCC_UYVY:
	case FOURCC_YUY2:
		size = *w << 1; // 2*width
		if (pitches)
			pitches[0] = size; // 2*width
		size *= *h; // 2*width*height
		break;
	case FOURCC_RGB:
		size = *w << 2; // 4*width (32 bit per pixel)
		if (pitches)
			pitches[0] = size; // 4*width
		size *= *h; // 4*width*height
		break;
	case FOURCC_AI44:
	case FOURCC_IA44:
		size = *w; // width
		if (pitches)
			pitches[0] = size; // width
		size *= *h; // width*height
		break;
	default:
		xf86DrvMsg(pScrn->scrnIndex, X_WARNING, "Unknown colorspace: %x\n", id);
		*w = *h = size = 0;
		break;
	}

	return size;
}

/***** Exported offscreen surface stuff ****/


static int
NVAllocSurface(ScrnInfoPtr pScrn, int id,
	       unsigned short w, unsigned short h,
	       XF86SurfacePtr surface)
{
	NVPtr pNv = NVPTR(pScrn);
	NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);
	int size, bpp, ret;

	bpp = pScrn->bitsPerPixel >> 3;

	if (pPriv->grabbedByV4L)
		return BadAlloc;

	if ((w > IMAGE_MAX_W) || (h > IMAGE_MAX_H))
		return BadValue;

	w = (w + 1) & ~1;
	pPriv->pitch = ((w << 1) + 63) & ~63;
	size = h * pPriv->pitch / bpp;

	ret = nouveau_xv_bo_realloc(pScrn, NOUVEAU_BO_VRAM, size,
				    &pPriv->video_mem);
	if (ret)
		return BadAlloc;
	pPriv->offset = 0;

	surface->width = w;
	surface->height = h;
	surface->pScrn = pScrn;
	surface->pitches = &pPriv->pitch;
	surface->offsets = &pPriv->offset;
	surface->devPrivate.ptr = (void*)pPriv;
	surface->id = id;

	/* grab the video */
	NVStopOverlay(pScrn);
	pPriv->videoStatus = 0;
	REGION_EMPTY(pScrn->pScreen, &pPriv->clip);
	pPriv->grabbedByV4L = TRUE;

	return Success;
}

static int
NVStopSurface(XF86SurfacePtr surface)
{
	NVPortPrivPtr pPriv = (NVPortPrivPtr)(surface->devPrivate.ptr);

	if (pPriv->grabbedByV4L && pPriv->videoStatus) {
		NV10StopOverlay(surface->pScrn);
		pPriv->videoStatus = 0;
	}

	return Success;
}

static int
NVFreeSurface(XF86SurfacePtr surface)
{
	NVPortPrivPtr pPriv = (NVPortPrivPtr)(surface->devPrivate.ptr);

	if (pPriv->grabbedByV4L) {
		NVStopSurface(surface);
		NVFreeOverlayMemory(surface->pScrn);
		pPriv->grabbedByV4L = FALSE;
	}

	return Success;
}

static int
NVGetSurfaceAttribute(ScrnInfoPtr pScrn, Atom attribute, INT32 *value)
{
	NVPtr pNv = NVPTR(pScrn);
	NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);

	return NV10GetOverlayPortAttribute(pScrn, attribute,
					 value, (void*)pPriv);
}

static int
NVSetSurfaceAttribute(ScrnInfoPtr pScrn, Atom attribute, INT32 value)
{
	NVPtr pNv = NVPTR(pScrn);
	NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);

	return NV10SetOverlayPortAttribute(pScrn, attribute,
					 value, (void*)pPriv);
}

static int
NVDisplaySurface(XF86SurfacePtr surface,
		 short src_x, short src_y,
		 short drw_x, short drw_y,
		 short src_w, short src_h,
		 short drw_w, short drw_h,
		 RegionPtr clipBoxes)
{
	ScrnInfoPtr pScrn = surface->pScrn;
	NVPortPrivPtr pPriv = (NVPortPrivPtr)(surface->devPrivate.ptr);
	INT32 xa, xb, ya, yb;
	BoxRec dstBox;

	if (!pPriv->grabbedByV4L)
		return Success;

	if (src_w > (drw_w << 3))
		drw_w = src_w >> 3;
	if (src_h > (drw_h << 3))
		drw_h = src_h >> 3;

	/* Clip */
	xa = src_x;
	xb = src_x + src_w;
	ya = src_y;
	yb = 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, &xa, &xb, &ya, &yb, clipBoxes,
				  surface->width, surface->height))
		return Success;

	dstBox.x1 -= pScrn->frameX0;
	dstBox.x2 -= pScrn->frameX0;
	dstBox.y1 -= pScrn->frameY0;
	dstBox.y2 -= pScrn->frameY0;

	pPriv->currentBuffer = 0;

	NV10PutOverlayImage(pScrn, pPriv->video_mem, surface->offsets[0],
			    0, surface->id, surface->pitches[0], &dstBox,
			    xa, ya, xb, yb, surface->width, surface->height,
			    src_w, src_h, drw_w, drw_h, clipBoxes);

	return Success;
}

/**
 * NVSetupBlitVideo
 * this function does all the work setting up a blit port
 *
 * @return blit port
 */
static XF86VideoAdaptorPtr
NVSetupBlitVideo (ScreenPtr pScreen)
{
	ScrnInfoPtr         pScrn = xf86ScreenToScrn(pScreen);
	NVPtr               pNv       = NVPTR(pScrn);
	XF86VideoAdaptorPtr adapt;
	NVPortPrivPtr       pPriv;
	int i;

	if (!(adapt = calloc(1, sizeof(XF86VideoAdaptorRec) +
					sizeof(NVPortPrivRec) +
					(sizeof(DevUnion) * NUM_BLIT_PORTS)))) {
		return NULL;
	}

	adapt->type		= XvWindowMask | XvInputMask | XvImageMask;
	adapt->flags		= 0;
	adapt->name		= "NV Video Blitter";
	adapt->nEncodings	= 1;
	adapt->pEncodings	= &DummyEncoding;
	adapt->nFormats		= NUM_FORMATS_ALL;
	adapt->pFormats		= NVFormats;
	adapt->nPorts		= NUM_BLIT_PORTS;
	adapt->pPortPrivates	= (DevUnion*)(&adapt[1]);

	pPriv = (NVPortPrivPtr)(&adapt->pPortPrivates[NUM_BLIT_PORTS]);
	for(i = 0; i < NUM_BLIT_PORTS; i++)
		adapt->pPortPrivates[i].ptr = (void*)(pPriv);

	if (pNv->dev->chipset >= 0x11) {
		adapt->pAttributes = NVBlitAttributes;
		adapt->nAttributes = NUM_BLIT_ATTRIBUTES;
	} else {
		adapt->pAttributes = NULL;
		adapt->nAttributes = 0;
	}

	adapt->pImages			= NVImages;
	adapt->nImages			= NUM_IMAGES_ALL;
	adapt->PutVideo			= NULL;
	adapt->PutStill			= NULL;
	adapt->GetVideo			= NULL;
	adapt->GetStill			= NULL;
	adapt->StopVideo		= NVStopBlitVideo;
	adapt->SetPortAttribute		= NVSetBlitPortAttribute;
	adapt->GetPortAttribute		= NVGetBlitPortAttribute;
	adapt->QueryBestSize		= NVQueryBestSize;
	adapt->PutImage			= NVPutImage;
	adapt->QueryImageAttributes	= NVQueryImageAttributes;

	pPriv->videoStatus		= 0;
	pPriv->grabbedByV4L		= FALSE;
	pPriv->blitter			= TRUE;
	pPriv->texture			= FALSE;
	pPriv->bicubic			= FALSE;
	pPriv->doubleBuffer		= FALSE;
	pPriv->SyncToVBlank		= (pNv->dev->chipset >= 0x11);
	pPriv->max_image_dim            = 2048;

	pNv->blitAdaptor		= adapt;

	return adapt;
}

/**
 * NVSetupOverlayVideo
 * this function does all the work setting up an overlay port
 *
 * @return overlay port
 */
static XF86VideoAdaptorPtr
NVSetupOverlayVideoAdapter(ScreenPtr pScreen)
{
	ScrnInfoPtr         pScrn = xf86ScreenToScrn(pScreen);
	NVPtr               pNv       = NVPTR(pScrn);
	XF86VideoAdaptorPtr adapt;
	NVPortPrivPtr       pPriv;

	if (!(adapt = calloc(1, sizeof(XF86VideoAdaptorRec) +
					sizeof(NVPortPrivRec) +
					sizeof(DevUnion)))) {
		return NULL;
	}

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

	pPriv = (NVPortPrivPtr)(&adapt->pPortPrivates[1]);
	adapt->pPortPrivates[0].ptr	= (void*)(pPriv);

	adapt->pAttributes		= (pNv->Architecture != NV_ARCH_04) ? NV10OverlayAttributes : NV04OverlayAttributes;
	adapt->nAttributes		= (pNv->Architecture != NV_ARCH_04) ? NUM_NV10_OVERLAY_ATTRIBUTES : NUM_NV04_OVERLAY_ATTRIBUTES;
	adapt->pImages			= NVImages;
	adapt->nImages			= NUM_IMAGES_YUV;
	adapt->PutVideo			= NULL;
	adapt->PutStill			= NULL;
	adapt->GetVideo			= NULL;
	adapt->GetStill			= NULL;
	adapt->StopVideo		= NVStopOverlayVideo;
	adapt->SetPortAttribute		= (pNv->Architecture != NV_ARCH_04) ? NV10SetOverlayPortAttribute : NV04SetOverlayPortAttribute;
	adapt->GetPortAttribute		= (pNv->Architecture != NV_ARCH_04) ? NV10GetOverlayPortAttribute : NV04GetOverlayPortAttribute;
	adapt->QueryBestSize		= NVQueryBestSize;
	adapt->PutImage			= NVPutImage;
	adapt->QueryImageAttributes	= NVQueryImageAttributes;

	pPriv->videoStatus		= 0;
	pPriv->currentBuffer		= 0;
	pPriv->grabbedByV4L		= FALSE;
	pPriv->blitter			= FALSE;
	pPriv->texture			= FALSE;
	pPriv->bicubic			= FALSE;
	pPriv->max_image_dim            = 2048;

	NVSetPortDefaults (pScrn, pPriv);

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

	pNv->overlayAdaptor	= adapt;

	xvBrightness		= MAKE_ATOM("XV_BRIGHTNESS");
	xvColorKey		= MAKE_ATOM("XV_COLORKEY");
	xvAutopaintColorKey     = MAKE_ATOM("XV_AUTOPAINT_COLORKEY");
	xvSetDefaults           = MAKE_ATOM("XV_SET_DEFAULTS");

	if ( pNv->Architecture != NV_ARCH_04 )
		{
		xvDoubleBuffer		= MAKE_ATOM("XV_DOUBLE_BUFFER");
		xvContrast		= MAKE_ATOM("XV_CONTRAST");
		xvSaturation		= MAKE_ATOM("XV_SATURATION");
		xvHue			= MAKE_ATOM("XV_HUE");
		xvITURBT709		= MAKE_ATOM("XV_ITURBT_709");
		xvOnCRTCNb		= MAKE_ATOM("XV_ON_CRTC_NB");
		NV10WriteOverlayParameters(pScrn);
		}

	return adapt;
}


XF86OffscreenImageRec NVOffscreenImages[2] = {
	{
		&NVImages[0],
		VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT,
		NVAllocSurface,
		NVFreeSurface,
		NVDisplaySurface,
		NVStopSurface,
		NVGetSurfaceAttribute,
		NVSetSurfaceAttribute,
		IMAGE_MAX_W, IMAGE_MAX_H,
		NUM_NV10_OVERLAY_ATTRIBUTES - 1,
		&NV10OverlayAttributes[1]
	},
	{
		&NVImages[2],
		VIDEO_OVERLAID_IMAGES | VIDEO_CLIP_TO_VIEWPORT,
		NVAllocSurface,
		NVFreeSurface,
		NVDisplaySurface,
		NVStopSurface,
		NVGetSurfaceAttribute,
		NVSetSurfaceAttribute,
		IMAGE_MAX_W, IMAGE_MAX_H,
		NUM_NV10_OVERLAY_ATTRIBUTES - 1,
		&NV10OverlayAttributes[1]
	}
};

static void
NVInitOffscreenImages (ScreenPtr pScreen)
{
	xf86XVRegisterOffscreenImages(pScreen, NVOffscreenImages, 2);
}

/**
 * NVChipsetHasOverlay
 *
 * newer chips don't support overlay anymore.
 * overlay feature is emulated via textures.
 *
 * @param pNv
 * @return true, if chipset supports overlay
 */
static Bool
NVChipsetHasOverlay(NVPtr pNv)
{
	switch (pNv->Architecture) {
	case NV_ARCH_04: /*NV04 has a different overlay than NV10+*/
	case NV_ARCH_10:
	case NV_ARCH_20:
	case NV_ARCH_30:
		return TRUE;
	case NV_ARCH_40:
		if (pNv->dev->chipset == 0x40)
			return TRUE;
		break;
	default:
		break;
	}

	return FALSE;
}

/**
 * NVSetupOverlayVideo
 * check if chipset supports Overla
 * if so, setup overlay port
 *
 * @return overlay port
 * @see NVChipsetHasOverlay(NVPtr pNv)
 * @see NV10SetupOverlayVideo(ScreenPtr pScreen)
 * @see NVInitOffscreenImages(ScreenPtr pScreen)
 */
static XF86VideoAdaptorPtr
NVSetupOverlayVideo(ScreenPtr pScreen)
{
	ScrnInfoPtr          pScrn = xf86ScreenToScrn(pScreen);
	XF86VideoAdaptorPtr  overlayAdaptor = NULL;
	NVPtr                pNv   = NVPTR(pScrn);

	if (1 /*pNv->kms_enable*/ || !NVChipsetHasOverlay(pNv))
		return NULL;

	overlayAdaptor = NVSetupOverlayVideoAdapter(pScreen);
	/* I am not sure what this call does. */
	if (overlayAdaptor && pNv->Architecture != NV_ARCH_04 )
		NVInitOffscreenImages(pScreen);

	#ifdef COMPOSITE
	if (!noCompositeExtension) {
		xf86DrvMsg(pScrn->scrnIndex, X_INFO,
			   "Xv: Composite is enabled, enabling overlay with "
			   "smart blitter fallback\n");
		overlayAdaptor->name = "NV Video Overlay with Composite";
	}
	#endif

	return overlayAdaptor;
}

/**
 * NV30 texture adapter.
 */

#define NUM_FORMAT_TEXTURED 2

static XF86ImageRec NV30TexturedImages[NUM_FORMAT_TEXTURED] =
{
	XVIMAGE_YV12,
	XVIMAGE_I420,
};

/**
 * NV30SetupTexturedVideo
 * this function does all the work setting up textured video port
 *
 * @return texture port
 */
static XF86VideoAdaptorPtr
NV30SetupTexturedVideo (ScreenPtr pScreen, Bool bicubic)
{
	ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
	NVPtr pNv = NVPTR(pScrn);
	XF86VideoAdaptorPtr adapt;
	NVPortPrivPtr pPriv;
	int i;

	if (!(adapt = calloc(1, sizeof(XF86VideoAdaptorRec) +
				 sizeof(NVPortPrivRec) +
				 (sizeof(DevUnion) * NUM_TEXTURE_PORTS)))) {
		return NULL;
	}

	adapt->type		= XvWindowMask | XvInputMask | XvImageMask;
	adapt->flags		= 0;
	if (bicubic)
		adapt->name		= "NV30 high quality adapter";
	else
		adapt->name		= "NV30 texture adapter";
	adapt->nEncodings	= 1;
	adapt->pEncodings	= &DummyEncodingTex;
	adapt->nFormats		= NUM_FORMATS_ALL;
	adapt->pFormats		= NVFormats;
	adapt->nPorts		= NUM_TEXTURE_PORTS;
	adapt->pPortPrivates	= (DevUnion*)(&adapt[1]);

	pPriv = (NVPortPrivPtr)(&adapt->pPortPrivates[NUM_TEXTURE_PORTS]);
	for(i = 0; i < NUM_TEXTURE_PORTS; i++)
		adapt->pPortPrivates[i].ptr = (void*)(pPriv);

	adapt->pAttributes		= NVTexturedAttributes;
	adapt->nAttributes		= NUM_TEXTURED_ATTRIBUTES;
	adapt->pImages			= NV30TexturedImages;
	adapt->nImages			= NUM_FORMAT_TEXTURED;
	adapt->PutVideo			= NULL;
	adapt->PutStill			= NULL;
	adapt->GetVideo			= NULL;
	adapt->GetStill			= NULL;
	adapt->StopVideo		= NV30StopTexturedVideo;
	adapt->SetPortAttribute		= NV30SetTexturePortAttribute;
	adapt->GetPortAttribute		= NV30GetTexturePortAttribute;
	adapt->QueryBestSize		= NVQueryBestSize;
	adapt->PutImage			= NVPutImage;
	adapt->QueryImageAttributes	= NVQueryImageAttributes;

	pPriv->videoStatus		= 0;
	pPriv->grabbedByV4L		= FALSE;
	pPriv->blitter			= FALSE;
	pPriv->texture			= TRUE;
	pPriv->bicubic			= bicubic;
	pPriv->doubleBuffer		= FALSE;
	pPriv->SyncToVBlank		= TRUE;
	pPriv->max_image_dim            = 4096;

	if (bicubic)
		pNv->textureAdaptor[1]	= adapt;
	else
		pNv->textureAdaptor[0]	= adapt;

	return adapt;
}

/**
 * NV40 texture adapter.
 */

#define NUM_FORMAT_TEXTURED 2

static XF86ImageRec NV40TexturedImages[NUM_FORMAT_TEXTURED] =
{
	XVIMAGE_YV12,
	XVIMAGE_I420,
};

/**
 * NV40SetupTexturedVideo
 * this function does all the work setting up textured video port
 *
 * @return texture port
 */
static XF86VideoAdaptorPtr
NV40SetupTexturedVideo (ScreenPtr pScreen, Bool bicubic)
{
	ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
	NVPtr pNv = NVPTR(pScrn);
	XF86VideoAdaptorPtr adapt;
	NVPortPrivPtr pPriv;
	int i;

	if (!(adapt = calloc(1, sizeof(XF86VideoAdaptorRec) +
				 sizeof(NVPortPrivRec) +
				 (sizeof(DevUnion) * NUM_TEXTURE_PORTS)))) {
		return NULL;
	}

	adapt->type		= XvWindowMask | XvInputMask | XvImageMask;
	adapt->flags		= 0;
	if (bicubic)
		adapt->name		= "NV40 high quality adapter";
	else
		adapt->name		= "NV40 texture adapter";
	adapt->nEncodings	= 1;
	adapt->pEncodings	= &DummyEncodingTex;
	adapt->nFormats		= NUM_FORMATS_ALL;
	adapt->pFormats		= NVFormats;
	adapt->nPorts		= NUM_TEXTURE_PORTS;
	adapt->pPortPrivates	= (DevUnion*)(&adapt[1]);

	pPriv = (NVPortPrivPtr)(&adapt->pPortPrivates[NUM_TEXTURE_PORTS]);
	for(i = 0; i < NUM_TEXTURE_PORTS; i++)
		adapt->pPortPrivates[i].ptr = (void*)(pPriv);

	adapt->pAttributes		= NVTexturedAttributes;
	adapt->nAttributes		= NUM_TEXTURED_ATTRIBUTES;
	adapt->pImages			= NV40TexturedImages;
	adapt->nImages			= NUM_FORMAT_TEXTURED;
	adapt->PutVideo			= NULL;
	adapt->PutStill			= NULL;
	adapt->GetVideo			= NULL;
	adapt->GetStill			= NULL;
	adapt->StopVideo		= NV40StopTexturedVideo;
	adapt->SetPortAttribute		= NV40SetTexturePortAttribute;
	adapt->GetPortAttribute		= NV40GetTexturePortAttribute;
	adapt->QueryBestSize		= NVQueryBestSize;
	adapt->PutImage			= NVPutImage;
	adapt->QueryImageAttributes	= NVQueryImageAttributes;

	pPriv->videoStatus		= 0;
	pPriv->grabbedByV4L		= FALSE;
	pPriv->blitter			= FALSE;
	pPriv->texture			= TRUE;
	pPriv->bicubic			= bicubic;
	pPriv->doubleBuffer		= FALSE;
	pPriv->SyncToVBlank		= TRUE;
	pPriv->max_image_dim            = 4096;

	if (bicubic)
		pNv->textureAdaptor[1]	= adapt;
	else
		pNv->textureAdaptor[0]	= adapt;

	return adapt;
}

static XF86ImageRec
NV50TexturedImages[] =
{
	XVIMAGE_YV12,
	XVIMAGE_I420,
	XVIMAGE_YUY2,
	XVIMAGE_UYVY
};

static XF86VideoAdaptorPtr
NV50SetupTexturedVideo (ScreenPtr pScreen)
{
	ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
	NVPtr pNv = NVPTR(pScrn);
	XF86VideoAdaptorPtr adapt;
	NVPortPrivPtr pPriv;
	int i;

	if (!(adapt = calloc(1, sizeof(XF86VideoAdaptorRec) +
				 sizeof(NVPortPrivRec) +
				 (sizeof(DevUnion) * NUM_TEXTURE_PORTS)))) {
		return NULL;
	}

	adapt->type		= XvWindowMask | XvInputMask | XvImageMask;
	adapt->flags		= 0;
	adapt->name		= "Nouveau GeForce 8/9 Textured Video";
	adapt->nEncodings	= 1;
	adapt->pEncodings	= &DummyEncodingNV50;
	adapt->nFormats		= NUM_FORMATS_NV50;
	adapt->pFormats		= NV50Formats;
	adapt->nPorts		= NUM_TEXTURE_PORTS;
	adapt->pPortPrivates	= (DevUnion*)(&adapt[1]);

	pPriv = (NVPortPrivPtr)(&adapt->pPortPrivates[NUM_TEXTURE_PORTS]);
	for(i = 0; i < NUM_TEXTURE_PORTS; i++)
		adapt->pPortPrivates[i].ptr = (void*)(pPriv);

	adapt->pAttributes		= NVTexturedAttributesNV50;
	adapt->nAttributes		= NUM_TEXTURED_ATTRIBUTES_NV50;
	adapt->pImages			= NV50TexturedImages;
	adapt->nImages			= sizeof(NV50TexturedImages) /
					  sizeof(NV50TexturedImages[0]);
	adapt->PutVideo			= NULL;
	adapt->PutStill			= NULL;
	adapt->GetVideo			= NULL;
	adapt->GetStill			= NULL;
	adapt->StopVideo		= nv50_xv_video_stop;
	adapt->SetPortAttribute		= nv50_xv_port_attribute_set;
	adapt->GetPortAttribute		= nv50_xv_port_attribute_get;
	adapt->QueryBestSize		= NVQueryBestSize;
	adapt->PutImage			= NVPutImage;
	adapt->QueryImageAttributes	= NVQueryImageAttributes;

	pNv->textureAdaptor[0]		= adapt;

	nv50_xv_set_port_defaults(pScrn, pPriv);
	nv50_xv_csc_update(pScrn, pPriv);

	xvBrightness = MAKE_ATOM("XV_BRIGHTNESS");
	xvContrast   = MAKE_ATOM("XV_CONTRAST");
	xvSaturation = MAKE_ATOM("XV_SATURATION");
	xvHue        = MAKE_ATOM("XV_HUE");
	xvITURBT709  = MAKE_ATOM("XV_ITURBT_709");
	return adapt;
}

static void
NVSetupTexturedVideo (ScreenPtr pScreen, XF86VideoAdaptorPtr *textureAdaptor)
{
	ScrnInfoPtr          pScrn = xf86ScreenToScrn(pScreen);
	NVPtr                pNv = NVPTR(pScrn);

	if (!pNv->Nv3D)
		return;

	if (pNv->Architecture == NV_ARCH_30) {
		textureAdaptor[0] = NV30SetupTexturedVideo(pScreen, FALSE);
		textureAdaptor[1] = NV30SetupTexturedVideo(pScreen, TRUE);
	} else
	if (pNv->Architecture == NV_ARCH_40) {
		textureAdaptor[0] = NV40SetupTexturedVideo(pScreen, FALSE);
		textureAdaptor[1] = NV40SetupTexturedVideo(pScreen, TRUE);
	} else
	if (pNv->Architecture >= NV_TESLA) {
		textureAdaptor[0] = NV50SetupTexturedVideo(pScreen);
	}
}

/**
 * NVInitVideo
 * tries to initialize the various supported adapters
 * and add them to the list of ports on screen "pScreen".
 *
 * @param pScreen
 * @see NVSetupOverlayVideo(ScreenPtr pScreen)
 * @see NVSetupBlitVideo(ScreenPtr pScreen)
 */
void
NVInitVideo(ScreenPtr pScreen)
{
	ScrnInfoPtr          pScrn = xf86ScreenToScrn(pScreen);
	NVPtr                pNv = NVPTR(pScrn);
	XF86VideoAdaptorPtr *adaptors, *newAdaptors = NULL;
	XF86VideoAdaptorPtr  overlayAdaptor = NULL;
	XF86VideoAdaptorPtr  blitAdaptor = NULL;
	XF86VideoAdaptorPtr  textureAdaptor[2] = {NULL, NULL};
	int                  num_adaptors;

	/*
	 * Driving the blitter requires the DMA FIFO. Using the FIFO
	 * without accel causes DMA errors. While the overlay might
	 * might work without accel, we also disable it for now when
	 * acceleration is disabled:
	 */
	if (pScrn->bitsPerPixel != 8 && pNv->AccelMethod == EXA) {
		xvSyncToVBlank = MAKE_ATOM("XV_SYNC_TO_VBLANK");

		if (pNv->Architecture < NV_TESLA) {
			overlayAdaptor = NVSetupOverlayVideo(pScreen);
			blitAdaptor    = NVSetupBlitVideo(pScreen);
		}

		NVSetupTexturedVideo(pScreen, textureAdaptor);
	}

	num_adaptors = xf86XVListGenericAdaptors(pScrn, &adaptors);
	if (blitAdaptor || overlayAdaptor || textureAdaptor[0]) {
		int size = num_adaptors;

		if(overlayAdaptor) size++;
		if(blitAdaptor)    size++;
		if(textureAdaptor[0]) size++;
		if(textureAdaptor[1]) size++;

		newAdaptors = malloc(size * sizeof(XF86VideoAdaptorPtr *));
		if(newAdaptors) {
			if(num_adaptors) {
				memcpy(newAdaptors, adaptors, num_adaptors *
						sizeof(XF86VideoAdaptorPtr));
			}

			if(overlayAdaptor) {
				newAdaptors[num_adaptors] = overlayAdaptor;
				num_adaptors++;
			}

			if (textureAdaptor[0]) { /* bilinear */
				newAdaptors[num_adaptors] = textureAdaptor[0];
				num_adaptors++;
			}

			if (textureAdaptor[1]) { /* bicubic */
				newAdaptors[num_adaptors] = textureAdaptor[1];
				num_adaptors++;
			}

			if(blitAdaptor) {
				newAdaptors[num_adaptors] = blitAdaptor;
				num_adaptors++;
			}

			adaptors = newAdaptors;
		}
	}

	if (num_adaptors)
		xf86XVScreenInit(pScreen, adaptors, num_adaptors);
	if (newAdaptors)
		free(newAdaptors);
	
	/*
	 * For now we associate with the plain texture adapter since it is logical, but we can
	 * associate with any/all adapters since VL doesn't depend on Xv for color conversion.
	 */
	if (textureAdaptor[0]) {
		XF86MCAdaptorPtr *adaptorsXvMC = malloc(sizeof(XF86MCAdaptorPtr));
		
		if (adaptorsXvMC) {
			adaptorsXvMC[0] = vlCreateAdaptorXvMC(pScreen, (char *)textureAdaptor[0]->name);
			
			if (adaptorsXvMC[0]) {
				vlInitXvMC(pScreen, 1, adaptorsXvMC);
				vlDestroyAdaptorXvMC(adaptorsXvMC[0]);
			}
			
			free(adaptorsXvMC);
		}
	}
}

void
NVTakedownVideo(ScrnInfoPtr pScrn)
{
	NVPtr pNv = NVPTR(pScrn);

	if (pNv->blitAdaptor)
		NVFreePortMemory(pScrn, GET_BLIT_PRIVATE(pNv));
	if (pNv->textureAdaptor[0]) {
		NVFreePortMemory(pScrn,
				 pNv->textureAdaptor[0]->pPortPrivates[0].ptr);
	}
	if (pNv->textureAdaptor[1]) {
		NVFreePortMemory(pScrn,
				 pNv->textureAdaptor[1]->pPortPrivates[0].ptr);
	}
}

/* The filtering function used for video scaling. We use a cubic filter as
 * defined in  "Reconstruction Filters in Computer Graphics" Mitchell &
 * Netravali in SIGGRAPH '88
 */
static float filter_func(float x)
{
	const double B=0.75;
	const double C=(1.0-B)/2.0;
	double x1=fabs(x);
	double x2=fabs(x)*x1;
	double x3=fabs(x)*x2;

	if (fabs(x)<1.0)
		return ( (12.0-9.0*B-6.0*C)*x3+(-18.0+12.0*B+6.0*C)*x2+(6.0-2.0*B) )/6.0; 
	else
		return ( (-B-6.0*C)*x3+(6.0*B+30.0*C)*x2+(-12.0*B-48.0*C)*x1+(8.0*B+24.0*C) )/6.0;
}

static int8_t f32tosb8(float v)
{
	return (int8_t)(v*127.0);
}

void
NVXVComputeBicubicFilter(struct nouveau_bo *bo, unsigned offset, unsigned size)
{
	int8_t *t = (int8_t *)(bo->map + offset);
	int i;

	for(i = 0; i < size; i++) {
		float  x = (i + 0.5) / size;
		float w0 = filter_func(x+1.0);
		float w1 = filter_func(x);
		float w2 = filter_func(x-1.0);
		float w3 = filter_func(x-2.0);

		t[4*i+2]=f32tosb8(1.0+x-w1/(w0+w1));
		t[4*i+1]=f32tosb8(1.0-x+w3/(w2+w3));
		t[4*i+0]=f32tosb8(w0+w1);
		t[4*i+3]=f32tosb8(0.0);
	}
}
