/*
 * Copyright 2004-2005 The Unichrome Project  [unichrome.sf.net]
 * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
 * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sub license,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86fbman.h"

#include "via.h"
#ifdef XF86DRI
#include "xf86drm.h"
#endif

#include "via_driver.h"
#include "via_priv.h"
#include "via_swov.h"
#ifdef XF86DRI
#include "via_drm.h"
#endif
#include "via_vgahw.h"
#include "via_id.h"

#include <math.h>

/*
 * Warning: this file contains revision checks which are CLE266-specific.
 * There seems to be no checking present for KM400 or more recent devices.
 *
 * TODO:
 *   - pVia->Chipset checking, of course
 *   - move content of pVia->HWDiff into pVia->swov
 *   - merge with CLEXF40040
 */

/*
 * Old via_regrec code.
 */
#define VIDREG_BUFFER_SIZE  100	       /* Number of entries in the VidRegBuffer. */
#define IN_VIDEO_DISPLAY     (*((unsigned long volatile *)(pVia->VidMapBase+V_FLAGS))&VBI_STATUS)
#define VIA_FIRETIMEOUT 40000

static void
viaWaitVideoCommandFire(VIAPtr pVia)
{
/*
 * Assume uncached PCI reading throughput is about 9 MB/s. 8 bytes/loop means
 * approx 1M loops/second. We want to time out after 50 ms which means 50000 loops.
 */

    unsigned count = 50000;
    CARD32 volatile *pdwState =
	(CARD32 volatile *)(pVia->VidMapBase + V_COMPOSE_MODE);

    while (--count && ((*pdwState & V1_COMMAND_FIRE)
	    || (*pdwState & V3_COMMAND_FIRE))) ;
    if (!count) {
	ErrorF("viaWaitVideoCommandFire: Timeout.\n");
    }
}

static void
viaWaitHQVFlip(VIAPtr pVia)
{
    unsigned long proReg = 0;
    CARD32 volatile *pdwState;

    if (pVia->ChipId == PCI_CHIP_VT3259 && !(pVia->swov.gdwVideoFlagSW & VIDEO_1_INUSE))
	proReg = PRO_HQV1_OFFSET;

    pdwState = (CARD32 volatile *)(pVia->VidMapBase + (HQV_CONTROL + proReg));

    if (pVia->VideoEngine == VIDEO_ENGINE_CME) {
	while (*pdwState & (HQV_SUBPIC_FLIP | HQV_SW_FLIP)) ;
    } else {
	while (!(*pdwState & HQV_FLIP_STATUS)) ;
    }
}

static void
viaWaitHQVFlipClear(VIAPtr pVia, unsigned long dwData)
{
    CARD32 volatile *pdwState =
	(CARD32 volatile *)(pVia->VidMapBase + HQV_CONTROL);
    *pdwState = dwData;

    while ((*pdwState & HQV_FLIP_STATUS)) {
	VIDOutD(HQV_CONTROL, *pdwState | HQV_FLIP_STATUS);
    }
}

static void
viaWaitVBI(VIAPtr pVia)
{
    while (IN_VIDEO_DISPLAY) ;
}

static void
viaWaitHQVDone(VIAPtr pVia)
{
    CARD32 volatile *pdwState;
    unsigned long proReg = 0;

    if (pVia->ChipId == PCI_CHIP_VT3259 && !(pVia->swov.gdwVideoFlagSW & VIDEO_1_INUSE))
	proReg = PRO_HQV1_OFFSET;

    pdwState = (CARD32 volatile *)(pVia->VidMapBase + (HQV_CONTROL + proReg));
    if (pVia->swov.MPEG_ON) {
	while ((*pdwState & HQV_SW_FLIP)) ;
    }
}

/*
 * Send all data in VidRegBuffer to the hardware.
 */
static void
FlushVidRegBuffer(VIAPtr pVia)
{
    unsigned int i;

    viaWaitVideoCommandFire(pVia);

    for (i = 0; i < pVia->VidRegCursor; i += 2) {
	VIDOutD(pVia->VidRegBuffer[i], pVia->VidRegBuffer[i + 1]);
	DBG_DD(ErrorF("FlushVideoRegs: [%i] %08lx %08lx\n",
		i >> 1, pVia->VidRegBuffer[i] + 0x200,
		pVia->VidRegBuffer[i + 1]));
    }

    /* BUG: (?) VIA never resets the cursor. 
     * My fix is commented out for now, in case they had a reason for that. /A
     */
    /* pVia->VidRegCursor = 0; */
}

/*
 * Initialize and clear VidRegBuffer.
 */
static void
ResetVidRegBuffer(VIAPtr pVia)
{
    /* BUG: (Memory leak) This allocation may need have a corresponding free somewhere... /A */
    if (!pVia->VidRegBuffer)
	pVia->VidRegBuffer =
	    xnfcalloc(VIDREG_BUFFER_SIZE, sizeof(CARD32) * 2);
    pVia->VidRegCursor = 0;
}

/*
 * Save a video register and data in VidRegBuffer.
 */
static void
SaveVideoRegister(VIAPtr pVia, CARD32 index, CARD32 data)
{
    pVia->VidRegBuffer[pVia->VidRegCursor++] = index;
    pVia->VidRegBuffer[pVia->VidRegCursor++] = data;

    if (pVia->VidRegCursor > VIDREG_BUFFER_SIZE) {
	DBG_DD(ErrorF("SaveVideoRegister: Out of video register space"));
    }
}

/*
 * HW Difference Flag (moved here from via_hwdiff.c)
 *
 * These are the entries of HWDiff used in our code (currently):
 *                     CLE266Ax   CLE266Cx   KM400     K8M800    PM800
 * ThreeHQVBuffer      FALSE      TRUE       TRUE      TRUE      TRUE
 * HQVFetchByteUnit    FALSE      TRUE       TRUE      TRUE      TRUE
 * SupportTwoColorKey  FALSE      TRUE       FALSE     FALSE     TRUE
 * HQVInitPatch        TRUE       FALSE      FALSE     FALSE     FALSE
 * HQVDisablePatch     FALSE      TRUE       TRUE      TRUE      FALSE
 *
 * This is now up to date with CLEXF40040. All unused entries were removed.
 * The functions depending on this struct are untouched. 
 */
void
VIAVidHWDiffInit(ScrnInfoPtr pScrn)
{
    VIAPtr pVia = VIAPTR(pScrn);
    VIAHWDiff *HWDiff = &pVia->HWDiff;

    switch (pVia->Chipset) {
    case VIA_CLE266:
	if (CLE266_REV_IS_AX(pVia->ChipRev)) {
	    HWDiff->dwThreeHQVBuffer = VID_HWDIFF_FALSE;
	    HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_FALSE;
	    HWDiff->dwSupportTwoColorKey = VID_HWDIFF_FALSE;
	    HWDiff->dwHQVInitPatch = VID_HWDIFF_TRUE;
	    HWDiff->dwHQVDisablePatch = VID_HWDIFF_FALSE;
	    HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
	} else {
	    HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
	    HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
	    HWDiff->dwSupportTwoColorKey = VID_HWDIFF_TRUE;
	    HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
	    HWDiff->dwHQVDisablePatch = VID_HWDIFF_TRUE;
	    HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
	}
	break;
    case VIA_KM400:
	HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
	HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
	HWDiff->dwSupportTwoColorKey = VID_HWDIFF_FALSE;
	HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
	HWDiff->dwHQVDisablePatch = VID_HWDIFF_TRUE;
	HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
	break;
    case VIA_K8M800:
	HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
	HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
	HWDiff->dwSupportTwoColorKey = VID_HWDIFF_FALSE;
	HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
	HWDiff->dwHQVDisablePatch = VID_HWDIFF_TRUE;
	HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
	break;
    case VIA_PM800:
	HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
	HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
	HWDiff->dwSupportTwoColorKey = VID_HWDIFF_TRUE;
	HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
	HWDiff->dwHQVDisablePatch = VID_HWDIFF_FALSE;
	HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
	break;
    case VIA_VM800:
    case VIA_P4M900:
	HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
	HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
	HWDiff->dwSupportTwoColorKey = VID_HWDIFF_FALSE;
	HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
	HWDiff->dwHQVDisablePatch = VID_HWDIFF_TRUE;
	HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
	break;
    case VIA_K8M890:
	HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
	HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
	HWDiff->dwSupportTwoColorKey = VID_HWDIFF_FALSE;
	HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
	HWDiff->dwHQVDisablePatch = VID_HWDIFF_TRUE;
	HWDiff->dwNeedV1Prefetch = VID_HWDIFF_TRUE;
	break;
    case VIA_P4M890:
        HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
        HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
        HWDiff->dwSupportTwoColorKey = VID_HWDIFF_FALSE;
        HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
        HWDiff->dwHQVDisablePatch = VID_HWDIFF_TRUE;
	HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
        break;
    case VIA_CX700:
        HWDiff->dwThreeHQVBuffer = VID_HWDIFF_TRUE;
        HWDiff->dwHQVFetchByteUnit = VID_HWDIFF_TRUE;
        HWDiff->dwSupportTwoColorKey = VID_HWDIFF_TRUE;
        HWDiff->dwHQVInitPatch = VID_HWDIFF_FALSE;
        HWDiff->dwHQVDisablePatch = VID_HWDIFF_FALSE;
	HWDiff->dwNeedV1Prefetch = VID_HWDIFF_FALSE;
    	break;
    default:
	xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
	    "VIAVidHWDiffInit: Unhandled ChipSet.\n");
    }
}

/*
 * Old via_overlay code.
 */
typedef struct _YCBCRREC
{
    CARD32 dwY;
    CARD32 dwCB;
    CARD32 dwCR;
} YCBCRREC;

/* 
 * Verify that using V1 bit definitions on V3
 * is not broken in OverlayGetV1V3Format().
 */

#if V1_COLORSPACE_SIGN != V3_COLORSPACE_SIGN
#error "V1_COLORSPACE_SIGN != V3_COLORSPACE_SIGN"
#endif
#if V1_YUV422 != V3_YUV422
#error "V1_YUV422 != V3_YUV422"
#endif
#if V1_SWAP_HW_HQV != V3_SWAP_HW_HQV
#error "V1_SWAP_HW_HQV != V3_SWAP_HW_HQV"
#endif
#if V1_RGB15 != V3_RGB15
#error "V1_RGB15 != V3_RGB15"
#endif
#if V1_RGB16 != V3_RGB16
#error "V1_RGB16 != V3_RGB16"
#endif
#if V1_RGB32 != V3_RGB32
#error "V1_RGB32 != V3_RGB32"
#endif

static BOOL
viaOverlayGetV1V3Format(VIAPtr pVia, int vport,	/* 1 or 3, as in V1 or V3 */
    unsigned long videoFlag, unsigned long *pVidCtl, unsigned long *pHQVCtl)
{
    if (videoFlag & VIDEO_HQV_INUSE) {
	switch (pVia->swov.SrcFourCC) {
	case FOURCC_YV12:
	case FOURCC_XVMC:
	    *pHQVCtl |= HQV_YUV420;
	    break;
	case FOURCC_YUY2:
	    *pHQVCtl |= HQV_YUV422;
	    break;
	case FOURCC_RV32:
	    *pVidCtl |= V1_RGB32;
	    *pHQVCtl |= HQV_RGB32;
	    break;
	case FOURCC_RV15:
	    *pVidCtl |= V1_RGB15;
	    *pHQVCtl |= HQV_RGB15;
	    break;
	case FOURCC_RV16:
	    *pVidCtl |= V1_RGB16;
	    *pHQVCtl |= HQV_RGB16;
	    break;
	default:
	    DBG_DD(ErrorF
		("viaOverlayGetV1V3Format: Invalid FOURCC format (0x%lx).\n",
		    pVia->swov.SrcFourCC));
	    return FALSE;
	}
	*pVidCtl |= V1_SWAP_HW_HQV;
	*pHQVCtl |= HQV_SRC_SW | HQV_ENABLE | HQV_SW_FLIP;
    } else {
	switch (pVia->swov.SrcFourCC) {
	case FOURCC_YV12:
	case FOURCC_XVMC:
	    if (vport == 1) {
		*pVidCtl |= V1_YCbCr420;
	    } else {
		DBG_DD(ErrorF
		    ("viaOverlayGetV1V3Format: V3 does not support planar YUV.\n"));
		return FALSE;
	    }
	    break;
	case FOURCC_YUY2:
	    *pVidCtl |= V1_YUV422;
	    break;
	case FOURCC_RV32:
	case FOURCC_RV15:
	case FOURCC_RV16:
	    ErrorF
		("viaOverlayGetV1V3Format: Can't display RGB video in this configuration.\n");
	    return FALSE;
	default:
	    DBG_DD(ErrorF
		("viaOverlayGetV1V3Format: Invalid FOURCC format (0x%lx).\n",
		    pVia->swov.SrcFourCC));
	    return FALSE;
	}
    }
    *pVidCtl |= V1_COLORSPACE_SIGN;
    return TRUE;
}

