case KSPROPERTY_VPCONFIG_DECIMATIONCAPABILITY :
            *(PBOOL)(pSpd->PropertyInfo) = TRUE;
            ActualBytesTransferred = sizeof(BOOL);
            break;

        default:
            TRAP();
            ActualBytesTransferred = 0;
            break;
    }
	return ActualBytesTransferred;
}       

ULONG Device::GetVideoPortVBIProperty(PSTREAM_PROPERTY_DESCRIPTOR pSpd)
{
    ULONG Id  = pSpd->Property->Id;              // index of the property
    ULONG nS  = pSpd->PropertyOutputSize;        // size of data supplied
    ULONG standard = GetVideoDecoderStandard();

    ASSERT(nS >= sizeof(ULONG));

    ULONG ActualBytesTransferred;

    switch (Id)
    {
        case KSPROPERTY_VPCONFIG_NUMCONNECTINFO :
            // 2 VideoPort connections are possible
            *(PULONG)(pSpd->PropertyInfo) = BT829_VPCONNECTIONS_NUMBER;

            ActualBytesTransferred = sizeof(ULONG);
            break;

        case KSPROPERTY_VPCONFIG_GETCONNECTINFO :

            ASSERT(nS >= BT829_VPCONNECTIONS_NUMBER * sizeof(DDVIDEOPORTCONNECT));

            {
                LPDDVIDEOPORTCONNECT pConnectInfo;

                pConnectInfo = (LPDDVIDEOPORTCONNECT) pSpd->PropertyInfo;

                // fill in the DDVIDEOPORTCONNECT structure 1
                pConnectInfo->dwSize = sizeof(DDVIDEOPORTCONNECT);
                pConnectInfo->guidTypeID = DDVPTYPE_BROOKTREE;
                pConnectInfo->dwPortWidth = 8;
                pConnectInfo->dwFlags = DDVPCONNECT_INVERTPOLARITY;
                pConnectInfo->dwReserved1 = 0;

#if 0
                // fill in the DDVIDEOPORTCONNECT structure 2
                pConnectInfo ++;
                pConnectInfo->dwSize = sizeof(DDVIDEOPORTCONNECT);
                pConnectInfo->guidTypeID = DDVPTYPE_BROOKTREE;
                pConnectInfo->dwPortWidth = 16;
                pConnectInfo->dwFlags = DDVPCONNECT_INVERTPOLARITY;
                pConnectInfo->dwReserved1 = 0;
#endif
            }

            ActualBytesTransferred = BT829_VPCONNECTIONS_NUMBER * sizeof(DDVIDEOPORTCONNECT);
            break;

        case KSPROPERTY_VPCONFIG_NUMVIDEOFORMAT :
            // 2 output pixel formats are possible
            *(PULONG)(pSpd->PropertyInfo) = BT829_PIXELFORMATS_NUMBER;

            ActualBytesTransferred = sizeof(ULONG);
            break;

        case KSPROPERTY_VPCONFIG_GETVIDEOFORMAT :

            ASSERT(nS >= BT829_PIXELFORMATS_NUMBER * sizeof(DDPIXELFORMAT));

            {
                LPDDPIXELFORMAT pPixelFormat;

                pPixelFormat = (LPDDPIXELFORMAT) pSpd->PropertyInfo;

                // fill in the DDPIXELFORMAT structure
                pPixelFormat->dwSize = sizeof(DDPIXELFORMAT);
                pPixelFormat->dwFourCC = FOURCC_VBID;
                pPixelFormat->dwYUVBitCount = 8;
                pPixelFormat->dwFlags = DDPF_FOURCC;
            }

            ActualBytesTransferred = BT829_PIXELFORMATS_NUMBER * sizeof(DDPIXELFORMAT);
            break;

        case KSPROPERTY_VPCONFIG_VPDATAINFO :

            ASSERT(nS >= sizeof(KS_AMVPDATAINFO));

            {
                PKS_AMVPDATAINFO pAMVPDataInfo;

                pAMVPDataInfo = (PKS_AMVPDATAINFO) pSpd->PropertyInfo;

				int decoderLostLines = (GetPartRev() >= 4) ?
					BT829A_LOST_LINES : BT829_LOST_LINES;

                // the values are sortof hardcoded for NTSC at this point
                // VBI values will need to be tweaked
                pAMVPDataInfo->dwSize = sizeof(KS_AMVPDATAINFO);
                if ( standard & ( KS_AnalogVideo_NTSC_Mask | KS_AnalogVideo_PAL_M ) )   // NTSC rectangle?
                    pAMVPDataInfo->dwMicrosecondsPerField = 16667;
                else
                    pAMVPDataInfo->dwMicrosecondsPerField = 20000;

                pAMVPDataInfo->bEnableDoubleClock = FALSE;
                pAMVPDataInfo->bEnableVACT = FALSE;

                pAMVPDataInfo->lHalfLinesOdd = 0;
                pAMVPDataInfo->lHalfLinesEven = 1;

                pAMVPDataInfo->bFieldPolarityInverted = FALSE;
                pAMVPDataInfo->bDataIsInterlaced = TRUE;
                pAMVPDataInfo->dwNumLinesInVREF = 6 - decoderLostLines;

                pAMVPDataInfo->amvpDimInfo.dwFieldWidth = GetDecoderWidth();
                
                // Beware of hard-coded numbers
                pAMVPDataInfo->amvpDimInfo.dwVBIWidth = VBISamples;
                pAMVPDataInfo->amvpDimInfo.rcValidRegion.left = 0;

                if ( standard & ( KS_AnalogVideo_NTSC_Mask | KS_AnalogVideo_PAL_M ) )   // NTSC rectangle?
                {
                    pAMVPDataInfo->amvpDimInfo.dwVBIHeight = NTSCVBIEnd - decoderLostLines;
                    pAMVPDataInfo->amvpDimInfo.dwFieldHeight =
                        GetDecoderHeight() +
                        pAMVPDataInfo->amvpDimInfo.dwVBIHeight;
                    /*
                        (NTSCVBIEnd - 1) -  // the '- 1' makes VBIEnd zero-based
                        decoderLostLines -
                        pAMVPDataInfo->dwNumLinesInVREF;
                    */
                
                    pAMVPDataInfo->amvpDimInfo.rcValidRegion.top = NTSCVBIStart - 1 - decoderLostLines;
                }
                else
                {
                    pAMVPDataInfo->amvpDimInfo.dwVBIHeight = PALVBIEnd - decoderLostLines;
                    pAMVPDataInfo->amvpDimInfo.dwFieldHeight =
                        GetDecoderHeight() +
                        pAMVPDataInfo->amvpDimInfo.dwVBIHeight;
                    /*
                        (PALVBIEnd - 1) -  // the '- 1' makes VBIEnd zero-based
                        decoderLostLines -
                        pAMVPDataInfo->dwNumLinesInVREF;
                    */
                
                    pAMVPDataInfo->amvpDimInfo.rcValidRegion.top = PALVBIStart - 1 - decoderLostLines;
                }

                pAMVPDataInfo->amvpDimInfo.rcValidRegion.right = pAMVPDataInfo->amvpDimInfo.dwVBIWidth;
                pAMVPDataInfo->amvpDimInfo.rcValidRegion.bottom = pAMVPDataInfo->amvpDimInfo.dwVBIHeight;
            }

            ActualBytesTransferred = sizeof(KS_AMVPDATAINFO);
            break;

        case KSPROPERTY_VPCONFIG_MAXPIXELRATE :
            ASSERT(nS >= sizeof(KSVPMAXPIXELRATE));

            {

                PKSVPMAXPIXELRATE pKSPixelRate;

                int decoderHeight = GetDecoderHeight();
                int decoderWidth = GetDecoderWidth();

                pKSPixelRate = (PKSVPMAXPIXELRATE) pSpd->PropertyInfo;

                pKSPixelRate->Size.dwWidth = decoderWidth;
                pKSPixelRate->Size.dwHeight = decoderHeight;
                if ( standard & ( KS_AnalogVideo_NTSC_Mask | KS_AnalogVideo_PAL_M ) )   // NTSC rectangle?
                    pKSPixelRate->MaxPixelsPerSecond = decoderWidth * decoderHeight * NTSC_FRAME_RATE;
                else
                    pKSPixelRate->MaxPixelsPerSecond = decoderWidth * decoderHeight * PAL_FRAME_RATE;
            }
            ActualBytesTransferred = sizeof(KSVPMAXPIXELRATE);
            break;

        case KSPROPERTY_VPCONFIG_INFORMVPINPUT :
            ActualBytesTransferred = 0;
            break;

        case KSPROPERTY_VPCONFIG_DECIMATIONCAPABILITY :
            ActualBytesTransferred = 0;
            break;

        default:
            TRAP();
            ActualBytesTransferred = 0;
            break;
    }
	return ActualBytesTransferred;
}       