static unsigned long
viaOverlayGetSrcStartAddress(VIAPtr pVia, unsigned long videoFlag,
    LPDDUPDATEOVERLAY pUpdate, unsigned long srcPitch,
    unsigned long *pHQVoffset)
{
    unsigned long srcWidth =
	(unsigned long)(pUpdate->SrcRight - pUpdate->SrcLeft);
    unsigned long dstWidth =
	(unsigned long)(pUpdate->DstRight - pUpdate->DstLeft);
    unsigned long srcHeight =
	(unsigned long)(pUpdate->SrcBottom - pUpdate->SrcTop);
    unsigned long dstHeight =
	(unsigned long)(pUpdate->DstBottom - pUpdate->DstTop);

    unsigned long offset = 0;
    unsigned long srcTopOffset = 0;
    unsigned long srcLeftOffset = 0;

    int n = 1;

    if ((pUpdate->SrcLeft != 0) || (pUpdate->SrcTop != 0)) {
	switch (pVia->swov.SrcFourCC) {
	case FOURCC_RV32:
	    n = 2;
	case FOURCC_YUY2:
	case FOURCC_UYVY:
	case FOURCC_RV15:
	case FOURCC_RV16:

	    if (videoFlag & VIDEO_HQV_INUSE) {
		offset =
		    (((pUpdate->SrcTop & ~3) * srcPitch) +
		    ((pUpdate->SrcLeft << n) & ~31));

		if (srcHeight > dstHeight)
		    srcTopOffset =
			((pUpdate->SrcTop & ~3) * dstHeight / srcHeight) *
			srcPitch;
		else
		    srcTopOffset = (pUpdate->SrcTop & ~3) * srcPitch;

		if (srcWidth > dstWidth)
		    srcLeftOffset =
			((pUpdate->SrcLeft << n) & ~31) * dstWidth / srcWidth;
		else
		    srcLeftOffset = (pUpdate->SrcLeft << n) & ~31;
		*pHQVoffset = srcTopOffset + srcLeftOffset;
	    } else
		offset =
		    ((pUpdate->SrcTop * srcPitch) +
		    ((pUpdate->SrcLeft << n) & ~15));
	    break;

	case FOURCC_YV12:
	case FOURCC_XVMC:

	    if (videoFlag & VIDEO_HQV_INUSE)
		offset =
		    (((pUpdate->SrcTop & ~3) * (srcPitch << 1)) +
		    ((pUpdate->SrcLeft << 1) & ~31));
	    else {
		offset =
		    ((((pUpdate->SrcTop & ~3) * srcPitch) +
			pUpdate->SrcLeft) & ~31);
		if (pUpdate->SrcTop > 0)
		    pVia->swov.overlayRecordV1.dwUVoffset =
			(((((pUpdate->SrcTop & ~3) >> 1) * srcPitch) +
			    pUpdate->SrcLeft) & ~31) >> 1;
		else
		    pVia->swov.overlayRecordV1.dwUVoffset = offset >> 1;
	    }
	    break;

	default:
	    DBG_DD(ErrorF
		("viaGetSrcStartAddress: Invalid FOURCC format (0x%lx).\n",
		    pVia->swov.SrcFourCC));
	    break;
	}
    } else {
	pVia->swov.overlayRecordV1.dwUVoffset = offset = 0;
    }

    return offset;
}

static YCBCRREC
viaOverlayGetYCbCrStartAddress(unsigned long videoFlag,
    unsigned long startAddr, unsigned long offset, unsigned long UVoffset,
    unsigned long srcPitch, unsigned long srcHeight)
{
    YCBCRREC YCbCr;

    if (videoFlag & VIDEO_HQV_INUSE) {
	YCbCr.dwY = startAddr;
	YCbCr.dwCB = startAddr + srcPitch * srcHeight;
	YCbCr.dwCR = startAddr + srcPitch * srcHeight
	    + srcPitch * (srcHeight >> 2);
    } else {
	YCbCr.dwY = startAddr + offset;
	YCbCr.dwCB = startAddr + srcPitch * srcHeight + UVoffset;
	YCbCr.dwCR = startAddr + srcPitch * srcHeight + UVoffset
	    + srcPitch * (srcHeight >> 2);
    }
    return YCbCr;
}

static unsigned long
viaOverlayHQVCalcZoomWidth(VIAPtr pVia, unsigned long videoFlag,
    unsigned long srcWidth, unsigned long dstWidth,
    unsigned long *pZoomCtl, unsigned long *pMiniCtl,
    unsigned long *pHQVfilterCtl, unsigned long *pHQVminiCtl,
    unsigned long *pHQVzoomflag)
{
    unsigned long tmp, sw1, d, falign, mdiv;
    Bool zoom_ok = TRUE;

    CARD32 HQVfilter[5] = {
	HQV_H_FILTER_DEFAULT, HQV_H_TAP4_121, HQV_H_TAP4_121,
	HQV_H_TAP8_12221, HQV_H_TAP8_12221
    };
    /* CARD HQVmini[5] = { 0, 0xc00, 0xa00, 0x900, 0x8800 }; */

    falign = 0;
    mdiv = 1;

    if (srcWidth == dstWidth) {	       /* No zoom */
	*pHQVfilterCtl |= HQV_H_FILTER_DEFAULT;
    } else if (srcWidth < dstWidth) {  /* Zoom in */

	tmp = srcWidth * 0x800 / dstWidth;
	*pZoomCtl = ((tmp & 0x7ff) << 16) | V1_X_ZOOM_ENABLE;
	*pMiniCtl |= V1_X_INTERPOLY;
	zoom_ok = !(tmp > 0x7ff);

	*pHQVzoomflag = 1;
	*pHQVfilterCtl |= HQV_H_FILTER_DEFAULT;

    } else {			       /* srcWidth > dstWidth - Zoom out */

	/* HQV rounding patch, instead of:
	 * //tmp = dstWidth*0x0800 / srcWidth; */
	tmp = dstWidth * 0x800 * 0x400 / srcWidth;
	tmp = tmp / 0x400 + ((tmp & 0x3ff) ? 1 : 0);

	*pHQVminiCtl =
	    (tmp & 0x7ff) | HQV_H_MINIFY_ENABLE | HQV_H_MINIFY_DOWN;

	/* Scale down the picture by a factor mdiv = (1 << d) = {2, 4, 8 or 16} */

	sw1 = srcWidth;
	for (d = 1; d < 5; d++) {
	    sw1 >>= 1;
	    if (sw1 <= dstWidth)
		break;
	}
	if (d == 5) {		       /* Too small. */
	    d = 4;
	    zoom_ok = FALSE;
	}
	mdiv = 1 << d;		       /* <= {2,4,8,16} */
	falign = ((mdiv << 1) - 1) & 0xf;	/* <= {3,7,15,15} */
	*pMiniCtl |= V1_X_INTERPOLY;
	*pMiniCtl |= ((d << 1) - 1) << 24;	/* <= {1,3,5,7} << 24 */

	*pHQVfilterCtl |= HQVfilter[d];
	/* *pHQVminiCtl = HQVmini[d]; */
	*pHQVminiCtl |= HQV_HDEBLOCK_FILTER;

	/* Scale to arbitrary size, on top of previous scaling by (1 << d). */

	if (sw1 < dstWidth) {
	    /* CLE bug
	     *pZoomCtl = sw1 * 0x0800 / dstWidth;*/
	    *pZoomCtl = (sw1 - 2) * 0x0800 / dstWidth;
	    *pZoomCtl = ((*pZoomCtl & 0x7ff) << 16) | V1_X_ZOOM_ENABLE;
	}
    }

    if (videoFlag & VIDEO_1_INUSE) {
	pVia->swov.overlayRecordV1.dwFetchAlignment = falign;
	pVia->swov.overlayRecordV1.dwminifyH = mdiv;
    } else {
	pVia->swov.overlayRecordV3.dwFetchAlignment = falign;
	pVia->swov.overlayRecordV3.dwminifyH = mdiv;
    }

    return zoom_ok;
}

static unsigned long
viaOverlayHQVCalcZoomHeight(VIAPtr pVia, unsigned long srcHeight,
    unsigned long dstHeight, unsigned long *pZoomCtl,
    unsigned long *pMiniCtl, unsigned long *pHQVfilterCtl,
    unsigned long *pHQVminiCtl, unsigned long *pHQVzoomflag)
{
    unsigned long tmp, sh1, d;
    Bool zoom_ok = TRUE;

    CARD32 HQVfilter[5] = {
	HQV_V_TAP4_121, HQV_V_TAP4_121, HQV_V_TAP4_121,
	HQV_V_TAP8_12221, HQV_V_TAP8_12221
    };
    /* CARD32 HQVmini[5] = { 0, 0x0c000000, 0x0a000000, 0x09000000, 0x08800000 }; */

    /*if (pVia->pBIOSInfo->scaleY)
     * {
     * dstHeight = dstHeight + 1;
     * } */

    if (srcHeight == dstHeight) {      /* No zoom */
	*pHQVfilterCtl |= HQV_V_TAP4_121;
    } else if (srcHeight < dstHeight) {	/* Zoom in */

	tmp = srcHeight * 0x0400 / dstHeight;
	*pZoomCtl |= ((tmp & 0x3ff) | V1_Y_ZOOM_ENABLE);
	*pMiniCtl |= (V1_Y_INTERPOLY | V1_YCBCR_INTERPOLY);

	*pHQVzoomflag = 1;
	*pHQVfilterCtl |= HQV_V_TAP4_121;
    } else {			       /* srcHeight > dstHeight - Zoom out */

	/* HQV rounding patch, instead of:
	 * //tmp = dstHeight*0x0800 / srcHeight; */
	tmp = dstHeight * 0x0800 * 0x400 / srcHeight;
	tmp = tmp / 0x400 + ((tmp & 0x3ff) ? 1 : 0);
	*pHQVminiCtl |=
	    ((tmp & 0x7ff) << 16) | HQV_V_MINIFY_ENABLE | HQV_V_MINIFY_DOWN;

	/* Scale down the picture by a factor (1 << d) = {2, 4, 8 or 16} */

	sh1 = srcHeight;
	for (d = 1; d < 5; d++) {
	    sh1 >>= 1;
	    if (sh1 <= dstHeight)
		break;
	}
	if (d == 5) {		       /* Too small. */
	    d = 4;
	    zoom_ok = FALSE;
	}

	*pMiniCtl |= ((d << 1) - 1) << 16;	/* <= {1,3,5,7} << 16 */

	*pHQVfilterCtl |= HQVfilter[d];
	/* *pHQVminiCtl |= HQVmini[d]; */
	*pHQVminiCtl |= HQV_VDEBLOCK_FILTER;

	/* Scale to arbitrary size, on top of previous scaling by (1 << d). */

	if (sh1 < dstHeight) {
	    tmp = sh1 * 0x0400 / dstHeight;
	    *pZoomCtl |= ((tmp & 0x3ff) | V1_Y_ZOOM_ENABLE);
	    *pMiniCtl |= V1_Y_INTERPOLY | V1_YCBCR_INTERPOLY;
	}
    }

    return zoom_ok;
}

static unsigned long
viaOverlayGetFetch(VIAPtr pVia, unsigned long videoFlag,
    unsigned long srcWidth, unsigned long dstWidth,
    unsigned long oriSrcWidth, unsigned long *pHQVsrcFetch)
{
    unsigned long fetch = 0;
    int n = 2;			       /* 2^n bytes per pixel. */

    switch (pVia->swov.SrcFourCC) {
    case FOURCC_YV12:
    case FOURCC_XVMC:
	n = 0;			       /* 2^n = 1 byte per pixel (Y channel in planar YUV) */
	break;
    case FOURCC_UYVY:
    case FOURCC_YUY2:
    case FOURCC_RV15:
    case FOURCC_RV16:
	n = 1;			       /* 2^n = 2 bytes per pixel (packed YUV) */
	break;
    case FOURCC_RV32:
	n = 2;
	break;
    default:
	DBG_DD(ErrorF("viaOverlayGetFetch: Invalid FOURCC format (0x%lx).\n",
		pVia->swov.SrcFourCC));
	break;
    }

    if (videoFlag & VIDEO_HQV_INUSE) {
	*pHQVsrcFetch = oriSrcWidth << n;
	if (n == 0) {
	    /* Assume n == 0 <=> Planar YUV.
	     * The V1/V3 pixelformat is always packed YUV when we use HQV,
	     * so we switch from 8-bit to 16-bit pixels here.
	     */
	    n = 1;
	}
	if (dstWidth >= srcWidth)
	    fetch = (ALIGN_TO(srcWidth << n, 16) >> 4) + 1;
	else
	    fetch = (ALIGN_TO(dstWidth << n, 16) >> 4) + 1;
    } else {
	if (n == 0)
	    fetch = (ALIGN_TO(srcWidth, 32) >> 4);
	else
	    fetch = (ALIGN_TO(srcWidth << n, 16) >> 4) + 1;
    }

    /* Fix planar mode problem. */
    if (fetch < 4)
	fetch = 4;

    return fetch;
}

/*
 * This function uses quadratic mapping to adjust the midpoint of the scaling.
 */
static float
rangeEqualize(float inLow, float inHigh, float outLow, float outHigh,
    float outMid, float inValue)
{
    float
	inRange = inHigh - inLow,
	outRange = outHigh - outLow,
	normIn = ((inValue - inLow) / inRange) * 2. - 1.,
	delta = outMid - outRange * 0.5 - outLow;
    return (inValue - inLow) * outRange / inRange + outLow + (1. -
	normIn * normIn) * delta;
}

static unsigned
vPackFloat(float val, float hiLimit, float loLimit, float mult, int shift,
    Bool doSign)
{
    unsigned packed, mask, sign;

    val = (val > hiLimit) ? hiLimit : val;
    val = (val < loLimit) ? loLimit : val;
    sign = (val < 0) ? 1 : 0;
    val = (sign) ? -val : val;
    packed = ((unsigned)(val * mult + 1.)) >> 1;
    mask = (1 << shift) - 1;
    return (((packed >=
		mask) ? mask : packed) | ((doSign) ? (sign << shift) : 0));

}

typedef float colorCoeff[5];
static colorCoeff colorCTable[] = { {1.1875, 1.625, 0.875, 0.375, 2.0},
{1.164, 1.596, 0.54, 0.45, 2.2}
};

/*
 * This function is a partial rewrite of the overlay.c file of the original VIA
 * drivers, which was extremely nasty and difficult to follow. Coefficients for
 * new chipset models should be added in the table above and, if needed,
 * implemented in the model switch below.
 */
static void
viaCalculateVideoColor(VIAPtr pVia, int hue, int saturation, int brightness,
    int contrast, Bool reset, CARD32 * col1, CARD32 * col2)
{
    float fA, fB1, fC1, fD, fB2, fC2, fB3, fC3;
    float fPI, fContrast, fSaturation, fHue, fBrightness;
    const float *mCoeff;
    unsigned long dwA, dwB1, dwC1, dwD, dwB2, dwC2, dwB3, dwC3, dwS;
    unsigned long dwD_Int, dwD_Dec;
    int intD;
    int model;

    fPI = (float)(M_PI / 180.);

    if (reset) {
	saturation = 10000;
	brightness = 5000;
	contrast = 10000;
    }

    switch (pVia->ChipId) {
    case PCI_CHIP_VT3205:
    case PCI_CHIP_VT3204:
    case PCI_CHIP_VT3259:
    case PCI_CHIP_VT3314:
    case PCI_CHIP_VT3336:
    case PCI_CHIP_VT3364:
    case PCI_CHIP_VT3324:
    case PCI_CHIP_VT3327:
	model = 0;
	break;
    case PCI_CHIP_CLE3122:
	model = (CLE266_REV_IS_CX(pVia->ChipRev) ? 0 : 1);
	break;
    default:
	ErrorF("Unknown Chip ID\n");
	model = 0;
    }

    switch (model) {
    case 0:
	fBrightness =
	    rangeEqualize(0., 10000., -128., 128., -16., (float)brightness);
	fContrast =
	    rangeEqualize(0., 20000., 0., 1.6645, 1.0, (float)contrast);
	fSaturation = rangeEqualize(0., 20000, 0., 2., 1., (float)saturation);
	break;
    default:
	fBrightness =
	    rangeEqualize(0., 10000., -128., 128., -12., (float)brightness);
	fContrast =
	    rangeEqualize(0., 20000., 0., 1.6645, 1.1, (float)contrast);
	fSaturation =
	    rangeEqualize(0., 20000, 0., 2., 1.15, (float)saturation);
	break;
    }
    fHue = (float)hue;

    mCoeff = colorCTable[model];

    fA = (float)(mCoeff[0] * fContrast);
    fB1 = (float)(-mCoeff[1] * fContrast * fSaturation * sin(fHue * fPI));
    fC1 = (float)(mCoeff[1] * fContrast * fSaturation * cos(fHue * fPI));
    fD = (float)(mCoeff[0] * (fBrightness));
    fB2 = (float)((mCoeff[2] * sin(fHue * fPI) -
	    mCoeff[3] * cos(fHue * fPI)) * fContrast * fSaturation);
    fC2 = (float)(-(mCoeff[2] * cos(fHue * fPI) +
	    mCoeff[3] * sin(fHue * fPI)) * fContrast * fSaturation);
    fB3 = (float)(mCoeff[4] * fContrast * fSaturation * cos(fHue * fPI));
    fC3 = (float)(mCoeff[4] * fContrast * fSaturation * sin(fHue * fPI));

    switch (model) {
    case 0:
	dwA = vPackFloat(fA, 1.9375, 0., 32., 5, 0);
	dwB1 = vPackFloat(fB1, 2.125, -2.125, 16., 5, 1);
	dwC1 = vPackFloat(fC1, 2.125, -2.125, 16., 5, 1);

	if (fD >= 0) {
	    intD = (int)fD;
	    if (intD > 127)
		intD = 127;
	    dwD_Int = ((unsigned long)intD) & 0xff;
	    dwD = ((unsigned long)(fD * 16 + 1)) >> 1;
	    dwD_Dec = dwD & 0x7;
	} else {
	    intD = (int)fD;
	    if (intD < -128)
		intD = -128;
	    intD = intD + 256;
	    dwD_Int = ((unsigned long)intD) & 0xff;
	    fD = -fD;
	    dwD = ((unsigned long)(fD * 16 + 1)) >> 1;
	    dwD_Dec = dwD & 0x7;
	}

	dwB2 = vPackFloat(fB2, 1.875, -1.875, 16, 4, 1);
	dwC2 = vPackFloat(fC2, 1.875, -1.875, 16, 4, 1);
	dwB3 = vPackFloat(fB3, 3.875, -3.875, 16, 5, 1);
	dwC3 = vPackFloat(fC3, 3.875, -3.875, 16, 5, 1);
	*col1 = (dwA << 24) | (dwB1 << 16) | (dwC1 << 8) | dwD_Int;
	*col2 =
	    (dwD_Dec << 29 | dwB2 << 24) | (dwC2 << 16) | (dwB3 << 8) |
	    (dwC3);
	break;

    default:
	dwA = vPackFloat(fA, 1.9375, -0., 32, 5, 0);
	dwB1 = vPackFloat(fB1, 0.75, -0.75, 8., 2, 1);
	dwC1 = vPackFloat(fC1, 2.875, 1., 16., 5, 0);

	if (fD >= 127)
	    fD = 127;

	if (fD <= -128)
	    fD = -128;

	if (fD >= 0) {
	    dwS = 0;
	} else {
	    dwS = 1;
	    fD = fD + 128;
	}

	dwD = ((unsigned long)(fD * 2 + 1)) >> 1;
	if (dwD >= 0x7f) {
	    dwD = 0x7f | (dwS << 7);
	} else {
	    dwD = (dwD & 0x7f) | (dwS << 7);
	}

	dwB2 = vPackFloat(fB2, 0., -0.875, 16., 3, 0);
	dwC2 = vPackFloat(fC2, 0., -1.875, 16., 4, 0);
	dwB3 = vPackFloat(fB3, 3.75, 0., 8., 4, 0);
	dwC3 = vPackFloat(fC3, 1.25, -1.25, 8., 3, 1);
	*col1 = (dwA << 24) | (dwB1 << 18) | (dwC1 << 9) | dwD;
	*col2 = (dwB2 << 25) | (dwC2 << 17) | (dwB3 << 10) | (dwC3 << 2);
	break;
    }
}

/*
 *
 *
 */
void
viaSetColorSpace(VIAPtr pVia, int hue, int saturation, int brightness,
    int contrast, Bool reset)
{
    CARD32 col1, col2;

    viaCalculateVideoColor(pVia, hue, saturation, brightness, contrast, reset,
	&col1, &col2);
    switch (pVia->ChipId) {
    case PCI_CHIP_VT3205:
    case PCI_CHIP_VT3204:
    case PCI_CHIP_VT3259:
    case PCI_CHIP_VT3314:
	VIDOutD(V3_ColorSpaceReg_1, col1);
	VIDOutD(V3_ColorSpaceReg_2, col2);
	DBG_DD(ErrorF("000002C4 %08lx\n", col1));
	DBG_DD(ErrorF("000002C8 %08lx\n", col2));
	break;
    case PCI_CHIP_VT3327:
    case PCI_CHIP_VT3336:
    case PCI_CHIP_VT3324:
    case PCI_CHIP_VT3364:
    case PCI_CHIP_CLE3122:
	VIDOutD(V1_ColorSpaceReg_2, col2);
	VIDOutD(V1_ColorSpaceReg_1, col1);
	VIDOutD(V3_ColorSpaceReg_2, col2);
	VIDOutD(V3_ColorSpaceReg_1, col1);

	DBG_DD(ErrorF("00000288 %08lx\n", col2));
	DBG_DD(ErrorF("00000284 %08lx\n", col1));
	break;
    default:
	DBG_DD(ErrorF("Unknown DeviceID\n"));
	break;
    }
}

static unsigned long
ViaInitVideoStatusFlag(VIAPtr pVia)
{
    switch (pVia->ChipId) {
    case PCI_CHIP_VT3205:
    case PCI_CHIP_VT3204:
    case PCI_CHIP_VT3259:
    case PCI_CHIP_VT3314:
	return VIDEO_HQV_INUSE | SW_USE_HQV | VIDEO_3_INUSE;
    case PCI_CHIP_VT3327:
    case PCI_CHIP_VT3336:
    case PCI_CHIP_VT3324:
    case PCI_CHIP_VT3364:
	return VIDEO_HQV_INUSE | SW_USE_HQV | VIDEO_1_INUSE | \
               VIDEO_ACTIVE | VIDEO_SHOW;
    case PCI_CHIP_CLE3122:
	return VIDEO_HQV_INUSE | SW_USE_HQV | VIDEO_1_INUSE;
    default:
	DBG_DD(ErrorF("Unknown DeviceID\n"));
	break;
    }
    return 0UL;
}