void Device::ConfigVPSurfaceParams(PKSVPSURFACEPARAMS pSurfaceParams)
{
	DBGINFO(("VP Surface Params:\n"));
	DBGINFO(("dwPitch    = %d\n",pSurfaceParams->dwPitch));
	DBGINFO(("dwXOrigin  = %d\n",pSurfaceParams->dwXOrigin));
	DBGINFO(("dwYOrigin  = %d\n",pSurfaceParams->dwYOrigin));

	VideoSurfaceOriginX = pSurfaceParams->dwXOrigin;
	VideoSurfaceOriginY = pSurfaceParams->dwYOrigin;
	VideoSurfacePitch = pSurfaceParams->dwPitch;
}



void Device::ConfigVPVBISurfaceParams(PKSVPSURFACEPARAMS pSurfaceParams)
{
    DBGINFO(("VP VBI Surface Params:\n"));
    DBGINFO(("dwPitch    = %d\n",pSurfaceParams->dwPitch));
    DBGINFO(("dwXOrigin  = %d\n",pSurfaceParams->dwXOrigin));
    DBGINFO(("dwYOrigin  = %d\n",pSurfaceParams->dwYOrigin));

    VBISurfaceOriginX = pSurfaceParams->dwXOrigin;
    VBISurfaceOriginY = pSurfaceParams->dwYOrigin;
    VBISurfacePitch = pSurfaceParams->dwPitch;
}