static unsigned long
ViaSetVidCtl(VIAPtr pVia, unsigned int videoFlag)
{
    if (videoFlag & VIDEO_1_INUSE) {
	/*=* Modify for C1 FIFO *=*/
	/* WARNING: not checking Chipset! */
	if (CLE266_REV_IS_CX(pVia->ChipRev))
	    return V1_ENABLE | V1_EXPIRE_NUM_F;
	else {
	    /* Overlay source format for V1 */
	    if (pVia->swov.gdwUseExtendedFIFO)
		return V1_ENABLE | V1_EXPIRE_NUM_A | V1_FIFO_EXTENDED;
	    else
		return V1_ENABLE | V1_EXPIRE_NUM;
	}
    } else {
	switch (pVia->ChipId) {
	case PCI_CHIP_VT3205:
	case PCI_CHIP_VT3204:
	case PCI_CHIP_VT3259:
	case PCI_CHIP_VT3314:
	    return V3_ENABLE | V3_EXPIRE_NUM_3205;
        case PCI_CHIP_VT3327:
	case PCI_CHIP_VT3336:
    	case PCI_CHIP_VT3324:
	case PCI_CHIP_VT3364:
            return V3_ENABLE | VIDEO_EXPIRE_NUM_VT3336;
	case PCI_CHIP_CLE3122:
	    if (CLE266_REV_IS_CX(pVia->ChipRev))
		return V3_ENABLE | V3_EXPIRE_NUM_F;
	    else
		return V3_ENABLE | V3_EXPIRE_NUM;
	    break;
	default:
	    DBG_DD(ErrorF("Unknown DeviceID\n"));
	    break;
	}
    }
    return 0;
}

/*
 * Fill the buffer with 0x8000 (YUV2 black).
 */
static void
ViaYUVFillBlack(VIAPtr pVia, int offset, int num)
{
    CARD16 *ptr = (CARD16 *) (pVia->FBBase + offset);

    while (num-- > 0)
#if X_BYTE_ORDER == X_LITTLE_ENDIAN
	*ptr++ = 0x0080;
#else
	*ptr++ = 0x8000;
#endif
}

/*
 * Add an HQV surface to an existing FOURCC surface.
 * numbuf: number of buffers, 1, 2 or 3
 * fourcc: FOURCC code of the current (already existing) surface
 */
static long
AddHQVSurface(ScrnInfoPtr pScrn, unsigned int numbuf, CARD32 fourcc)
{
    unsigned int i, width, height, pitch, fbsize, addr;
    unsigned long retCode;
    BOOL isplanar;

    VIAPtr pVia = VIAPTR(pScrn);
    CARD32 AddrReg[3] =
	{ HQV_DST_STARTADDR0, HQV_DST_STARTADDR1, HQV_DST_STARTADDR2 };
    unsigned long proReg = 0;

    if (pVia->ChipId == PCI_CHIP_VT3259 && !(pVia->swov.gdwVideoFlagSW & VIDEO_1_INUSE))
	proReg = PRO_HQV1_OFFSET;

    isplanar = ((fourcc == FOURCC_YV12) || (fourcc == FOURCC_XVMC));

    width = pVia->swov.SWDevice.gdwSWSrcWidth;
    height = pVia->swov.SWDevice.gdwSWSrcHeight;
    pitch = pVia->swov.SWDevice.dwPitch;
    fbsize = pitch * height * (isplanar ? 2 : 1);

    VIAFreeLinear(&pVia->swov.HQVMem);
    retCode = VIAAllocLinear(&pVia->swov.HQVMem, pScrn, fbsize * numbuf);
    if (retCode != Success)
	return retCode;
    addr = pVia->swov.HQVMem.base;

    ViaYUVFillBlack(pVia, addr, fbsize);

    for (i = 0; i < numbuf; i++) {
	pVia->swov.overlayRecordV1.dwHQVAddr[i] = addr;
	VIDOutD(AddrReg[i] + proReg, addr);
	addr += fbsize;
    }

    return Success;
}

/*
 * Create a FOURCC surface.
 * doalloc: set true to actually allocate memory for the framebuffers
 */
static long
CreateSurface(ScrnInfoPtr pScrn, CARD32 FourCC, CARD16 Width,
    CARD16 Height, BOOL doalloc)
{
    VIAPtr pVia = VIAPTR(pScrn);
    unsigned long pitch, fbsize, addr;
    unsigned long retCode;
    BOOL isplanar;

    pVia->swov.SrcFourCC = FourCC;
    pVia->swov.gdwVideoFlagSW = ViaInitVideoStatusFlag(pVia);

    isplanar = FALSE;
    switch (FourCC) {
    case FOURCC_YV12:
    case FOURCC_XVMC:
	isplanar = TRUE;
	pitch = ALIGN_TO(Width, 32);
	fbsize = pitch * Height * 1.5;
	break;
    case FOURCC_RV32:
	pitch = ALIGN_TO(Width << 2, 32);
	fbsize = pitch * Height;
	break;
    default:
	pitch = ALIGN_TO(Width << 1, 32);
	fbsize = pitch * Height;
	break;
    }

    if (doalloc) {
	VIAFreeLinear(&pVia->swov.SWfbMem);
	retCode = VIAAllocLinear(&pVia->swov.SWfbMem, pScrn, fbsize * 2);
	if (retCode != Success)
	    return retCode;
	addr = pVia->swov.SWfbMem.base;

	ViaYUVFillBlack(pVia, addr, fbsize);

	pVia->swov.SWDevice.dwSWPhysicalAddr[0] = addr;
	pVia->swov.SWDevice.dwSWPhysicalAddr[1] = addr + fbsize;
	pVia->swov.SWDevice.lpSWOverlaySurface[0] = pVia->FBBase + addr;
	pVia->swov.SWDevice.lpSWOverlaySurface[1] =
	    pVia->swov.SWDevice.lpSWOverlaySurface[0] + fbsize;

	if (isplanar) {
	    pVia->swov.SWDevice.dwSWCrPhysicalAddr[0] =
		pVia->swov.SWDevice.dwSWPhysicalAddr[0] + (pitch * Height);
	    pVia->swov.SWDevice.dwSWCrPhysicalAddr[1] =
		pVia->swov.SWDevice.dwSWPhysicalAddr[1] + (pitch * Height);
	    pVia->swov.SWDevice.dwSWCbPhysicalAddr[0] =
		pVia->swov.SWDevice.dwSWCrPhysicalAddr[0] +
		((pitch >> 1) * (Height >> 1));
	    pVia->swov.SWDevice.dwSWCbPhysicalAddr[1] =
		pVia->swov.SWDevice.dwSWCrPhysicalAddr[1] +
		((pitch >> 1) * (Height >> 1));
	}
    }

    pVia->swov.SWDevice.gdwSWSrcWidth = Width;
    pVia->swov.SWDevice.gdwSWSrcHeight = Height;
    pVia->swov.SWDevice.dwPitch = pitch;

    pVia->swov.overlayRecordV1.dwV1OriWidth = Width;
    pVia->swov.overlayRecordV1.dwV1OriHeight = Height;
    pVia->swov.overlayRecordV1.dwV1OriPitch = pitch;

    return Success;
}

/*
 *
 */
int
ViaSwovSurfaceCreate(ScrnInfoPtr pScrn, viaPortPrivPtr pPriv, CARD32 FourCC,
    CARD16 Width, CARD16 Height)
{
    VIAPtr pVia = VIAPTR(pScrn);
    unsigned long retCode = Success;
    int numbuf = pVia->HWDiff.dwThreeHQVBuffer ? 3 : 2;

    DBG_DD(ErrorF("ViaSwovSurfaceCreate: FourCC =0x%08lx\n", FourCC));

    if ((pVia->VideoStatus & VIDEO_SWOV_SURFACE_CREATED) &&
	(FourCC == pPriv->FourCC))
	return Success;

    pPriv->FourCC = FourCC;
    switch (FourCC) {
    case FOURCC_YUY2:
    case FOURCC_RV15:
    case FOURCC_RV16:
    case FOURCC_RV32:
	retCode = CreateSurface(pScrn, FourCC, Width, Height, TRUE);
	if (retCode != Success)
	    break;
	if ((pVia->swov.gdwVideoFlagSW & SW_USE_HQV))
	    retCode = AddHQVSurface(pScrn, numbuf, FourCC);
	break;

    case FOURCC_HQVSW:
	retCode = AddHQVSurface(pScrn, numbuf, FOURCC_YUY2);
	break;

    case FOURCC_YV12:
	retCode = CreateSurface(pScrn, FourCC, Width, Height, TRUE);
	if (retCode == Success)
	    retCode = AddHQVSurface(pScrn, numbuf, FOURCC_YV12);
	break;

    case FOURCC_XVMC:
	retCode = CreateSurface(pScrn, FourCC, Width, Height, FALSE);
	if (retCode == Success)
	    retCode = AddHQVSurface(pScrn, numbuf, FOURCC_XVMC);
	break;

    default:
	break;
    }

    if (retCode == Success) {
	pVia->swov.SWDevice.lpSWOverlaySurface[0] =
	    pVia->FBBase + pVia->swov.SWDevice.dwSWPhysicalAddr[0];
	pVia->swov.SWDevice.lpSWOverlaySurface[1] =
	    pVia->FBBase + pVia->swov.SWDevice.dwSWPhysicalAddr[1];

	DBG_DD(ErrorF(" lpSWOverlaySurface[0]: %p\n",
		pVia->swov.SWDevice.lpSWOverlaySurface[0]));
	DBG_DD(ErrorF(" lpSWOverlaySurface[1]: %p\n",
		pVia->swov.SWDevice.lpSWOverlaySurface[1]));

	pVia->VideoStatus |= VIDEO_SWOV_SURFACE_CREATED | VIDEO_SWOV_ON;
    }
    return retCode;
}

/*
 *  Destroy Surface
 */
void
ViaSwovSurfaceDestroy(ScrnInfoPtr pScrn, viaPortPrivPtr pPriv)
{
    VIAPtr pVia = VIAPTR(pScrn);

    DBG_DD(ErrorF("ViaSwovSurfaceDestroy: FourCC =0x%08lx\n", pPriv->FourCC));

    if (pVia->VideoStatus & VIDEO_SWOV_SURFACE_CREATED) {
	DBG_DD(ErrorF("ViaSwovSurfaceDestroy: VideoStatus =0x%08lx\n",
		pVia->VideoStatus));

	switch (pPriv->FourCC) {
	case FOURCC_YUY2:
	case FOURCC_RV16:
	case FOURCC_RV32:
	case FOURCC_RV15:
	    pVia->swov.SrcFourCC = 0;

	    VIAFreeLinear(&pVia->swov.SWfbMem);
	    if ((pVia->swov.gdwVideoFlagSW & SW_USE_HQV))
		VIAFreeLinear(&pVia->swov.HQVMem);
	    pVia->swov.gdwVideoFlagSW = 0;
	    break;

	case FOURCC_HQVSW:
	    VIAFreeLinear(&pVia->swov.HQVMem);
	    pVia->swov.gdwVideoFlagSW = 0;
	    break;

	case FOURCC_YV12:
	    VIAFreeLinear(&pVia->swov.SWfbMem);
	case FOURCC_XVMC:
	    pVia->swov.SrcFourCC = 0;

	    VIAFreeLinear(&pVia->swov.HQVMem);
	    pVia->swov.gdwVideoFlagSW = 0;
	    break;
	}

	pPriv->FourCC = 0;
	pVia->VideoStatus &= ~VIDEO_SWOV_SURFACE_CREATED;

    } else
	DBG_DD(ErrorF
	    ("ViaSwovSurfaceDestroy: No SW Overlay Surface Destroyed,"
		" VideoStatus =0x%08lx\n", pVia->VideoStatus));
}

static void
SetFIFO_V1(VIAPtr pVia, CARD8 depth, CARD8 prethreshold, CARD8 threshold)
{
    SaveVideoRegister(pVia, V_FIFO_CONTROL, ((depth - 1) & 0x7f) |
	((prethreshold & 0x7f) << 24) | ((threshold & 0x7f) << 8));
}

static void
SetFIFO_V3(VIAPtr pVia, CARD8 depth, CARD8 prethreshold, CARD8 threshold)
{
    if ((pVia->ChipId == PCI_CHIP_VT3314) || (pVia->ChipId == PCI_CHIP_VT3324) || (pVia->ChipId == PCI_CHIP_VT3327)) {
	SaveVideoRegister(pVia, ALPHA_V3_FIFO_CONTROL,
	    (VIDInD(ALPHA_V3_FIFO_CONTROL) & ALPHA_FIFO_MASK) |
	    ((depth - 1) & 0xff) | ((threshold & 0xff) << 8));
	SaveVideoRegister(pVia, ALPHA_V3_PREFIFO_CONTROL,
	    (VIDInD(ALPHA_V3_PREFIFO_CONTROL) & ~V3_FIFO_MASK_3314) |
	    (prethreshold & 0xff));
    } else {
	SaveVideoRegister(pVia, ALPHA_V3_FIFO_CONTROL,
	    (VIDInD(ALPHA_V3_FIFO_CONTROL) & ALPHA_FIFO_MASK) |
	    ((depth - 1) & 0xff) | ((threshold & 0xff) << 8));
	SaveVideoRegister(pVia, ALPHA_V3_PREFIFO_CONTROL,
	    (VIDInD(ALPHA_V3_PREFIFO_CONTROL) & ~V3_FIFO_MASK) |
	    (prethreshold & 0x7f));
    }
}

static void
SetFIFO_64or32(VIAPtr pVia)
{
    /*=* Modify for C1 FIFO *=*/
    /* WARNING: not checking Chipset! */
    if (CLE266_REV_IS_CX(pVia->ChipRev))
	SetFIFO_V1(pVia, 64, 56, 56);
    else
	SetFIFO_V1(pVia, 32, 29, 16);
}

static void
SetFIFO_64or16(VIAPtr pVia)
{
    /*=* Modify for C1 FIFO *=*/
    /* WARNING: not checking Chipset! */
    if (CLE266_REV_IS_CX(pVia->ChipRev))
	SetFIFO_V1(pVia, 64, 56, 56);
    else
	SetFIFO_V1(pVia, 16, 12, 8);
}

static void
SetFIFO_64or48or32(VIAPtr pVia)
{
    /*=* Modify for C1 FIFO *=*/
    /* WARNING: not checking Chipset! */
    if (CLE266_REV_IS_CX(pVia->ChipRev))
	SetFIFO_V1(pVia, 64, 56, 56);
    else {
	if (pVia->swov.gdwUseExtendedFIFO)
	    SetFIFO_V1(pVia, 48, 40, 40);
	else
	    SetFIFO_V1(pVia, 32, 29, 16);
    }
}

static void
SetFIFO_V3_64or32or32(VIAPtr pVia)
{
    switch (pVia->ChipId) {
    case PCI_CHIP_VT3327:
    case PCI_CHIP_VT3336:
    case PCI_CHIP_VT3324:
    case PCI_CHIP_VT3364:
        SetFIFO_V3(pVia, 225, 200, 250);
        break;
    case PCI_CHIP_VT3204:
	SetFIFO_V3(pVia, 100, 89, 89);
	break;
    case PCI_CHIP_VT3314:
	SetFIFO_V3(pVia, 64, 61, 61);
	break;
    case PCI_CHIP_VT3205:
    case PCI_CHIP_VT3259:
	SetFIFO_V3(pVia, 32, 29, 29);
	break;
    case PCI_CHIP_CLE3122:
	if (CLE266_REV_IS_CX(pVia->ChipRev))
	    SetFIFO_V3(pVia, 64, 56, 56);
	else
	    SetFIFO_V3(pVia, 32, 16, 16);
	break;
    default:
	break;
    }
}

static void
SetFIFO_V3_64or32or16(VIAPtr pVia)
{
    switch (pVia->ChipId) {
    case PCI_CHIP_VT3327:
    case PCI_CHIP_VT3336:
    case PCI_CHIP_VT3324:
    case PCI_CHIP_VT3364:
        SetFIFO_V3(pVia, 225, 200, 250);
        break;
    case PCI_CHIP_VT3204:
	SetFIFO_V3(pVia, 100, 89, 89);
	break;
    case PCI_CHIP_VT3314:
	SetFIFO_V3(pVia, 64, 61, 61);
	break;
    case PCI_CHIP_VT3205:
    case PCI_CHIP_VT3259:
	SetFIFO_V3(pVia, 32, 29, 29);
	break;

    case PCI_CHIP_CLE3122:
	if (CLE266_REV_IS_CX(pVia->ChipRev))
	    SetFIFO_V3(pVia, 64, 56, 56);
	else
	    SetFIFO_V3(pVia, 16, 16, 8);
	break;

    default:
	break;
    }
}

static void
SetupFIFOs(VIAPtr pVia, unsigned long videoFlag, unsigned long miniCtl,
    unsigned long srcWidth)
{
    if (miniCtl & V1_Y_INTERPOLY) {
	if (pVia->swov.SrcFourCC == FOURCC_YV12 ||
	    pVia->swov.SrcFourCC == FOURCC_XVMC) {
	    if (videoFlag & VIDEO_HQV_INUSE) {
		if (videoFlag & VIDEO_1_INUSE)
		    SetFIFO_64or32(pVia);
		else
		    SetFIFO_V3_64or32or16(pVia);
	    } else {
		/* Minified video will be skewed without this workaround. */
		if (srcWidth <= 80) {  /* Fetch count <= 5 */
		    if (videoFlag & VIDEO_1_INUSE)
			SetFIFO_V1(pVia, 16, 0, 0);
		    else
			SetFIFO_V3(pVia, 16, 16, 0);
		} else {
		    if (videoFlag & VIDEO_1_INUSE)
			SetFIFO_64or16(pVia);
		    else
			SetFIFO_V3_64or32or16(pVia);
		}
	    }
	} else {
	    if (videoFlag & VIDEO_1_INUSE)
		SetFIFO_64or48or32(pVia);
	    else {
		/* Fix V3 bug. */
		if (srcWidth <= 8)
		    SetFIFO_V3(pVia, 1, 0, 0);
		else
		    SetFIFO_V3_64or32or32(pVia);
	    }
	}
    } else {
	if (pVia->swov.SrcFourCC == FOURCC_YV12 ||
	    pVia->swov.SrcFourCC == FOURCC_XVMC) {
	    if (videoFlag & VIDEO_HQV_INUSE) {
		if (videoFlag & VIDEO_1_INUSE)
		    SetFIFO_64or32(pVia);
		else
		    SetFIFO_V3_64or32or16(pVia);
	    } else {
		/* Minified video will be skewed without this workaround. */
		if (srcWidth <= 80) {  /* Fetch count <= 5 */
		    if (videoFlag & VIDEO_1_INUSE)
			SetFIFO_V1(pVia, 16, 0, 0);
		    else
			SetFIFO_V3(pVia, 16, 16, 0);
		} else {
		    if (videoFlag & VIDEO_1_INUSE)
			SetFIFO_64or16(pVia);
		    else
			SetFIFO_V3_64or32or16(pVia);
		}
	    }
	} else {
	    if (videoFlag & VIDEO_1_INUSE)
		SetFIFO_64or48or32(pVia);
	    else {
		/* Fix V3 bug. */
		if (srcWidth <= 8)
		    SetFIFO_V3(pVia, 1, 0, 0);
		else
		    SetFIFO_V3_64or32or32(pVia);
	    }
	}
    }
}

static CARD32
SetColorKey(VIAPtr pVia, unsigned long videoFlag,
    CARD32 keyLow, CARD32 keyHigh, CARD32 compose)
{
    keyLow &= 0x00FFFFFF;
    if (pVia->VideoEngine == VIDEO_ENGINE_CME)
	keyLow |= 0x40000000;

    /*SaveVideoRegister(pVia, V_COLOR_KEY, keyLow); */

    if (videoFlag & VIDEO_1_INUSE) {
	SaveVideoRegister(pVia, V_COLOR_KEY, keyLow);
    } else {
	if (pVia->HWDiff.dwSupportTwoColorKey)	/*CLE_C0 */
	    SaveVideoRegister(pVia, V3_COLOR_KEY, keyLow);
    }

    /*compose = (compose & ~0x0f) | SELECT_VIDEO_IF_COLOR_KEY; */
    /*CLE_C0 */
    compose =
	(compose & ~0x0f) | SELECT_VIDEO_IF_COLOR_KEY |
	SELECT_VIDEO3_IF_COLOR_KEY;
    /*compose = (compose & ~0x0f)  ; */

    return compose;
}

static CARD32
SetChromaKey(VIAPtr pVia, unsigned long videoFlag,
    CARD32 chromaLow, CARD32 chromaHigh, CARD32 miniCtl, CARD32 compose)
{
    chromaLow &= CHROMA_KEY_LOW;
    chromaHigh &= CHROMA_KEY_HIGH;

    chromaLow |= (VIDInD(V_CHROMAKEY_LOW) & ~CHROMA_KEY_LOW);
    chromaHigh |= (VIDInD(V_CHROMAKEY_HIGH) & ~CHROMA_KEY_HIGH);

    if (pVia->VideoEngine == VIDEO_ENGINE_CME)
	chromaLow |= 0x40000000;

    SaveVideoRegister(pVia, V_CHROMAKEY_HIGH, chromaHigh);
    if (videoFlag & VIDEO_1_INUSE) {
	SaveVideoRegister(pVia, V_CHROMAKEY_LOW, chromaLow & ~V_CHROMAKEY_V3);
	/* Temporarily solve the HW interpolation error when using Chroma key */
	SaveVideoRegister(pVia, V1_MINI_CONTROL, miniCtl & 0xFFFFFFF8);
    } else {
	SaveVideoRegister(pVia, V_CHROMAKEY_LOW, chromaLow | V_CHROMAKEY_V3);
	SaveVideoRegister(pVia, V3_MINI_CONTROL, miniCtl & 0xFFFFFFF8);
    }

    /* Modified by Scottie[2001.12.5] for select video if (Color key & Chroma key) */
    if (compose == SELECT_VIDEO_IF_COLOR_KEY)
	compose = SELECT_VIDEO_IF_COLOR_KEY | SELECT_VIDEO_IF_CHROMA_KEY;
    else
	compose = (compose & ~0x0f) | SELECT_VIDEO_IF_CHROMA_KEY;

    return compose;
}

static void
SetVideoStart(VIAPtr pVia, unsigned long videoFlag,
    unsigned int numbufs, CARD32 a1, CARD32 a2, CARD32 a3)
{
    CARD32 V1Addr[3] = { V1_STARTADDR_0, V1_STARTADDR_1, V1_STARTADDR_2 };
    CARD32 V3Addr[3] = { V3_STARTADDR_0, V3_STARTADDR_1, V3_STARTADDR_2 };
    CARD32 *VideoAddr = (videoFlag & VIDEO_1_INUSE) ? V1Addr : V3Addr;

    SaveVideoRegister(pVia, VideoAddr[0], a1);
    if (numbufs > 1)
	SaveVideoRegister(pVia, VideoAddr[1], a2);
    if (numbufs > 2)
	SaveVideoRegister(pVia, VideoAddr[2], a3);
}

static void
SetHQVFetch(VIAPtr pVia, CARD32 srcFetch, unsigned long srcHeight)
{
    unsigned long proReg = 0;

    if (pVia->ChipId == PCI_CHIP_VT3259 && !(pVia->swov.gdwVideoFlagSW & VIDEO_1_INUSE))
	proReg = PRO_HQV1_OFFSET;

    if (!pVia->HWDiff.dwHQVFetchByteUnit) {	/* CLE_C0 */
	srcFetch >>= 3;		       /* fetch unit is 8-byte */
    }

    SaveVideoRegister(pVia, HQV_SRC_FETCH_LINE + proReg,
	((srcFetch - 1) << 16) | (srcHeight - 1));
}