// -------------------------------------------------------------------
// VideoProcAmp functions
// -------------------------------------------------------------------

NTSTATUS Device::SetProcAmpProperty(ULONG Id, LONG Value)
{
    switch (Id) {
		case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:

			decoder->SetBrightness(Value);
			break;
        
		case KSPROPERTY_VIDEOPROCAMP_CONTRAST:

			decoder->SetContrast(Value);
			break;

		case KSPROPERTY_VIDEOPROCAMP_HUE:

			decoder->SetHue(Value);
			break;

		case KSPROPERTY_VIDEOPROCAMP_SATURATION:

			decoder->SetSaturation(Value);
			break;

		default:
			TRAP();
			return STATUS_NOT_IMPLEMENTED;
			break;
    }

	return STATUS_SUCCESS;
}

NTSTATUS Device::GetProcAmpProperty(ULONG Id, PLONG pValue)
{
    switch (Id) {

		case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:
			*pValue = decoder->GetBrightness();
			break;
        
		case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
			*pValue = decoder->GetContrast();
			break;

		case KSPROPERTY_VIDEOPROCAMP_HUE:
			*pValue = decoder->GetHue();
			break;

		case KSPROPERTY_VIDEOPROCAMP_SATURATION:
			*pValue = decoder->GetSaturation();
			break;

		default:
			TRAP();
			return STATUS_NOT_IMPLEMENTED;
			break;
		}

	return STATUS_SUCCESS;
}

BOOL Device::SetVideoDecoderStandard(DWORD standard)    //Paul:  Changed
{
    if ( decoder->SetVideoDecoderStandard(standard) )
    {
        switch (standard)
        {
        case KS_AnalogVideo_NTSC_M:
            scaler->VideoFormatChanged( VFormat_NTSC );
            break;
        case KS_AnalogVideo_NTSC_M_J:
            scaler->VideoFormatChanged( VFormat_NTSC_J );
            break;
		case KS_AnalogVideo_PAL_B:
		case KS_AnalogVideo_PAL_D:
		case KS_AnalogVideo_PAL_G:
		case KS_AnalogVideo_PAL_H:
		case KS_AnalogVideo_PAL_I:
            scaler->VideoFormatChanged( VFormat_PAL_BDGHI );    // PAL_BDGHI covers most areas 
            break;
        case KS_AnalogVideo_PAL_M:
            scaler->VideoFormatChanged( VFormat_PAL_M ); 
            break;
        case KS_AnalogVideo_PAL_N:
            scaler->VideoFormatChanged( VFormat_PAL_N_COMB ); 
            break;
        default:    //Paul:  SECAM
            scaler->VideoFormatChanged( VFormat_SECAM );
        }
        //SetRect(destRect);
        return TRUE;
    }
    return FALSE;
}