static void
SetFetch(VIAPtr pVia, unsigned long videoFlag, CARD32 fetch)
{
    fetch <<= 20;
    if (videoFlag & VIDEO_1_INUSE) {
	SaveVideoRegister(pVia, V12_QWORD_PER_LINE, fetch);
    } else {
	fetch |= VIDInD(V3_ALPHA_QWORD_PER_LINE) & ~V3_FETCH_COUNT;
	SaveVideoRegister(pVia, V3_ALPHA_QWORD_PER_LINE, fetch);
    }
}

static void
SetDisplayCount(VIAPtr pVia, unsigned long videoFlag,
    unsigned long srcWidth, unsigned long srcHeight)
{
    unsigned long DisplayCount;

    /* Removed VIA's large pixelformat switch/case.
     * All formats (YV12, UYVY, YUY2, VIA, RGB16 and RGB32)
     * seem to use the same count. /A
     */

    if (videoFlag & VIDEO_HQV_INUSE)
	DisplayCount = srcWidth - 1;
    else
	DisplayCount = srcWidth - pVia->swov.overlayRecordV1.dwminifyH;

    if (videoFlag & VIDEO_1_INUSE)
	SaveVideoRegister(pVia, V1_SOURCE_HEIGHT,
	    (srcHeight << 16) | DisplayCount);
    else
	SaveVideoRegister(pVia, V3_SOURCE_WIDTH, DisplayCount);
}

static void
SetMiniAndZoom(VIAPtr pVia, unsigned long videoFlag,
    CARD32 miniCtl, CARD32 zoomCtl)
{
    if (videoFlag & VIDEO_1_INUSE) {
	SaveVideoRegister(pVia, V1_MINI_CONTROL, miniCtl);
	SaveVideoRegister(pVia, V1_ZOOM_CONTROL, zoomCtl);
    } else {
	SaveVideoRegister(pVia, V3_MINI_CONTROL, miniCtl);
	SaveVideoRegister(pVia, V3_ZOOM_CONTROL, zoomCtl);
    }
}

static void
SetVideoControl(VIAPtr pVia, unsigned long videoFlag, CARD32 vidCtl)
{
    if (videoFlag & VIDEO_1_INUSE)
	SaveVideoRegister(pVia, V1_CONTROL, vidCtl);
    else
	SaveVideoRegister(pVia, V3_CONTROL, vidCtl);
}

static void
FireVideoCommand(VIAPtr pVia, unsigned long videoFlag, CARD32 compose)
{
    if (videoFlag & VIDEO_1_INUSE)
	SaveVideoRegister(pVia, V_COMPOSE_MODE, compose | V1_COMMAND_FIRE);
    else
	SaveVideoRegister(pVia, V_COMPOSE_MODE, compose | V3_COMMAND_FIRE);
}

static void
SetVideoWindow(ScrnInfoPtr pScrn, unsigned long videoFlag,
    LPDDUPDATEOVERLAY pUpdate)
{
    VIAPtr pVia = VIAPTR(pScrn);
    VIABIOSInfoPtr pBIOSInfo = pVia->pBIOSInfo;
    CARD32 left = pUpdate->DstLeft;
    CARD32 top = pUpdate->DstTop;
    CARD32 right = pUpdate->DstRight - 1;
    CARD32 bottom = pUpdate->DstBottom - 1;

    DBG_DD(ErrorF("SetVideoWindow: X (%ld,%ld) Y (%ld,%ld)\n",
	    left, right, top, bottom));

    /* Modify for HW DVI limitation.
     * When we enable both the CRT and DVI, then change resolution.
     * If the resolution is smaller than the panel's physical size,
     * the video display in Y direction will be cut.
     * So, we need to adjust the Y top and bottom position.
     */
    if (videoFlag & VIDEO_1_INUSE) {
	if (pBIOSInfo->SetDVI && pBIOSInfo->scaleY) {
	    top =
		pUpdate->DstTop * pBIOSInfo->panelY /
		pScrn->currentMode->VDisplay;
	    bottom =
		pUpdate->DstBottom * pBIOSInfo->panelY /
		pScrn->currentMode->VDisplay;
	}
    }

    if (top < 0)
	top = 0;
    else if (top > 2047)
	top = 2047;

    if (bottom < 0)
	bottom = 0;
    else if (bottom > 2047)
	bottom = 2047;

    if (left < 0)
	left = 0;
    else if (left > 2047)
	left = 2047;

    if (right < 0)
	right = 0;
    else if (right > 2047)
	right = 2047;

    if (videoFlag & VIDEO_1_INUSE) {
	SaveVideoRegister(pVia, V1_WIN_END_Y, (right << 16) | bottom);
	SaveVideoRegister(pVia, V1_WIN_START_Y, (left << 16) | top);
    } else {
	SaveVideoRegister(pVia, V3_WIN_END_Y, (right << 16) | bottom);
	SaveVideoRegister(pVia, V3_WIN_START_Y, (left << 16) | top);
    }
}

/*
 * Upd_Video()
 */
static Bool
Upd_Video(ScrnInfoPtr pScrn, unsigned long videoFlag,
    unsigned long startAddr, LPDDUPDATEOVERLAY pUpdate,
    unsigned long srcPitch,
    unsigned long oriSrcWidth, unsigned long oriSrcHeight,
    unsigned long deinterlaceMode,
    unsigned long haveColorKey, unsigned long haveChromaKey,
    unsigned long colorKeyLow, unsigned long colorKeyHigh,
    unsigned long chromaKeyLow, unsigned long chromaKeyHigh)
{
    VIAPtr pVia = VIAPTR(pScrn);
    vgaHWPtr hwp = VGAHWPTR(pScrn);
    VIAHWDiff *hwDiff = &pVia->HWDiff;

    int i;
    unsigned long vidCtl = 0, compose;
    unsigned long srcWidth, srcHeight, dstWidth, dstHeight;
    unsigned long zoomCtl = 0, miniCtl = 0;
    unsigned long hqvCtl = 0;
    unsigned long hqvFilterCtl = 0, hqvMiniCtl = 0;
    unsigned long haveHQVzoomH = 0, haveHQVzoomV = 0;
    unsigned long hqvSrcWidth = 0, hqvDstWidth = 0;
    unsigned long hqvSrcFetch = 0, hqvOffset = 0;
    unsigned long dwOffset = 0, fetch = 0, tmp = 0;
    unsigned long proReg = 0;

    DBG_DD(ErrorF("videoflag=%p\n",videoFlag));

    if (pVia->ChipId == PCI_CHIP_VT3259 && !(videoFlag & VIDEO_1_INUSE))
	proReg = PRO_HQV1_OFFSET;

    compose = (VIDInD(V_COMPOSE_MODE) &
	~(SELECT_VIDEO_IF_COLOR_KEY | V1_COMMAND_FIRE | V3_COMMAND_FIRE)) |
	V_COMMAND_LOAD_VBI;

    DBG_DD(ErrorF("// Upd_Video:\n"));
    DBG_DD(ErrorF("Modified rSrc  X (%ld,%ld) Y (%ld,%ld)\n",
	    pUpdate->SrcLeft, pUpdate->SrcRight,
	    pUpdate->SrcTop, pUpdate->SrcBottom));
    DBG_DD(ErrorF("Modified rDest  X (%ld,%ld) Y (%ld,%ld)\n",
	    pUpdate->DstLeft, pUpdate->DstRight,
	    pUpdate->DstTop, pUpdate->DstBottom));

    pVia->swov.overlayRecordV1.dwWidth = dstWidth =
	pUpdate->DstRight - pUpdate->DstLeft;
    pVia->swov.overlayRecordV1.dwHeight = dstHeight =
	pUpdate->DstBottom - pUpdate->DstTop;
    srcWidth = (unsigned long)pUpdate->SrcRight - pUpdate->SrcLeft;
    srcHeight = (unsigned long)pUpdate->SrcBottom - pUpdate->SrcTop;
    DBG_DD(ErrorF("===srcWidth= %ld \n", srcWidth));
    DBG_DD(ErrorF("===srcHeight= %ld \n", srcHeight));

    vidCtl = ViaSetVidCtl(pVia, videoFlag);

    if(hwDiff->dwNeedV1Prefetch) {
        DBG_DD(ErrorF("NEEDV1PREFETCH\n"));
        vidCtl |= V1_PREFETCH_ON_3336;
    }
    
    /* 
     * FIXME:
     * Enable video on secondary 
     */
    if (pVia->Chipset == VIA_P4M900 &&
        pVia->pBIOSInfo->PanelActive) {
        /* V1_ON_SND_DISPLAY */ 
	vidCtl |= 0x80000000;
        /* SECOND_DISPLAY_COLOR_KEY_ENABLE */
        compose |= 0x00010000 | 0x1 ;
    }

    viaOverlayGetV1V3Format(pVia, (videoFlag & VIDEO_1_INUSE) ? 1 : 3,
	videoFlag, &vidCtl, &hqvCtl);

    if (hwDiff->dwThreeHQVBuffer) {    /* CLE_C0: HQV supports triple-buffering */
	hqvCtl &= ~HQV_SW_FLIP;
	hqvCtl |= HQV_TRIPLE_BUFF | HQV_FLIP_STATUS;
    }

    /* Starting address of source and Source offset */
    dwOffset =
	viaOverlayGetSrcStartAddress(pVia, videoFlag, pUpdate, srcPitch,
	&hqvOffset);
    DBG_DD(ErrorF("===dwOffset= 0x%lx \n", dwOffset));

    pVia->swov.overlayRecordV1.dwOffset = dwOffset;

    if (pVia->swov.SrcFourCC == FOURCC_YV12 ||
	pVia->swov.SrcFourCC == FOURCC_XVMC) {
	YCBCRREC YCbCr;

	if (videoFlag & VIDEO_HQV_INUSE) {
	    SetVideoStart(pVia, videoFlag, hwDiff->dwThreeHQVBuffer ? 3 : 2,
		pVia->swov.overlayRecordV1.dwHQVAddr[0] + dwOffset,
		pVia->swov.overlayRecordV1.dwHQVAddr[1] + dwOffset,
		pVia->swov.overlayRecordV1.dwHQVAddr[2] + dwOffset);

	    if (pVia->swov.SrcFourCC != FOURCC_XVMC) {
		YCbCr = viaOverlayGetYCbCrStartAddress(videoFlag, startAddr,
		    pVia->swov.overlayRecordV1.dwOffset,
		    pVia->swov.overlayRecordV1.dwUVoffset,
		    srcPitch, oriSrcHeight);
		if (pVia->VideoEngine == VIDEO_ENGINE_CME) {
		    SaveVideoRegister(pVia, HQV_SRC_STARTADDR_Y + proReg,
			YCbCr.dwY);
		    SaveVideoRegister(pVia, HQV_SRC_STARTADDR_U + proReg,
			YCbCr.dwCB);
		} else {
		    SaveVideoRegister(pVia, HQV_SRC_STARTADDR_Y, YCbCr.dwY);
		    SaveVideoRegister(pVia, HQV_SRC_STARTADDR_U, YCbCr.dwCR);
		    SaveVideoRegister(pVia, HQV_SRC_STARTADDR_V, YCbCr.dwCB);
		}
	    }
	} else {
	    YCbCr = viaOverlayGetYCbCrStartAddress(videoFlag, startAddr,
		pVia->swov.overlayRecordV1.dwOffset,
		pVia->swov.overlayRecordV1.dwUVoffset,
		srcPitch, oriSrcHeight);

	    if (videoFlag & VIDEO_1_INUSE) {
		SaveVideoRegister(pVia, V1_STARTADDR_0, YCbCr.dwY);
		SaveVideoRegister(pVia, V1_STARTADDR_CB0, YCbCr.dwCR);
		SaveVideoRegister(pVia, V1_STARTADDR_CR0, YCbCr.dwCB);
	    } else
		DBG_DD(ErrorF
		    ("Upd_Video() : We do not support YV12 with V3!\n"));
	}
    } else {
	if (videoFlag & VIDEO_HQV_INUSE) {
	    hqvSrcWidth = (unsigned long)pUpdate->SrcRight - pUpdate->SrcLeft;
	    hqvDstWidth = (unsigned long)pUpdate->DstRight - pUpdate->DstLeft;

	    if (hqvSrcWidth > hqvDstWidth)
		dwOffset = dwOffset * hqvDstWidth / hqvSrcWidth;

	    SetVideoStart(pVia, videoFlag, hwDiff->dwThreeHQVBuffer ? 3 : 2,
		pVia->swov.overlayRecordV1.dwHQVAddr[0] + hqvOffset,
		pVia->swov.overlayRecordV1.dwHQVAddr[1] + hqvOffset,
		pVia->swov.overlayRecordV1.dwHQVAddr[2] + hqvOffset);

	    if (pVia->VideoEngine == VIDEO_ENGINE_CME)
		SaveVideoRegister(pVia, 0x1cc + proReg, dwOffset);
	    SaveVideoRegister(pVia, HQV_SRC_STARTADDR_Y + proReg, startAddr);
	} else {
	    startAddr += dwOffset;
	    SetVideoStart(pVia, videoFlag, 1, startAddr, 0, 0);
	}
    }

    fetch = viaOverlayGetFetch(pVia, videoFlag,
	srcWidth, dstWidth, oriSrcWidth, &hqvSrcFetch);
    DBG_DD(ErrorF("===fetch= 0x%lx\n", fetch));

#if 0
    /* For DCT450 test-BOB INTERLEAVE */
    if ((deinterlaceMode & DDOVER_INTERLEAVED)
	&& (deinterlaceMode & DDOVER_BOB)) {
	if (videoFlag & VIDEO_HQV_INUSE)
	    hqvCtl |= HQV_FIELD_2_FRAME | HQV_FRAME_2_FIELD | HQV_DEINTERLACE;
	else
	    vidCtl |= V1_BOB_ENABLE | V1_FRAME_BASE;
    } else if (deinterlaceMode & DDOVER_BOB) {
	if (videoFlag & VIDEO_HQV_INUSE)
	    /* The HQV source data line count should be two times of the original line count */
	    hqvCtl |= HQV_FIELD_2_FRAME | HQV_DEINTERLACE;
	else
	    vidCtl |= V1_BOB_ENABLE;
    }
#endif

    if (videoFlag & VIDEO_HQV_INUSE) {
	if (!(deinterlaceMode & DDOVER_INTERLEAVED)
	    && (deinterlaceMode & DDOVER_BOB))
	    SetHQVFetch(pVia, hqvSrcFetch, oriSrcHeight << 1);
	else
	    SetHQVFetch(pVia, hqvSrcFetch, oriSrcHeight);

	if (pVia->swov.SrcFourCC == FOURCC_YV12 ||
	    pVia->swov.SrcFourCC == FOURCC_XVMC) {
	    if (videoFlag & VIDEO_1_INUSE)
		SaveVideoRegister(pVia, V1_STRIDE, srcPitch << 1);
	    else
		SaveVideoRegister(pVia, V3_STRIDE, srcPitch << 1);

	    if (pVia->HWDiff.dwHQVFetchByteUnit)
		SaveVideoRegister(pVia, HQV_SRC_STRIDE + proReg,
		    ((srcPitch >> 1) << 16) | srcPitch | HQV_FIFO_DEPTH_1);
	    else
		SaveVideoRegister(pVia, HQV_SRC_STRIDE + proReg,
		    ((srcPitch >> 1) << 16) | srcPitch);

	    SaveVideoRegister(pVia, HQV_DST_STRIDE + proReg, (srcPitch << 1));
	} else {
	    if (videoFlag & VIDEO_1_INUSE)
		SaveVideoRegister(pVia, V1_STRIDE, srcPitch);
	    else
		SaveVideoRegister(pVia, V3_STRIDE, srcPitch);

	    SaveVideoRegister(pVia, HQV_SRC_STRIDE + proReg, srcPitch);
	    SaveVideoRegister(pVia, HQV_DST_STRIDE + proReg, srcPitch);
	}

    } else {
	if (videoFlag & VIDEO_1_INUSE)
	    SaveVideoRegister(pVia, V1_STRIDE, srcPitch | (srcPitch << 15));
	else
	    SaveVideoRegister(pVia, V3_STRIDE, srcPitch | (srcPitch << 15));
    }

    /* Set destination window */
    SetVideoWindow(pScrn, videoFlag, pUpdate);

    compose |= ALWAYS_SELECT_VIDEO;

    /* Set up X zoom factor */

    pVia->swov.overlayRecordV1.dwFetchAlignment = 0;

    if (!viaOverlayHQVCalcZoomWidth(pVia, videoFlag, srcWidth, dstWidth,
	    &zoomCtl, &miniCtl, &hqvFilterCtl, &hqvMiniCtl, &haveHQVzoomH)) {
	/* Need to scale (minify) too much - can't handle it. */
	SetFetch(pVia, videoFlag, fetch);
	FireVideoCommand(pVia, videoFlag, compose);
	FlushVidRegBuffer(pVia);
	return FALSE;
    }

    SetFetch(pVia, videoFlag, fetch);

    /* Set up Y zoom factor */

    /* For DCT450 test-BOB INTERLEAVE */
    if ((deinterlaceMode & DDOVER_INTERLEAVED)
	&& (deinterlaceMode & DDOVER_BOB)) {
	if (!(videoFlag & VIDEO_HQV_INUSE)) {
	    srcHeight /= 2;
	    if (videoFlag & VIDEO_1_INUSE)
		vidCtl |= V1_BOB_ENABLE | V1_FRAME_BASE;
	    else
		vidCtl |= V3_BOB_ENABLE | V3_FRAME_BASE;
	} else
	    hqvCtl |= HQV_FIELD_2_FRAME | HQV_FRAME_2_FIELD | HQV_DEINTERLACE;
    } else if (deinterlaceMode & DDOVER_BOB) {
	if (videoFlag & VIDEO_HQV_INUSE) {
	    srcHeight <<= 1;
	    hqvCtl |= HQV_FIELD_2_FRAME | HQV_DEINTERLACE;
	} else {
	    if (videoFlag & VIDEO_1_INUSE)
		vidCtl |= V1_BOB_ENABLE;
	    else
		vidCtl |= V3_BOB_ENABLE;
	}
    }

    SetDisplayCount(pVia, videoFlag, srcWidth, srcHeight);

    if (!viaOverlayHQVCalcZoomHeight(pVia, srcHeight, dstHeight, &zoomCtl,
	    &miniCtl, &hqvFilterCtl, &hqvMiniCtl, &haveHQVzoomV)) {
	/* Need to scale (minify) too much - can't handle it. */
	FireVideoCommand(pVia, videoFlag, compose);
	FlushVidRegBuffer(pVia);
	return FALSE;
    }

    SetupFIFOs(pVia, videoFlag, miniCtl, srcWidth);

    if (videoFlag & VIDEO_HQV_INUSE) {
	miniCtl = 0;

	if (haveHQVzoomH || haveHQVzoomV) {
	    tmp = 0;

	    if (haveHQVzoomH) {
		miniCtl = V1_X_INTERPOLY;
		/* Disable X interpolation if the height exceeds 
		 * the maximum supported by the hardware */
                if (srcHeight >= pVia->swov.maxHInterp)
                    miniCtl &= ~V1_X_INTERPOLY;
		tmp = zoomCtl & 0xffff0000;
	    }

	    if (haveHQVzoomV) {
		miniCtl |= V1_Y_INTERPOLY | V1_YCBCR_INTERPOLY;
		/* Disable Y interpolation if the width exceeds 
		 * the maximum supported by the hardware */
                if (srcWidth >= pVia->swov.maxWInterp)
                    miniCtl &= ~V1_Y_INTERPOLY;
		tmp |= zoomCtl & 0x0000ffff;
		hqvFilterCtl &= 0xfffdffff;
	    }

	    /* Temporary fix for 2D bandwidth problem. 2002/08/01 */
	    if (pVia->swov.gdwUseExtendedFIFO)
		miniCtl &= ~V1_Y_INTERPOLY;

	    SetMiniAndZoom(pVia, videoFlag, miniCtl, tmp);
	} else {
	    if (srcHeight == dstHeight)
		hqvFilterCtl &= 0xfffdffff;

	    SetMiniAndZoom(pVia, videoFlag, 0, 0);
	}
	SaveVideoRegister(pVia, HQV_MINIFY_CONTROL + proReg, hqvMiniCtl);
	SaveVideoRegister(pVia, HQV_FILTER_CONTROL + proReg, hqvFilterCtl);
    } else
	SetMiniAndZoom(pVia, videoFlag, miniCtl, zoomCtl);

    if (haveColorKey)
	compose =
	    SetColorKey(pVia, videoFlag, colorKeyLow, colorKeyHigh, compose);

    if (haveChromaKey)
	compose = SetChromaKey(pVia, videoFlag, chromaKeyLow, chromaKeyHigh,
	    miniCtl, compose);

    /* Set up video control */
    if (videoFlag & VIDEO_HQV_INUSE) {
	if (!pVia->swov.SWVideo_ON) {
	    DBG_DD(ErrorF("    First HQV\n"));

	    FlushVidRegBuffer(pVia);

	    DBG_DD(ErrorF(" Wait flips"));

	    if (hwDiff->dwHQVInitPatch) {
		DBG_DD(ErrorF(" Initializing HQV twice ..."));
		for (i = 0; i < 2; i++) {
		    viaWaitHQVFlipClear(pVia,
			((hqvCtl & ~HQV_SW_FLIP) | HQV_FLIP_STATUS) &
			~HQV_ENABLE);
		    VIDOutD(HQV_CONTROL + proReg, hqvCtl);
		    viaWaitHQVFlip(pVia);
		}
		DBG_DD(ErrorF(" done.\n"));
	    } else {		       /* CLE_C0 */
		CARD32 volatile *HQVCtrl =
		    (CARD32 volatile *)(pVia->VidMapBase + HQV_CONTROL +
		    proReg);

		/* Check that HQV is idle */
		DBG_DD(ErrorF("HQV control wf - %08lx\n", *HQVCtrl));
		while (!(*HQVCtrl & HQV_IDLE)) {
		    DBG_DD(ErrorF("HQV control busy - %08lx\n", *HQVCtrl));
		    usleep(1);
		}

		if (pVia->VideoEngine == VIDEO_ENGINE_CME)
		    hqvCtl |= HQV_GEN_IRQ;

		VIDOutD(HQV_CONTROL + proReg, hqvCtl & ~HQV_SW_FLIP);
		VIDOutD(HQV_CONTROL + proReg, hqvCtl | HQV_SW_FLIP);

		DBG_DD(ErrorF("HQV control wf5 - %08lx\n", *HQVCtrl));
		DBG_DD(ErrorF(" Wait flips5"));

		if (pVia->VideoEngine != VIDEO_ENGINE_CME) {
		    for (i = 0; (i < 50) && !(*HQVCtrl & HQV_FLIP_STATUS);
			i++) {
			DBG_DD(ErrorF(" HQV wait %d %08lx\n", i, *HQVCtrl));
			*HQVCtrl |= HQV_SW_FLIP | HQV_FLIP_STATUS;
			usleep(1);
		    }
		} else {
		    viaWaitHQVFlip(pVia);
		}

		DBG_DD(ErrorF(" Wait flips6"));
	    }

	    if (videoFlag & VIDEO_1_INUSE) {
		VIDOutD(V1_CONTROL, vidCtl);
		VIDOutD(V_COMPOSE_MODE, compose | V1_COMMAND_FIRE);
		if (pVia->swov.gdwUseExtendedFIFO) {
		    /* Set Display FIFO */
		    DBG_DD(ErrorF(" Wait flips7"));
		    viaWaitVBI(pVia);
		    DBG_DD(ErrorF(" Wait flips 8"));
		    hwp->writeSeq(hwp, 0x17, 0x2F);
		    ViaSeqMask(hwp, 0x16, 0x14, 0x1F);
		    hwp->writeSeq(hwp, 0x18, 0x56);
		    DBG_DD(ErrorF(" Wait flips 9"));
		}
	    } else {
		DBG_DD(ErrorF(" Wait flips 10"));
		VIDOutD(V3_CONTROL, vidCtl);
		VIDOutD(V_COMPOSE_MODE, compose | V3_COMMAND_FIRE);
	    }
	    DBG_DD(ErrorF(" Done flips"));
	} else {
	    DBG_DD(ErrorF("    Normal called\n"));
	    SaveVideoRegister(pVia, HQV_CONTROL + proReg,
		hqvCtl | HQV_FLIP_STATUS);
	    SetVideoControl(pVia, videoFlag, vidCtl);
	    FireVideoCommand(pVia, videoFlag, compose);
	    viaWaitHQVDone(pVia);
	    FlushVidRegBuffer(pVia);
	}
    } else {
	SetVideoControl(pVia, videoFlag, vidCtl);
	FireVideoCommand(pVia, videoFlag, compose);
	viaWaitHQVDone(pVia);
	FlushVidRegBuffer(pVia);
    }
    pVia->swov.SWVideo_ON = TRUE;

    DBG_DD(ErrorF(" Done Upd_Video"));

    return TRUE;

}					/* Upd_Video */

/*
 *  VIAVidUpdateOverlay()
 *  Parameters:   src rectangle, dst rectangle, colorkey...
 *  Return value: unsigned long of state
 *  Note: updates the overlay image parameter.
 */
Bool
VIAVidUpdateOverlay(ScrnInfoPtr pScrn, LPDDUPDATEOVERLAY pUpdate)
{
    VIAPtr pVia = VIAPTR(pScrn);
    OVERLAYRECORD *ovlV1 = &pVia->swov.overlayRecordV1;

    unsigned long flags = pUpdate->dwFlags;
    unsigned long videoFlag = 0;
    unsigned long startAddr = 0;
    unsigned long deinterlaceMode = 0;

    unsigned long haveColorKey = 0, haveChromaKey = 0;
    unsigned long colorKeyLow = 0, colorKeyHigh = 0;
    unsigned long chromaKeyLow = 0, chromaKeyHigh = 0;

    unsigned long scrnWidth, scrnHeight;
    int dstTop, dstBottom, dstLeft, dstRight;
    int panDX, panDY;		       /* Panning delta */

    unsigned long proReg = 0;

    panDX = pVia->swov.panning_x;
    panDY = pVia->swov.panning_y;
    pVia->swov.oldPanningX = pVia->swov.panning_x;
    pVia->swov.oldPanningY = pVia->swov.panning_y;

    pUpdate->DstLeft -= panDX;
    pUpdate->DstTop -= panDY;
    pUpdate->DstRight -= panDX;
    pUpdate->DstBottom -= panDY;

    DBG_DD(ErrorF("Raw rSrc  X (%ld,%ld) Y (%ld,%ld)\n",
	    pUpdate->SrcLeft, pUpdate->SrcRight,
	    pUpdate->SrcTop, pUpdate->SrcBottom));
    DBG_DD(ErrorF("Raw rDest  X (%ld,%ld) Y (%ld,%ld)\n",
	    pUpdate->DstLeft, pUpdate->DstRight,
	    pUpdate->DstTop, pUpdate->DstBottom));

    if ((pVia->swov.SrcFourCC == FOURCC_YUY2) ||
	(pVia->swov.SrcFourCC == FOURCC_RV15) ||
	(pVia->swov.SrcFourCC == FOURCC_RV16) ||
	(pVia->swov.SrcFourCC == FOURCC_RV32) ||
	(pVia->swov.SrcFourCC == FOURCC_YV12) ||
	(pVia->swov.SrcFourCC == FOURCC_XVMC)) {
	videoFlag = pVia->swov.gdwVideoFlagSW;
    }

    if (pVia->ChipId == PCI_CHIP_VT3259 && !(videoFlag & VIDEO_1_INUSE))
	proReg = PRO_HQV1_OFFSET;

    flags |= DDOVER_INTERLEAVED;

    /* Disable destination color keying if the alpha window is in use. */
    if (pVia->swov.gdwAlphaEnabled)
	flags &= ~DDOVER_KEYDEST;

    ResetVidRegBuffer(pVia);

    /* For SW decode HW overlay use */
    startAddr = VIDInD(HQV_SRC_STARTADDR_Y + proReg);

    if (flags & DDOVER_KEYDEST) {
	haveColorKey = 1;
	colorKeyLow = pUpdate->dwColorSpaceLowValue;
    }

    if (flags & DDOVER_INTERLEAVED)
	deinterlaceMode |= DDOVER_INTERLEAVED;

    if (flags & DDOVER_BOB)
	deinterlaceMode |= DDOVER_BOB;

    if ((pVia->ChipId == PCI_CHIP_CLE3122)
	&& (pScrn->currentMode->HDisplay > 1024)) {
	DBG_DD(ErrorF("UseExtendedFIFO\n"));
	pVia->swov.gdwUseExtendedFIFO = 1;
    } else
	pVia->swov.gdwUseExtendedFIFO = 0;

    /* Figure out actual rSrc rectangle */

    dstLeft = pUpdate->DstLeft;
    dstTop = pUpdate->DstTop;
    dstRight = pUpdate->DstRight;
    dstBottom = pUpdate->DstBottom;

    scrnWidth = pScrn->currentMode->HDisplay;
    scrnHeight = pScrn->currentMode->VDisplay;

    if (dstLeft < 0) {
	pUpdate->SrcLeft = (((-dstLeft) * ovlV1->dwV1OriWidth) +
	    ((dstRight - dstLeft) >> 1)) / (dstRight - dstLeft);
    }
    if (dstRight > scrnWidth) {
	pUpdate->SrcRight = (((scrnWidth - dstLeft) * ovlV1->dwV1OriWidth) +
	    ((dstRight - dstLeft) >> 1)) / (dstRight - dstLeft);
    }
    if (dstTop < 0) {
	pUpdate->SrcTop = (((-dstTop) * ovlV1->dwV1OriHeight) +
	    ((dstBottom - dstTop) >> 1)) / (dstBottom - dstTop);
    }
    if (dstBottom > scrnHeight) {
	pUpdate->SrcBottom = (((scrnHeight - dstTop) * ovlV1->dwV1OriHeight) +
	    ((dstBottom - dstTop) >> 1)) / (dstBottom - dstTop);
    }

    /* Save modified src & original dest rectangle parameters */

    if ((pVia->swov.SrcFourCC == FOURCC_YUY2) ||
	(pVia->swov.SrcFourCC == FOURCC_RV15) ||
	(pVia->swov.SrcFourCC == FOURCC_RV16) ||
	(pVia->swov.SrcFourCC == FOURCC_RV32) ||
	(pVia->swov.SrcFourCC == FOURCC_YV12) ||
	(pVia->swov.SrcFourCC == FOURCC_XVMC)) {
	pVia->swov.SWDevice.gdwSWDstLeft = pUpdate->DstLeft + panDX;
	pVia->swov.SWDevice.gdwSWDstTop = pUpdate->DstTop + panDY;
	pVia->swov.SWDevice.gdwSWDstWidth =
	    pUpdate->DstRight - pUpdate->DstLeft;
	pVia->swov.SWDevice.gdwSWDstHeight =
	    pUpdate->DstBottom - pUpdate->DstTop;

	pVia->swov.SWDevice.gdwSWSrcWidth =
	    ovlV1->dwV1SrcWidth = pUpdate->SrcRight - pUpdate->SrcLeft;
	pVia->swov.SWDevice.gdwSWSrcHeight =
	    ovlV1->dwV1SrcHeight = pUpdate->SrcBottom - pUpdate->SrcTop;
    }

    ovlV1->dwV1SrcLeft = pUpdate->SrcLeft;
    ovlV1->dwV1SrcRight = pUpdate->SrcRight;
    ovlV1->dwV1SrcTop = pUpdate->SrcTop;
    ovlV1->dwV1SrcBot = pUpdate->SrcBottom;

    /* Figure out actual rDest rectangle */

    pUpdate->DstLeft = (dstLeft < 0) ? 0 : dstLeft;
    pUpdate->DstTop = (dstTop < 0) ? 0 : dstTop;
    if (pUpdate->DstTop >= scrnHeight)
	pUpdate->DstTop = scrnHeight - 1;
    pUpdate->DstRight = (dstRight > scrnWidth) ? scrnWidth : dstRight;
    pUpdate->DstBottom = (dstBottom > scrnHeight) ? scrnHeight : dstBottom;

    /* Update the overlay */

    if (!Upd_Video(pScrn, videoFlag, startAddr, pUpdate,
	    pVia->swov.SWDevice.dwPitch, ovlV1->dwV1OriWidth,
	    ovlV1->dwV1OriHeight, deinterlaceMode, haveColorKey,
	    haveChromaKey, colorKeyLow, colorKeyHigh, chromaKeyLow,
	    chromaKeyHigh))
	return FALSE;

    pVia->swov.SWVideo_ON = FALSE;

    return TRUE;

}					/* VIAVidUpdateOverlay */

/*
 *
 */
void
ViaOverlayHide(ScrnInfoPtr pScrn)
{
    VIAPtr pVia = VIAPTR(pScrn);
    vgaHWPtr hwp = VGAHWPTR(pScrn);
    CARD32 videoFlag = 0;
    unsigned long proReg = 0;

    if ((pVia->swov.SrcFourCC == FOURCC_YUY2) ||
	(pVia->swov.SrcFourCC == FOURCC_RV15) ||
	(pVia->swov.SrcFourCC == FOURCC_RV16) ||
	(pVia->swov.SrcFourCC == FOURCC_RV32) ||
	(pVia->swov.SrcFourCC == FOURCC_YV12) ||
	(pVia->swov.SrcFourCC == FOURCC_XVMC))
	videoFlag = pVia->swov.gdwVideoFlagSW;

    if (pVia->ChipId == PCI_CHIP_VT3259 && !(videoFlag & VIDEO_1_INUSE))
	proReg = PRO_HQV1_OFFSET;

    ResetVidRegBuffer(pVia);

    if (pVia->HWDiff.dwHQVDisablePatch)
	ViaSeqMask(hwp, 0x2E, 0x00, 0x10);

    SaveVideoRegister(pVia, V_FIFO_CONTROL, V1_FIFO_PRETHRESHOLD12 |
	V1_FIFO_THRESHOLD8 | V1_FIFO_DEPTH16);
    SaveVideoRegister(pVia, ALPHA_V3_FIFO_CONTROL, ALPHA_FIFO_THRESHOLD4
	| ALPHA_FIFO_DEPTH8 | V3_FIFO_THRESHOLD24 | V3_FIFO_DEPTH32);

    if (videoFlag & VIDEO_HQV_INUSE)
	SaveVideoRegister(pVia, HQV_CONTROL + proReg,
	    VIDInD(HQV_CONTROL + proReg) & ~HQV_ENABLE);

    if (videoFlag & VIDEO_1_INUSE)
	SaveVideoRegister(pVia, V1_CONTROL, VIDInD(V1_CONTROL) & ~V1_ENABLE);
    else
	SaveVideoRegister(pVia, V3_CONTROL, VIDInD(V3_CONTROL) & ~V3_ENABLE);

    FireVideoCommand(pVia, videoFlag, VIDInD(V_COMPOSE_MODE));
    FlushVidRegBuffer(pVia);

    if (pVia->HWDiff.dwHQVDisablePatch)
	ViaSeqMask(hwp, 0x2E, 0x10, 0x10);

    pVia->swov.SWVideo_ON = FALSE;
    pVia->VideoStatus &= ~VIDEO_SWOV_ON;
}