/******************************************************************************
/
/	File:			Theater.cpp
/
/	Description:	ATI Rage Theater Video Decoder interface.
/
/	Copyright 2001, Carlos Hasan
/
*******************************************************************************/

#include <Debug.h>
#include "Theater100.h"
#include "Theater.h"
#include "TheatreReg.h"
#include "lendian_bitfield.h"

CTheater100::CTheater100(CRadeon & radeon, int device)
:CTheater(radeon, device)
{
	PRINT(("CTheater100::CTheater100()\n"));
	
	if( fPort.InitCheck() == B_OK ) {
		radeon_video_tuner tuner;
		radeon_video_decoder video;
		
		radeon.GetMMParameters(tuner, video, fClock,
			fTunerPort, fCompositePort, fSVideoPort);
		
		if (fClock != C_RADEON_VIDEO_CLOCK_29_49892_MHZ &&
			fClock != C_RADEON_VIDEO_CLOCK_27_00000_MHZ)
			PRINT(("CTheater100::CTheater100() - Unsupported crystal clock!\n"));

		//fDevice = fPort.FindVIPDevice( C_THEATER100_VIP_DEVICE_ID );
	
	}
	
	if( InitCheck() != B_OK )
		PRINT(("CTheater100::CTheater100() - Rage Theater not found!\n"));
}

CTheater100::~CTheater100()
{
	PRINT(("CTheater100::~CTheater100()\n"));
	
	if( InitCheck() == B_OK )
		SetEnable(false, false);
}

status_t CTheater100::InitCheck() const
{
	status_t res;
	
	res = fPort.InitCheck();
	if( res != B_OK )
		return res;
		
	return (fDevice >= C_VIP_PORT_DEVICE_0 && fDevice <= C_VIP_PORT_DEVICE_3) ? B_OK : B_ERROR;
}

void CTheater100::Reset()
{
	PRINT(("CTheater100::Reset()\n"));
	
	SetHue(0);
	SetBrightness(0);
	SetSaturation(0);
	SetContrast(0);
	SetSharpness(false);
}

// disable/enable capturing
void CTheater100::SetEnable(bool enable, bool vbi)
{
	PRINT(("CTheater100::SetEnable(%d, %d)\n", enable, vbi));

#if 0
	//@ reset ADC?
	SetRegister(VIP_ADC_CNTL, ADC_CPRESET, ADC_CPRESET);
	snooze(1000);
	SetRegister(VIP_ADC_CNTL, ADC_CPRESET, 0);
	snooze(1000);
	SetRegister(VIP_ADC_CNTL, ADC_PDWN, ADC_PDWN_DOWN);
#endif

	
	WaitVSYNC();

	/* Disable the Video In, Scaler and DVS port */
	SetRegister(VIP_MASTER_CNTL, VIN_ASYNC_RST, VIN_ASYNC_RST);
	SetRegister(VIP_MASTER_CNTL, DVS_ASYNC_RST, DVS_ASYNC_RST);

	/* select the reference clock for the Video In */
	SetRegister(VIP_CLOCK_SEL_CNTL, VIN_CLK_SEL, VIN_CLK_SEL_REF_CLK);

	/* reset the VIN/L54 PLL clocks */
	SetRegister(VIP_PLL_CNTL1, VINRST, VINRST);
	SetRegister(VIP_PLL_CNTL1, L54RST, L54RST);

	/* power down the ADC block */
	SetRegister(VIP_ADC_CNTL, ADC_PDWN, ADC_PDWN);

	/* set DVS port to input mode */
	SetRegister(VIP_DVS_PORT_CTRL, DVS_DIRECTION, DVS_DIRECTION_INPUT);

	/* select DVS clock to 8xFsc and disable continuous mode */
	SetRegister(VIP_DVS_PORT_CTRL, DVS_CLK_SELECT, DVS_CLK_SELECT_8X);
	SetRegister(VIP_DVS_PORT_CTRL, CONTINUOUS_STREAM, 0);

	if (enable) {
		WaitVSYNC();

		SetClock(fStandard, fClock);
		SetADC(fStandard, fSource);
		SetLuminanceProcessor(fStandard);
		SetChromaProcessor(fStandard);
		SetVSYNC(fStandard);
		SetClipWindow(fStandard, vbi);
		SetCombFilter(fStandard, fSource);
		SetHSYNC(fStandard);
		SetSyncGenerator(fStandard);
		SetScaler(fStandard, fHActive, fVActive, fDeinterlace);
		
		/* Enable ADC block */
		SetRegister(VIP_ADC_CNTL, ADC_PDWN, ADC_PDWN_UP);

		WaitVSYNC();

		/* Enable the Video In, Scaler and DVS port */
		SetRegister(VIP_MASTER_CNTL, VIN_ASYNC_RST, 0);
		SetRegister(VIP_MASTER_CNTL, DVS_ASYNC_RST, 0);

		/* set DVS port to output mode */
		SetRegister(VIP_DVS_PORT_CTRL, DVS_DIRECTION, DVS_DIRECTION_OUTPUT);

		//WaitHSYNC();

		/* restore luminance and chroma settings */
		SetLuminanceLevels(fStandard, fBrightness, fContrast);
		SetChromaLevels(fStandard, fSaturation, fHue);
	}
}

void CTheater100::SetStandard(theater_standard standard, theater_source source)
{
	PRINT(("CTheater100::SetStandard(%s, %s)\n",
		"NTSC\0\0\0\0\0\0NTSC-J\0\0\0\0NTSC-443\0\0PAL-M\0\0\0\0\0"
		"PAL-N\0\0\0\0\0PAL-NC\0\0\0\0PAL-BDGHI\0PAL-60\0\0\0\0"
		"SECAM\0\0\0\0\0"+10*standard,
		"TUNER\0COMP\0\0SVIDEO"+6*source));
		
	fStandard = standard;
	fSource = source;
}

void CTheater100::SetSize(int hactive, int vactive)
{
	PRINT(("CTheater100::SetSize(%d, %d)\n", hactive, vactive));
	
	fHActive = hactive;
	fVActive = vactive;
}

void CTheater100::SetDeinterlace(bool deinterlace)
{
	PRINT(("CTheater100::SetDeinterlace(%d)\n", deinterlace));
	
	fDeinterlace = deinterlace;
}

void CTheater100::SetSharpness(int sharpness)
{
	PRINT(("CTheater100::SetSharpness(%d)\n", sharpness));
	
	SetRegister(VIP_H_SCALER_CONTROL, H_SHARPNESS, sharpness << 25);
}

void CTheater100::SetBrightness(int brightness)
{
	PRINT(("CTheater100::SetBrightness(%d)\n", brightness));
	
	fBrightness = brightness;
	SetLuminanceLevels(fStandard, fBrightness, fContrast);
}

void CTheater100::SetContrast(int contrast)
{
	PRINT(("CTheater100::SetContrast(%d)\n", contrast));

	fContrast = contrast;
	SetLuminanceLevels(fStandard, fBrightness, fContrast);
}

void CTheater100::SetSaturation(int saturation)
{
	PRINT(("CTheater100::SetSaturation(%d)\n", saturation));

	fSaturation = saturation;
	SetChromaLevels(fStandard, fSaturation, fHue);
}

void CTheater100::SetHue(int hue)
{
	PRINT(("CTheater100::SetHue(%d)\n", hue));

	fHue = hue;
	SetChromaLevels(fStandard, fSaturation, fHue);
}


// set pixel clock
void CTheater100::SetClock(theater_standard standard, radeon_video_clock clock)
{
	// set VIN PLL clock dividers
	int referenceDivider, feedbackDivider, postDivider;
	
	switch (standard) {
	case C_THEATER_NTSC:
	case C_THEATER_NTSC_JAPAN:
		if (clock == C_RADEON_VIDEO_CLOCK_29_49892_MHZ) {
			referenceDivider = 0x39;
			feedbackDivider = 0x14c;
			postDivider = 0x6;
		}
		else {
			referenceDivider = 0x0b;
			feedbackDivider = 0x46;
			postDivider = 0x6;
		}
		break;
	case C_THEATER_NTSC_443:
		if (clock == C_RADEON_VIDEO_CLOCK_29_49892_MHZ) {
			referenceDivider = 0x23;
			feedbackDivider = 0x88;
			postDivider = 0x7;
		}
		else {
			referenceDivider = 0x2c;
			feedbackDivider = 0x121;
			postDivider = 0x5;
		}
		break;
	case C_THEATER_PAL_M:
		if (clock == C_RADEON_VIDEO_CLOCK_29_49892_MHZ) {
			referenceDivider = 0x2c;
			feedbackDivider = 0x12b;
			postDivider = 0x7;
		}
		else {
			referenceDivider = 0x0b;
			feedbackDivider = 0x46;
			postDivider = 0x6;
		}
		break;
	case C_THEATER_PAL_BDGHI:
	case C_THEATER_PAL_N:
	case C_THEATER_PAL_60:
	case C_THEATER_SECAM:
		if (clock == C_RADEON_VIDEO_CLOCK_29_49892_MHZ) {
			referenceDivider = 0x0e;
			feedbackDivider = 0x65;
			postDivider = 0x6;
		}
		else {
			referenceDivider = 0x2c;
			feedbackDivider = 0x121;
			postDivider = 0x5;
		}
		break;
	case C_THEATER_PAL_NC:
		if (clock == C_RADEON_VIDEO_CLOCK_29_49892_MHZ) {
			referenceDivider = 0x23;
			feedbackDivider = 0x88;
			postDivider = 0x7;
		}
		else {
			referenceDivider = 0x37;
			feedbackDivider = 0x1d3;
			postDivider = 0x8;
		}
		break;
	default:
		PRINT(("CTheater100::SetClock() - Bad standard\n"));
		return;
	}

	// reset VIN PLL and select the reference clock
	SetRegister(VIP_CLOCK_SEL_CNTL, VIN_CLK_SEL, VIN_CLK_SEL_REF_CLK);
	SetRegister(VIP_PLL_CNTL1, VINRST, VINRST);
	SetRegister(VIP_PLL_CNTL1, L54RST, L54RST);
	
	// set up the VIN PLL clock control
	SetRegister(VIP_VIN_PLL_CNTL, VIN_M0, referenceDivider << 0);
	SetRegister(VIP_VIN_PLL_CNTL, VIN_N0, feedbackDivider << 11);
	SetRegister(VIP_VIN_PLL_CNTL, VIN_P, postDivider << 24);

	// active the VIN/L54 PLL and attach the VIN PLL to the VIN clock
	SetRegister(VIP_PLL_CNTL1, VINRST, 0);
	SetRegister(VIP_PLL_CNTL1, L54RST, 0);
	SetRegister(VIP_CLOCK_SEL_CNTL, VIN_CLK_SEL, VIN_CLK_SEL_VIPLL_CLK);

	PRINT(("CTheater100::SetClock(Fsamp=%g, Fref=%g)\n",
		((fClock == C_RADEON_VIDEO_CLOCK_29_49892_MHZ ? 29.49892 : 27.0) * feedbackDivider) / (referenceDivider * postDivider),
		(fClock == C_RADEON_VIDEO_CLOCK_29_49892_MHZ ? 29.49892 : 27.0)));
}


// setup analog-digital converter
void CTheater100::SetADC(theater_standard standard, theater_source source)
{
	PRINT(("CTheater100::SetADC(%c, %c)\n", "NJ4MNCB6S"[standard], "TCS"[source]));
	
	// set HW_DEBUG before setting the standard
	SetRegister(VIP_HW_DEBUG, 0x0000f000);
	
	// select the video standard
	switch (standard) {
	case C_THEATER_NTSC:
	case C_THEATER_NTSC_JAPAN:
	case C_THEATER_NTSC_443:
	case C_THEATER_PAL_M:
		SetRegister(VIP_STANDARD_SELECT, STANDARD_SEL, STANDARD_NTSC);
		break;
	case C_THEATER_PAL_BDGHI:
	case C_THEATER_PAL_N:
	case C_THEATER_PAL_60:
	case C_THEATER_PAL_NC:
		SetRegister(VIP_STANDARD_SELECT, STANDARD_SEL, STANDARD_PAL);
		break;
	case C_THEATER_SECAM:
		SetRegister(VIP_STANDARD_SELECT, STANDARD_SEL, STANDARD_SECAM);
		break;
	default:
		PRINT(("CTheater100::SetADC() - Bad standard\n"));
		return;
	}

	// select input connector and Y/C mode
	switch (source) {
	case C_THEATER_TUNER:
		SetRegister(VIP_ADC_CNTL, INPUT_SELECT, fTunerPort);
		SetRegister(VIP_STANDARD_SELECT, YC_MODE, YC_MODE_COMPOSITE);
		break;
	case C_THEATER_COMPOSITE:
		SetRegister(VIP_ADC_CNTL, INPUT_SELECT, fCompositePort);
		SetRegister(VIP_STANDARD_SELECT, YC_MODE, YC_MODE_COMPOSITE);
		break;
	case C_THEATER_SVIDEO:
		SetRegister(VIP_ADC_CNTL, INPUT_SELECT, fSVideoPort);
		SetRegister(VIP_STANDARD_SELECT, YC_MODE, YC_MODE_SVIDEO);
		break;
	default:
		PRINT(("CTheater100::SetADC() - Bad source\n"));
		return;
	}
	
	SetRegister(VIP_ADC_CNTL, I_CLAMP_SEL, I_CLAMP_SEL_22);
	SetRegister(VIP_ADC_CNTL, I_AGC_SEL, I_AGC_SEL_7);

	SetRegister(VIP_ADC_CNTL, EXT_CLAMP_CAP, EXT_CLAMP_CAP_EXTERNAL);
	SetRegister(VIP_ADC_CNTL, EXT_AGC_CAP, EXT_AGC_CAP_EXTERNAL);
	SetRegister(VIP_ADC_CNTL, ADC_DECI_BYPASS, ADC_DECI_WITH_FILTER);
	SetRegister(VIP_ADC_CNTL, VBI_DECI_BYPASS, VBI_DECI_WITH_FILTER);
	SetRegister(VIP_ADC_CNTL, DECI_DITHER_EN, 0 << 12);
	SetRegister(VIP_ADC_CNTL, ADC_CLK_SEL, ADC_CLK_SEL_8X);
	SetRegister(VIP_ADC_CNTL, ADC_BYPASS, ADC_BYPASS_INTERNAL);
	switch (standard) {
	case C_THEATER_NTSC:
	case C_THEATER_NTSC_JAPAN:
	case C_THEATER_NTSC_443:
	case C_THEATER_PAL_M:
		SetRegister(VIP_ADC_CNTL, ADC_CH_GAIN_SEL, ADC_CH_GAIN_SEL_NTSC);
		break;
	case C_THEATER_PAL_BDGHI:
	case C_THEATER_PAL_N:
	case C_THEATER_PAL_60:
	case C_THEATER_PAL_NC:
	case C_THEATER_SECAM:
		SetRegister(VIP_ADC_CNTL, ADC_CH_GAIN_SEL, ADC_CH_GAIN_SEL_PAL);
		break;
	}
	SetRegister(VIP_ADC_CNTL, ADC_PAICM, 1 << 18);

	SetRegister(VIP_ADC_CNTL, ADC_PDCBIAS, 2 << 20);
	SetRegister(VIP_ADC_CNTL, ADC_PREFHI, ADC_PREFHI_2_7);
	SetRegister(VIP_ADC_CNTL, ADC_PREFLO, ADC_PREFLO_1_5);

	SetRegister(VIP_ADC_CNTL, ADC_IMUXOFF, 0 << 26);
	SetRegister(VIP_ADC_CNTL, ADC_CPRESET, 0 << 27);
}


// setup horizontal sync PLL
void CTheater100::SetHSYNC(theater_standard standard)
{
	static const uint16 hs_line_total[] = {
		0x38E,	0x38E,	0x46F,	0x38D,	0x46F,	0x395,	0x46F,	0x467,	0x46F };
		
	static const uint32 hs_dto_inc[] = {
		0x40000,	0x40000,	0x40000,	0x40000,	0x40000,	0x40000,	0x40000,	0x40000,	0x3E7A2 };

	// TK: completely different in gatos
	static const uint8 hs_pll_sgain[] = {
		2,		2,		2,		2,		2,		2,		2,		2,		2 };
	static const uint8 hs_pll_fgain[] = {
		8,		8,		8,		8,		8,		8,		8,		8,		8 };

	static const uint8 gen_lock_delay[] = {
		0x10,	0x10,	0x10,	0x10,	0x10,	0x10,	0x10,	0x10,	0x10 };
		
	static const uint8 min_pulse_width[] = {
		0x21,	0x21,	0x29,	0x21,	0x29,	0x21,	0x29,	0x29,	0x29 };
	static const uint8 max_pulse_width[] = {
		0x64,	0x64,	0x7D,	0x64,	0x7D,	0x65,	0x7D,	0x7D,	0x7D };
		
	static const uint16 win_close_limit[] = {
		0x0A0,	0x0A0,	0x0C7,	0x0A0,	0x0C7,	0x0A0,	0x0C7,	0x0C7,	0x0C7 };
	static const uint16 win_open_limit[] = {
		0x1B7,	0x1B7,	0x228,	0x1B7,	0x228,	0x1BB,	0x228,	0x224,	0x228 };


	// set number of samples per line
	SetRegister(VIP_HS_PLINE, HS_LINE_TOTAL, hs_line_total[standard]);
	
	SetRegister(VIP_HS_DTOINC, HS_DTO_INC, hs_dto_inc[standard]);
	
	SetRegister(VIP_HS_PLLGAIN, HS_PLL_SGAIN, hs_pll_sgain[standard] << 0);
	SetRegister(VIP_HS_PLLGAIN, HS_PLL_FGAIN, (uint32)hs_pll_fgain[standard] << 4);
	
	SetRegister(VIP_HS_GENLOCKDELAY, GEN_LOCK_DELAY, gen_lock_delay[standard]);

	// set min/max pulse width in samples	
	SetRegister(VIP_HS_MINMAXWIDTH, MIN_PULSE_WIDTH, min_pulse_width[standard] << 0);
	SetRegister(VIP_HS_MINMAXWIDTH, MAX_PULSE_WIDTH, (uint32)max_pulse_width[standard] << 8);

	SetRegister(VIP_HS_WINDOW_LIMIT, WIN_CLOSE_LIMIT, win_close_limit[standard] << 0);
	SetRegister(VIP_HS_WINDOW_LIMIT, WIN_OPEN_LIMIT, (uint32)win_open_limit[standard] << 16);
	

	PRINT(("CTheater100::SetHSYNC(total=%d, pulse=%d/%d, window=%d/%d)\n",
		Register(VIP_HS_PLINE, HS_LINE_TOTAL),
		Register(VIP_HS_MINMAXWIDTH, MIN_PULSE_WIDTH) >> 0,
		Register(VIP_HS_MINMAXWIDTH, MAX_PULSE_WIDTH) >> 8,
		Register(VIP_HS_WINDOW_LIMIT, WIN_CLOSE_LIMIT) >> 0,
		Register(VIP_HS_WINDOW_LIMIT, WIN_OPEN_LIMIT) >> 16));
}


// wait until horizontal scaler is locked
void CTheater100::WaitHSYNC()
{
	for (int timeout = 0; timeout < 1000; timeout++) {
		if (Register(VIP_HS_PULSE_WIDTH, HS_GENLOCKED) != 0)
			return;
		snooze(20);
	}
	PRINT(("CTheater100::WaitHSYNC() - wait for HSync locking time out!\n"));
}


// setup vertical sync and field detector
void CTheater100::SetVSYNC(theater_standard standard)
{
	static const uint16 vsync_int_trigger[] = {
		0x2AA,	0x2AA,	0x353,	0x2AA,	0x353,	0x2B0,	0x353,	0x34D,	0x353 };
	static const uint16 vsync_int_hold[] = {
		0x017,	0x017,	0x01C,	0x017,	0x01C,	0x017,	0x01C,	0x01C,	0x01C };
	// PAL value changed from 26b to 26d - else, odd/even field detection fails sometimes;
	// did the same for PAL N, PAL NC and SECAM
	static const uint16 vs_field_blank_start[] = {
		0x206,	0x206,	0x206,	0x206,	0x26d,	0x26d,	0x26d,	0x206,	0x26d };
	static const uint8 vs_field_blank_end[] = {
		0x00a,	0x00a,	0x00a,	0x00a,	0x02a,	0x02a,	0x02a,	0x00a,	0x02a };
	// NTSC value changed from 1 to 105 - else, odd/even fields were always swapped;
	// did the same for NTSC Japan, NTSC 443, PAL M and PAL 60
	static const uint16 vs_field_id_location[] = {
		0x105,	0x105,	0x105,	0x105,	0x1,	0x1,	0x1,	0x105,	0x1 };
	static const uint16 vs_frame_total[] = {
		0x217,	0x217,	0x217,	0x217,	0x27B,	0x27B,	0x27B,	0x217,	0x27B };

	SetRegister(VIP_VS_DETECTOR_CNTL, VSYNC_INT_TRIGGER, vsync_int_trigger[standard] << 0);
	SetRegister(VIP_VS_DETECTOR_CNTL, VSYNC_INT_HOLD, (uint32)vsync_int_hold[standard] << 16);

	SetRegister(VIP_VS_BLANKING_CNTL, VS_FIELD_BLANK_START, vs_field_blank_start[standard] << 0);
	SetRegister(VIP_VS_BLANKING_CNTL, VS_FIELD_BLANK_END, (uint32)vs_field_blank_end[standard] << 16);
	SetRegister(VIP_VS_FRAME_TOTAL, VS_FRAME_TOTAL, vs_frame_total[standard]);

	SetRegister(VIP_VS_FIELD_ID_CNTL, VS_FIELD_ID_LOCATION, vs_field_id_location[standard] << 0);

	// auto-detect fields
	SetRegister(VIP_VS_COUNTER_CNTL, FIELD_DETECT_MODE, FIELD_DETECT_DETECTED);
	
	// don't flip fields
	SetRegister(VIP_VS_COUNTER_CNTL, FIELD_FLIP_EN, 0 );

	PRINT(("CTheater100::SetVSYNC(total=%d)\n",
		Register(VIP_VS_FRAME_TOTAL, VS_FRAME_TOTAL)));
}

// wait until a visible line is viewed
void CTheater100::WaitVSYNC()
{
	for (int timeout = 0; timeout < 1000; timeout++) {
		int lineCount = Register(VIP_VS_LINE_COUNT, VS_LINE_COUNT);
		if (lineCount > 1 && lineCount < 20)
			return;
		snooze(20);
	}
	PRINT(("CTheater100::WaitVSYNC() - wait for VBI timed out!\n"));
}


// setup timing generator
void CTheater100::SetSyncGenerator(theater_standard standard)
{
	static const uint16 blank_int_start[] = {
		0x031,	0x031,	0x046,	0x031,	0x046,	0x046,	0x046,	0x031,	0x046 };
	static const uint8 blank_int_length[] = {
		0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F };
		
	static const uint16 sync_tip_start[] = {
		0x0372,	0x0372,	0x0453,	0x0371,	0x0453,	0x0379,	0x0453,	0x044B,	0x0453 };
	static const uint8 sync_tip_length[] = {
		0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F };

	static const uint8 uv_int_start[] = {
		0x03B,	0x03B,	0x052,	0x03B,	0x052,	0x03B,	0x052,	0x03C,	0x068 };
	static const uint8 u_int_length[] = {
		0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F };
	static const uint8 v_int_length[] = {
		0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F,	0x0F };

	// set blank interrupt position
	SetRegister(VIP_SG_BLACK_GATE, BLANK_INT_START, blank_int_start[standard] );
	SetRegister(VIP_SG_BLACK_GATE, BLANK_INT_LENGTH, (uint32)blank_int_length[standard] << 8);

	SetRegister(VIP_SG_SYNCTIP_GATE, SYNC_TIP_START, sync_tip_start[standard]);
	SetRegister(VIP_SG_SYNCTIP_GATE, SYNC_TIP_LENGTH, (uint32)sync_tip_length[standard] << 12);

	SetRegister(VIP_SG_UVGATE_GATE, UV_INT_START, uv_int_start[standard] << 0);
	
	SetRegister(VIP_SG_UVGATE_GATE, U_INT_LENGTH, (uint32)u_int_length[standard] << 8);
	SetRegister(VIP_SG_UVGATE_GATE, V_INT_LENGTH, (uint32)v_int_length[standard] << 12);

	PRINT(("CTheater100::SetSyncGenerator(black=%d/%d, synctip=%d/%d, uvgate=%d/%d-%d)\n",
		Register(VIP_SG_BLACK_GATE, BLANK_INT_START) >> 0,
		Register(VIP_SG_BLACK_GATE, BLANK_INT_LENGTH) >> 8,
		Register(VIP_SG_SYNCTIP_GATE, SYNC_TIP_START),
		Register(VIP_SG_SYNCTIP_GATE, SYNC_TIP_LENGTH) >> 12,
		Register(VIP_SG_UVGATE_GATE, UV_INT_START),
		Register(VIP_SG_UVGATE_GATE, U_INT_LENGTH) >> 8,
		Register(VIP_SG_UVGATE_GATE, V_INT_LENGTH) >> 12));
}


// setup input comb filter.
// this is really ugly but I cannot find a scheme
void CTheater100::SetCombFilter(theater_standard standard, theater_source source)
{
	enum {
		_3Tap_2D_adaptive_Comb = 1,	// composite
		_2Tap_C_combed_Y_Sub = 2,
		_2Tap_C_combed_Y_combed = 3,
		_3Tap_C_combed_Y_Sub = 4,
		_3Tap_C_combed_Y_combed = 5,
		YC_mode_Comb_filter_off = 6,	// S-Video
		YC_mode_2Tap_YV_filter = 7,
		YC_mode_3Tap_YV_filter = 8
	};

	// make sure to keep bitfield in sync with register definition!
	// we could define each component as an uint8, but this would waste space
	// and would require an extra register-composition 
	typedef struct {
		LBITFIELD32_12 (
			comb_hck			: 8, 
			comb_vck			: 8, 
			comb_filter_en		: 1, 
			comb_adaptiv_en		: 1,
			comb_bpfmuxsel		: 3,
			comb_coutsel		: 2,
			comb_sumdiff0sel	: 1, 
			comb_sumdiff1sel	: 2,
			comb_yvlpfsel		: 1, 
			comb_dlylinesel		: 2, 
			comb_ydlyinsel		: 2, 
			comb_ysubbw			: 1
		);
	} comb_cntl0;
	
	typedef struct {
		LBITFIELD32_7 (
			comb_ydlyoutsel		: 2,
			comb_coresize		: 2, 
			comb_ysuben			: 1, 
			comb_youtsel		: 1,
			comb_syncpfsel		: 2, 
			comb_synclpfrst		: 1, 
			comb_debug			: 1
		);
	} comb_cntl1;

	typedef struct {
		LBITFIELD32_4 (
			comb_hyk0			: 8, 
			comb_vyk0			: 8, 
			comb_hyk1			: 8, 
			comb_vyk1			: 8
		);
	} comb_cntl2;

	typedef struct {
		LBITFIELD32_2 (
			comb_tap0length		: 16,
			comb_tap1length		: 12
		);
	} comb_line_length;

	typedef struct {
		const uint8				*types;
		const comb_cntl0		*cntl0;
		const comb_cntl1		*cntl1;
		const comb_cntl2		*cntl2;
		const comb_line_length	*line_length;
	} comb_settings;
	
	static const uint8 comb_types_ntsc_m[] = {
		_3Tap_2D_adaptive_Comb,
		_2Tap_C_combed_Y_Sub,
		_2Tap_C_combed_Y_combed,	
		_3Tap_C_combed_Y_Sub,
		_3Tap_C_combed_Y_combed,	
		YC_mode_Comb_filter_off,
		YC_mode_2Tap_YV_filter,	
		YC_mode_3Tap_YV_filter,
		0
	};

	static const comb_cntl0 comb_cntl0_ntsc_m[] = {
		{	0x90,	0x80,	1,	1,	0,	2,	0,	1,	0,	1,	0,	0 },
		{	0,	0,	1,	0,	3,	2,	0,	0,	0,	1,	0,	0 },
		{	0,	0,	1,	0,	3,	2,	0,	0,	0,	1,	1,	0 },
		{	0,	0,	1,	0,	1,	2,	0,	1,	0,	1,	0,	0 },
		{	0,	0,	1,	0,	1,	2,	0,	1,	1,	1,	0,	0 },
		{	0,	0,	0,	0,	5,	2,	0,	0,	0,	1,	2,	0 },
		{	0,	0,	0,	0,	5,	2,	0,	0,	0,	1,	1,	0 },
		{	0,	0,	0,	0,	5,	2,	0,	0,	1,	1,	0,	0 }
	};
	
	static const comb_cntl1 comb_cntl1_ntsc_m[] = {
		{	0,	0,	1,	0,	0,	0,	0 }, 
		{	2,	0,	1,	0,	0,	0,	0 }, 
		{	3,	0,	0,	0,	0,	0,	0 }, 
		{	0,	0,	1,	0,	1,	0,	0 }, 
		{	3,	0,	0,	0,	1,	0,	0 }, 
		{	1,	0,	0,	0,	2,	0,	0 }, 
		{	3,	0,	0,	0,	0,	0,	0 }, 
		{	3,	0,	0,	0,	1,	0,	0 }
	};
		
	static const comb_cntl2 comb_cntl2_ntsc_m[] = {
		{	0x10,	0x10,	0x16,	0x16 },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};
		
	static const comb_line_length comb_line_length_ntsc_m[] = {
		{	0x38A,	0x718 }, 
		{	0x38A,	0x718 }, 
		{	0x38A,	0x718 }, 
		{	0x38A,	0x718 }, 
		{	0x38A,	0x718 }, 
		{	0,		0 }, 
		{	0x38A,	0 }, 
		{	0x38A,	0x718 }
	};


	static const uint8 comb_types_ntsc_433[] = {
		_2Tap_C_combed_Y_Sub,
		_2Tap_C_combed_Y_combed,	
		_3Tap_C_combed_Y_Sub,
		_3Tap_C_combed_Y_combed,	
		YC_mode_Comb_filter_off,
		YC_mode_2Tap_YV_filter,	
		YC_mode_3Tap_YV_filter,
		0
	};
	
	static const comb_cntl0 comb_cntl0_ntsc_433[] = {
		{	0,	0,	1,	0,	3,	2,	0,	0,	0,	1,	0,	0 },
		{	0,	0,	1,	0,	3,	2,	0,	0,	0,	1,	1,	0 },
		{	0,	0,	1,	0,	1,	2,	0,	1,	0,	1,	0,	0 },
		{	0,	0,	1,	0,	1,	2,	0,	1,	1,	1,	0,	0 },
		{	0,	0,	0,	0,	5,	2,	0,	0,	0,	1,	2,	0 },
		{	0,	0,	0,	0,	5,	2,	0,	0,	0,	1,	1,	0 },
		{	0,	0,	0,	0,	5,	2,	0,	0,	1,	1,	0,	0 }
	};
	
	static const comb_cntl1 comb_cntl1_ntsc_433[] = {
		{	2,	0,	1,	0,	0,	0,	0 },
		{	3,	0,	0,	0,	0,	0,	0 },
		{	0,	0,	1,	0,	1,	0,	0 },
		{	3,	0,	0,	0,	1,	0,	0 },
		{	1,	0,	0,	0,	2,	0,	0 },
		{	3,	0,	0,	0,	0,	0,	0 },
		{	3,	0,	0,	0,	1,	0,	0 }
	};
	
	static const comb_cntl2 comb_cntl2_ntsc_433[] = {
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};
	
	static const comb_line_length comb_line_length_ntsc_433[] = {
		{	0x462,	0x8C9 },
		{	0x462,	0x8C9 },
		{	0x462,	0x8C9 },
		{	0x462,	0x8C9 },
		{	0,		0 },
		{	0x462,	0x8C9 },
		{	0x462,	0x8C9 }
	};
	

	static const uint8 comb_types_pal_m[] = {
		_2Tap_C_combed_Y_Sub,
		YC_mode_2Tap_YV_filter,	
		0
	};
	
	static const comb_cntl0 comb_cntl0_pal_m[] = {
		{	0,	0,	1,	0,	4,	0,	1,	2,	0,	0,	2,	0 },
		{	0,	0,	1,	0,	5,	0,	1,	2,	0,	0,	2,	0 }
	};

	static const comb_cntl1 comb_cntl1_pal_m[] = {
		{	1,	0,	1,	1,	2,	0,	0 },
		{	1,	0,	0,	1,	2,	0,	0 }
	};
	
	static const comb_cntl2 comb_cntl2_pal_m[] = {
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};

	static const comb_line_length comb_line_length_pal_m[] = {
		{	0x389,	0 },
		{	0x389,	0 }
	};


	static const uint8 comb_types_pal_n[] = {
		_3Tap_2D_adaptive_Comb,
		_2Tap_C_combed_Y_Sub,
		YC_mode_2Tap_YV_filter,
		0
	};

	static const comb_cntl0 comb_cntl0_pal_n[] = {
		{	0x90,	0x80,	1,	1,	0,	2,	0,	1,	0,	1,	0,	0 },
		{	0,	0,	1,	0,	4,	0,	1,	2,	0,	0,	2,	0 },
		{	0,	0,	1,	0,	5,	0,	1,	2,	0,	0,	2,	0 }
	};

	static const comb_cntl1 comb_cntl1_pal_n[] = {
		{	0,	0,	1,	0,	0,	0,	0 },
		{	1,	0,	1,	1,	2,	0,	0 },
		{	1,	0,	0,	1,	2,	0,	0 }
	};
	
	static const comb_cntl2 comb_cntl2_pal_n[] = {
		{	0x10,	0x10,	0x16,	0x16 },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};

	static const comb_line_length comb_line_length_pal_n[] = {
		{	0x46B,	0x8DA },
		{	0x46C,	0 },
		{	0x46C,	0 }
	};


	static const uint8 comb_types_pal_nc[] = {
		_3Tap_2D_adaptive_Comb,
		_2Tap_C_combed_Y_Sub,
		YC_mode_2Tap_YV_filter,
		0
	};

	// used to represent an N/A for easier copy'n'paste	
#define X 0

	static const comb_cntl0 comb_cntl0_pal_nc[] = {
		{	0x90,	0x80,	1,	1,	0,	2,	0,	1,	0,	1,	0,	0 },
		{	X,	X,	1,	0,	4,	0,	1,	2,	0,	0,	2,	0 },
		{	X,	X,	1,	0,	5,	0,	1,	2,	X,	0,	2,	0 }
	};
	
	static const comb_cntl1 comb_cntl1_pal_nc[] = {
		{	0,	0,	1,	0,	0,	0,	0 },
		{	1,	0,	1,	1,	2,	0,	0 },
		{	1,	0,	0,	1,	2,	0,	0 }
	};

	static const comb_cntl2 comb_cntl2_pal_nc[] = {
		{	0x10,	0x10,	0x16,	0x16 },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};

	static const comb_line_length comb_line_length_pal_nc[] = {
		{	0x391,	0x726 },
		{	0x394,	X },
		{	0x394,	X }
	};
	
	
	static const uint8 comb_types_pal[] = {
		_3Tap_2D_adaptive_Comb,
		_2Tap_C_combed_Y_Sub,
		YC_mode_2Tap_YV_filter,
		0
	};

	static const comb_cntl0 comb_cntl0_pal[] = {
		{	0x90,	0x80,	1,	1,	0,	2,	0,	1,	0,	1,	0,	0 },
		{	0,	0,	1,	0,	4,	0,	1,	2,	0,	0,	2,	0 },
		{	0,	0,	1,	0,	5,	0,	1,	2,	X,	0,	2,	0 }
	};
	
	static const comb_cntl1 comb_cntl1_pal[] = {
		{	0,	0,	1,	0,	0,	0,	0 },
		{	1,	0,	1,	1,	2,	0,	0 },
		{	1,	0,	0,	1,	2,	0,	0 }
	};

	static const comb_cntl2 comb_cntl2_pal[] = {	
		{	2,	1,	8,	6 },
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};

	static const comb_line_length comb_line_length_pal[] = {
		{	0x46B,	0x8DA },
		{	0x46C,	X },
		{	0x46C,	X }
	};


	static const uint8 comb_types_pal_60[] = {
		_2Tap_C_combed_Y_Sub,
		YC_mode_2Tap_YV_filter,
		0
	};

	static const comb_cntl0 comb_cntl0_pal_60[] = {
		{	0,	0,	1,	0,	4,	0,	1,	2,	0,	0,	2,	0 },
		{	0,	0,	1,	0,	5,	0,	1,	2,	0,	0,	2,	0 }
	};
	
	static const comb_cntl1 comb_cntl1_pal_60[] = {
		{	1,	0,	1,	1,	2,	0,	0 },
		{	1,	0,	0,	1,	2,	0,	0 }
	};

	static const comb_cntl2 comb_cntl2_pal_60[] = {	
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};

	static const comb_line_length comb_line_length_pal_60[] = {
		{	0x463,	0 },
		{	0x463,	0 }
	};

		
	static const uint8 comb_types_secam[] = {
		_2Tap_C_combed_Y_Sub,		// could be another type, spec is unclear here
		YC_mode_2Tap_YV_filter,
		0,
	};

	static const comb_cntl0 comb_cntl0_secam[] = {
		{	X,	X,	0,	0,	4,	X,	X,	X,	X,	2,	2,	1 },
		{	X,	X,	0,	0,	5,	X,	X,	X,	X,	2,	2,	X }
	};
	
	static const comb_cntl1 comb_cntl1_secam[] = {
		{	1,	0,	1,	0,	2,	0,	0 },
		{	1,	X,	0,	0,	2,	0,	0 }
	};
	
	static const comb_cntl2 comb_cntl2_secam[] = {	
		{	0xFF,	0xFF,	0xFF,	0xFF },
		{	0xFF,	0xFF,	0xFF,	0xFF }
	};
	
	static const comb_line_length comb_line_length_secam[] = {
		{	0x46A,	0 },
		{	0x46A,	0 }
	};

#undef X		
		
	static const comb_settings comb_settings_list[] = {
		{ comb_types_ntsc_m,	comb_cntl0_ntsc_m,		comb_cntl1_ntsc_m,		comb_cntl2_ntsc_m,		comb_line_length_ntsc_m },
		{ comb_types_ntsc_m,	comb_cntl0_ntsc_m,		comb_cntl1_ntsc_m,		comb_cntl2_ntsc_m,		comb_line_length_ntsc_m },
		{ comb_types_ntsc_433,	comb_cntl0_ntsc_433,	comb_cntl1_ntsc_433,	comb_cntl2_ntsc_433,	comb_line_length_ntsc_433 },
		{ comb_types_pal_m,		comb_cntl0_pal_m,		comb_cntl1_pal_m,		comb_cntl2_pal_m,		comb_line_length_pal_m },
		{ comb_types_pal_n,		comb_cntl0_pal_n,		comb_cntl1_pal_n,		comb_cntl2_pal_n,		comb_line_length_pal_n },
		{ comb_types_pal_nc,	comb_cntl0_pal_nc,		comb_cntl1_pal_nc,		comb_cntl2_pal_nc,		comb_line_length_pal_nc },
		{ comb_types_pal,		comb_cntl0_pal,			comb_cntl1_pal,			comb_cntl2_pal,			comb_line_length_pal },
		{ comb_types_pal_60,	comb_cntl0_pal_60,		comb_cntl1_pal_60,		comb_cntl2_pal_60,		comb_line_length_pal_60 },
		{ comb_types_secam,		comb_cntl0_secam,		comb_cntl1_secam,		comb_cntl2_secam,		comb_line_length_secam }
	};

	int min_type, max_type, type;
	const comb_settings *settings;
	int i = 0;

	PRINT(("CTheater100::SetCombFilter(%c, %c)\n", "NJ4MNCB6S"[standard], "TCS"[source]));

	// I don't really understand what the different types mean;
	// what is particularly strange is that many types are defined for few standards only
	if( source == C_THEATER_TUNER || source == C_THEATER_COMPOSITE ) {
		min_type = _3Tap_2D_adaptive_Comb;
		max_type = _3Tap_C_combed_Y_combed;
	} else {
		min_type = YC_mode_Comb_filter_off;
		max_type = YC_mode_3Tap_YV_filter;
	}
	
	settings = &comb_settings_list[standard];
	
	for( type = min_type; type <= max_type; ++type ) {
		for( i = 0; settings->types[i]; ++i ) {
			if( settings->types[i] == type )
				break;
		}
		
		if( settings->types[i] != 0 )
			break;
	}
	
	if( type > max_type ) {
		PRINT(("CTheater100::SetCombFilter() - No settings for this standard and input type combination!!!\n"));
		return;
	}

	SetRegister(VIP_COMB_CNTL0, *(const int32 *)(settings->cntl0 + i));
	SetRegister(VIP_COMB_CNTL1, *(const int32 *)(settings->cntl1 + i));
	SetRegister(VIP_COMB_CNTL2, *(const int32 *)(settings->cntl2 + i));
	SetRegister(VIP_COMB_LINE_LENGTH, *(const int32 *)(settings->line_length + i));
	

	// reset the comb filter
	SetRegister(VIP_COMB_CNTL1, Register(VIP_COMB_CNTL1) ^ COMB_SYNCLPFRST);
	SetRegister(VIP_COMB_CNTL1, Register(VIP_COMB_CNTL1) ^ COMB_SYNCLPFRST);
}


// setup luma processor
void CTheater100::SetLuminanceProcessor(theater_standard standard)
{	
	static const uint16 synctip_ref0[] = {
		0x037,	0x037,	0x037,	0x037,	0x037,	0x037,	0x037,	0x037,	0x037 };
	static const uint16 synctip_ref1[] = {
		0x029,	0x029,	0x029,	0x029,	0x029,	0x026,	0x026,	0x026,	0x026 };
	static const uint16 clamp_ref[] = {
		0x03B,	0x03B,	0x03B,	0x03B,	0x03B,	0x03B,	0x03B,	0x03B,	0x03B };
	static const uint16 agc_peakwhite[] = {
		0x0FF,	0x0FF,	0x0FF,	0x0FF,	0x0FF,	0x0FF,	0x0FF,	0x0FF,	0x0FF };
	static const uint16 vbi_peakwhite[] = {
		0x0D2,	0x0D2,	0xD2,	0x0D2,	0x0D2,	0x0C6,	0x0C6,	0x0C6,	0x0C6 };
		
	static const uint16 wpa_threshold[] = {
		0x406,	0x406,	0x4FC,	0x406,	0x59C,	0x488,	0x59C,	0x59C,	0x57A };
	static const uint16 wpa_trigger_lo[] = {
		0x0B3,	0x0B3,	0x0B3,	0x0B3,	0x096,	0x096,	0x096,	0x0B3,	0x096 };
	static const uint16 wpa_trigger_hi[] = {
		0x21B,	0x21B,	0x21B,	0x21B,	0x1C2,	0x1C2,	0x1C2,	0x21B,	0x1C2 };
	static const uint16 lp_lockout_start[] = {
		0x206,	0x206,	0x206,	0x206,	0x263,	0x263,	0x263,	0x206,	0x263 };
	// PAL: changed 0x2c to 0x0c; NTSC: changed 0x21 to 0x0b
	static const uint16 lp_lockout_end[] = {
		0x00B,	0x00B,	0x00B,	0x00B,	0x00C,	0x00C,	0x00C,	0x00B,	0x00C };

	PRINT(("CTheater100::SetLuminanceProcessor(%c)\n", "NJ4MNCB6S"[standard]));

	SetRegister(VIP_LP_AGC_CLAMP_CNTL0, SYNCTIP_REF0, synctip_ref0[standard] << 0);
	SetRegister(VIP_LP_AGC_CLAMP_CNTL0, SYNCTIP_REF1, (uint32)synctip_ref1[standard] << 8);
	SetRegister(VIP_LP_AGC_CLAMP_CNTL0, CLAMP_REF, (uint32)clamp_ref[standard] << 16);
	SetRegister(VIP_LP_AGC_CLAMP_CNTL0, AGC_PEAKWHITE, (uint32)agc_peakwhite[standard] << 24);
	SetRegister(VIP_LP_AGC_CLAMP_CNTL1, VBI_PEAKWHITE, (uint32)vbi_peakwhite[standard] << 0);
	
	SetRegister(VIP_LP_WPA_CNTL0, WPA_THRESHOLD, wpa_threshold[standard] << 0);
	SetRegister(VIP_LP_WPA_CNTL1, WPA_TRIGGER_LO, wpa_trigger_lo[standard] << 0);
	SetRegister(VIP_LP_WPA_CNTL1, WPA_TRIGGER_HI, (uint32)wpa_trigger_hi[standard] << 16);
	SetRegister(VIP_LP_VERT_LOCKOUT, LP_LOCKOUT_START, lp_lockout_start[standard] << 0);
	SetRegister(VIP_LP_VERT_LOCKOUT, LP_LOCKOUT_END, (uint32)lp_lockout_end[standard] << 16);
}


// setup brightness and contrast
void CTheater100::SetLuminanceLevels(theater_standard standard, int brightness, int contrast)
{
	double ref0, setup, gain;

	ref0 = Register(VIP_LP_AGC_CLAMP_CNTL0, SYNCTIP_REF0);

	switch (standard) {
	case C_THEATER_NTSC:
	case C_THEATER_PAL_M:
	case C_THEATER_NTSC_443:
		setup = 7.5 * ref0 / 40.0;
		gain = 219.0 / (92.5 * ref0 / 40.0);
		break;

	case C_THEATER_NTSC_JAPAN:
		setup = 0.0;
		gain = 219.0 / (100.0 * ref0 / 40.0);
		break;

	case C_THEATER_PAL_BDGHI:
	case C_THEATER_PAL_N:
	case C_THEATER_SECAM:
	case C_THEATER_PAL_60:
	case C_THEATER_PAL_NC:
		setup = 0.0;
		gain = 219.0 / (100.0 * ref0 / 43.0);
		break;
		
	default:
		setup = 0.0;
		gain = 0.0;
		break;
	}

	if (contrast <= -100)
		contrast = -99;

	/* set luminance processor constrast (7:0) */
	SetRegister(VIP_LP_CONTRAST, CONTRAST,
		int(64.0 * ((contrast + 100) / 100.0) * gain) << 0);

	/* set luminance processor brightness (13:0) */
	SetRegister(VIP_LP_BRIGHTNESS, BRIGHTNESS,
		int(16.0 * ((brightness - setup) + 16.0 / ((contrast + 100) * gain / 100.0))) & BRIGHTNESS);
}


// setup chroma demodulator
void CTheater100::SetChromaProcessor(theater_standard standard)
{
	PRINT(("CTheater100::SetChromaProcessor(%c)\n", "NJ4MNCB6S"[standard]));
	
	static const uint32 ch_dto_inc[] = {
		0x400000,	0x400000,	0x400000,	0x400000,	0x400000,	0x400000,	0x400000,	0x400000,	0x3E7A28 };
	static const uint8 ch_pll_sgain[] = {
		1,		1,		1,		1,		1,		1,		1,		1,		5 };
	static const uint8 ch_pll_fgain[] = {
		2,		2,		2,		2,		2,		2,		2,		2,		6 };
		
	static const uint8 ch_height[] = {
		0xCD,	0xCD,	0xCD,	0x91,	0x91,	0x9C,	0x9C,	0x9C,	0x66 };
	static const uint8 ch_kill_level[] = {
		0x0C0,	0xC0,	0xC0,	0x8C,	0x8C,	0x90,	0x90,	0x90,	0x60 };
	static const uint8 ch_agc_error_lim[] = {
		2,		2,		2,		2,		2,		2,		2,		2,		3 };
	static const uint8 ch_agc_filter_en[] = {
		0,		0,		0,		0,		0,		0,		1,		0,		0 };
	static const uint8 ch_agc_loop_speed[] = {
		0,		0,		0,		0,		0,		0,		0,		0,		0 };
		
	static const uint16 cr_burst_gain[] = {
		0x7A,	0x71,	0x7A,	0x7A,	0x7A,	0x7A,	0x7A,	0x7A,	0x1FF };
	static const uint16 cb_burst_gain[] = {
		0xAC,	0x9F,	0xAC,	0xAC,	0xAC,	0xAB,	0xAB,	0xAB,	0x1FF };
	static const uint16 crdr_active_gain[] = {
		0x7A,	0x71,	0x7A,	0x7A,	0x7A,	0x7A,	0x7A,	0x7A,	0x11C };
	static const uint16 cbdb_active_gain[] = {
		0xAC,	0x9F,	0xAC,	0xAC,	0xAC,	0xAB,	0xAB,	0xAB,	0x15A };
	static const uint16 cp_vert_lockout_start[] = {
		0x207,	0x207,	0x207,	0x207,	0x269,	0x269,	0x269,	0x207,	0x269 };
	static const uint8 cp_vert_lockout_end[] = {
		0x00E,	0x00E,	0x00E,	0x00E,	0x00E,	0x012,	0x012,	0x00E,	0x012 };

	SetRegister(VIP_CP_PLL_CNTL0, CH_DTO_INC, ch_dto_inc[standard] << 0);
	SetRegister(VIP_CP_PLL_CNTL0, CH_PLL_SGAIN, (uint32)ch_pll_sgain[standard] << 24);
	SetRegister(VIP_CP_PLL_CNTL0, CH_PLL_FGAIN, (uint32)ch_pll_fgain[standard] << 28);

	SetRegister(VIP_CP_AGC_CNTL, CH_HEIGHT, ch_height[standard] << 0);	
	SetRegister(VIP_CP_AGC_CNTL, CH_KILL_LEVEL, (uint32)ch_kill_level[standard] << 8);
	SetRegister(VIP_CP_AGC_CNTL, CH_AGC_ERROR_LIM, (uint32)ch_agc_error_lim[standard] << 16);
	SetRegister(VIP_CP_AGC_CNTL, CH_AGC_FILTER_EN, (uint32)ch_agc_filter_en[standard] << 18);
	SetRegister(VIP_CP_AGC_CNTL, CH_AGC_LOOP_SPEED, (uint32)ch_agc_loop_speed[standard] << 19);

	SetRegister(VIP_CP_BURST_GAIN, CR_BURST_GAIN, cr_burst_gain[standard] << 0);
	SetRegister(VIP_CP_BURST_GAIN, CB_BURST_GAIN, (uint32)cb_burst_gain[standard] << 16);
	
	SetRegister(VIP_CP_ACTIVE_GAIN, CRDR_ACTIVE_GAIN, crdr_active_gain[standard] << 0);
	SetRegister(VIP_CP_ACTIVE_GAIN, CBDB_ACTIVE_GAIN, (uint32)cbdb_active_gain[standard] << 16);

	SetRegister(VIP_CP_VERT_LOCKOUT, CP_LOCKOUT_START, cp_vert_lockout_start[standard] << 0);
	SetRegister(VIP_CP_VERT_LOCKOUT, CP_LOCKOUT_END, (uint32)cp_vert_lockout_end[standard] << 16);
}


// set colour saturation and hue.
// hue makes sense for NTSC only and seems to act as saturation for PAL
void CTheater100::SetChromaLevels(theater_standard standard, int saturation, int hue)
{
	int ref0;
	double gain, CRgain, CBgain;

	/* compute Cr/Cb gains */
	ref0 = Register(VIP_LP_AGC_CLAMP_CNTL0, SYNCTIP_REF0);

	switch (standard) {
	case C_THEATER_NTSC:
	case C_THEATER_NTSC_443:
	case C_THEATER_PAL_M:
		CRgain = (40.0 / ref0) * (100.0 / 92.5) * (1.0 / 0.877) * (112.0 / 70.1) / 1.5;
		CBgain = (40.0 / ref0) * (100.0 / 92.5) * (1.0 / 0.492) * (112.0 / 88.6) / 1.5;
		break;

	case C_THEATER_NTSC_JAPAN:
		CRgain = (40.0 / ref0) * (100.0 / 100.0) * (1.0 / 0.877) * (112.0 / 70.1) / 1.5;
		CBgain = (40.0 / ref0) * (100.0 / 100.0) * (1.0 / 0.492) * (112.0 / 88.6) / 1.5;
		break;

	case C_THEATER_PAL_BDGHI:
	case C_THEATER_PAL_60:
	case C_THEATER_PAL_NC:
	case C_THEATER_PAL_N:
		CRgain = (43.0 / ref0) * (100.0 / 92.5) * (1.0 / 0.877) * (112.0 / 70.1) / 1.5;
		CBgain = (43.0 / ref0) * (100.0 / 92.5) * (1.0 / 0.492) * (112.0 / 88.6) / 1.5;
		break;

	case C_THEATER_SECAM:
		CRgain = 32.0 * 32768.0 / 280000.0 / (33554432.0 / 35.46985) * (1.597 / 1.902) / 1.5;
		CBgain = 32.0 * 32768.0 / 230000.0 / (33554432.0 / 35.46985) * (1.267 / 1.505) / 1.5;
		break;
	
	default:
		PRINT(("CTheater100::SetChromaLevels() - Bad standard\n"));
		CRgain = 0.0;
		CBgain = 0.0;
		break;
	}
	
	if (saturation >= 0)
		gain = 1.0 + 4.9 * saturation / 100.0;
	else
		gain = 1.0 + saturation / 100.0;
		
	SetRegister(VIP_CP_ACTIVE_GAIN, CRDR_ACTIVE_GAIN, int(128 * CRgain * gain) << 0);
	SetRegister(VIP_CP_ACTIVE_GAIN, CBDB_ACTIVE_GAIN, int(128 * CBgain * gain) << 16);

	if (hue >= 0)
		hue = (256 * hue) / 360;
	else
		hue = (256 * (hue + 360)) / 360;

	SetRegister(VIP_CP_HUE_CNTL, HUE_ADJ, hue << 0);
}


// these values are used by scaler as well
static const uint16 h_active_start[] = {
	0x06b,	0x06B,	0x07E,	0x067,	0x09A,	0x07D,	0x09A,	0x084,	0x095 };
static const uint16 h_active_end[] = {
	0x363,	0x363,	0x42A,	0x363,	0x439,	0x439,	0x439,	0x363,	0x439 };
static const uint16 v_active_start[] = {
	0x025,	0x025,	0x025,	0x025,	0x02E,	0x02E,	0x02E,	0x025,	0x02E };
// PAL height is too small (572 instead of 576 lines), but changing 0x269 to 0x26d
// leads to trouble, and the last 2 lines seem to be used for VBI data 
// (read: garbage) anyway
static const uint16 v_active_end[] = {
	0x204,	0x204,	0x204,	0x204,	0x269,	0x269,	0x269,	0x204,	0x269 };
static const uint16 h_vbi_wind_start[] = {
	0x064,	0x064,	0x064,	0x064,	0x084,	0x084,	0x084,	0x064,	0x084 };
static const uint16 h_vbi_wind_end[] = {
	0x366,	0x366,	0x366,	0x366,	0x41F,	0x41F,	0x41F,	0x366,	0x41F };
static const uint16 v_vbi_wind_start[] = {
	0x00b,	0x00b,	0x00b,	0x00b,	0x008,	0x008,	0x008,	0x00b,	0x008 };
static const uint16 v_vbi_wind_end[] = {
	0x024,	0x024,	0x024,	0x024,	0x02d,	0x02d,	0x02d,	0x024,	0x02d };
	
void CTheater100::getActiveRange( theater_standard standard, CRadeonRect &rect )
{
	rect.SetTo( 
		h_active_start[standard], v_active_start[standard],
		h_active_end[standard], v_active_end[standard] );
}

void CTheater100::getVBIRange( theater_standard standard, CRadeonRect &rect )
{
	rect.SetTo( 
		h_vbi_wind_start[standard], v_vbi_wind_start[standard],
		h_vbi_wind_end[standard], v_vbi_wind_end[standard] );
}

// program clipping engine
void CTheater100::SetClipWindow(theater_standard standard, bool vbi)
{		
	// set horizontal active window
	SetRegister(VIP_H_ACTIVE_WINDOW, H_ACTIVE_START, h_active_start[standard] << 0);
	SetRegister(VIP_H_ACTIVE_WINDOW, H_ACTIVE_END, (uint32)h_active_end[standard] << 16);
	
	// set vertical active window
	SetRegister(VIP_V_ACTIVE_WINDOW, V_ACTIVE_START, v_active_start[standard] << 0);
	SetRegister(VIP_V_ACTIVE_WINDOW, V_ACTIVE_END, (uint32)v_active_end[standard] << 16);
	
	// set horizontal VBI window
	SetRegister(VIP_H_VBI_WINDOW, H_VBI_WIND_START, h_vbi_wind_start[standard] << 0);
	SetRegister(VIP_H_VBI_WINDOW, H_VBI_WIND_END, (uint32)h_vbi_wind_end[standard] << 16);
	
	// set vertical VBI window
	SetRegister(VIP_V_VBI_WINDOW, V_VBI_WIND_START, v_vbi_wind_start[standard] << 0);
	SetRegister(VIP_V_VBI_WINDOW, V_VBI_WIND_END, (uint32)v_vbi_wind_end[standard]  << 16);

	// set VBI scaler control
	SetRegister(VIP_VBI_SCALER_CONTROL, (1 << 16) & VBI_SCALING_RATIO);
	
	// enable/disable VBI capture
	SetRegister(VIP_VBI_CONTROL, VBI_CAPTURE_ENABLE,
		vbi ? VBI_CAPTURE_EN : VBI_CAPTURE_DIS);
	
	PRINT(("CTheater100::SetClipWindow(active=%d/%d/%d/%d, vbi=%d/%d/%d/%d)\n",
		Register(VIP_H_ACTIVE_WINDOW, H_ACTIVE_START) >> 0,
		Register(VIP_H_ACTIVE_WINDOW, H_ACTIVE_END) >> 16,
		Register(VIP_V_ACTIVE_WINDOW, V_ACTIVE_START) >> 0,
		Register(VIP_V_ACTIVE_WINDOW, V_ACTIVE_END) >> 16,
		Register(VIP_H_VBI_WINDOW, H_VBI_WIND_START) >> 0,
		Register(VIP_H_VBI_WINDOW, H_VBI_WIND_END) >> 16,
		Register(VIP_V_VBI_WINDOW, V_VBI_WIND_START) >> 0,
		Register(VIP_V_VBI_WINDOW, V_VBI_WIND_END) >> 16));
		
}


// setup capture scaler.
void CTheater100::SetScaler(theater_standard standard, int hactive, int vactive, bool deinterlace)
{
	int oddOffset, evenOffset;
	uint16 h_active_width, v_active_height;
	
//	ASSERT(vactive <= 511);

	// TK: Gatos uses different values here
	h_active_width = h_active_end[standard] - h_active_start[standard] + 1;
	v_active_height = v_active_end[standard] - v_active_start[standard] + 1;
	
	// for PAL, we have 572 lines only, but need 576 lines;
	// my attempts to find those missing lines all failed, so if the application requests
	// 576 lines, we had to upscale the video which is not supported by hardware;
	// solution: restrict to 572 lines - the scaler will fill out the missing lines with black
	if( vactive > v_active_height )
		vactive = v_active_height;
	
	if (deinterlace) {
		// progressive scan
		evenOffset = oddOffset = 512 - (int) ((512 * vactive) / v_active_height);
	}
	else {
		// interlaced
		evenOffset = (int) ((512 * vactive) / v_active_height);
		oddOffset = 2048 - evenOffset;
	}

	// set scale input window
	SetRegister(VIP_SCALER_IN_WINDOW, H_IN_WIND_START, h_active_start[standard] << 0);
	SetRegister(VIP_SCALER_IN_WINDOW, V_IN_WIND_START, (uint32)v_active_start[standard] << 16);

	SetRegister(VIP_SCALER_OUT_WINDOW, H_OUT_WIND_WIDTH, hactive << 0);
	SetRegister(VIP_SCALER_OUT_WINDOW, V_OUT_WIND_HEIGHT, (vactive / 2) << 16);

	SetRegister(VIP_H_SCALER_CONTROL, H_SCALE_RATIO, (((uint32)h_active_width << 16) / hactive) << 0);
	SetRegister(VIP_V_SCALER_CONTROL, V_SCALE_RATIO, ((vactive << 11) / v_active_height) << 0);

	// enable horizontal and vertical scaler
	SetRegister(VIP_H_SCALER_CONTROL, H_BYPASS, 
		h_active_width == hactive ? H_BYPASS : 0);
	SetRegister(VIP_V_SCALER_CONTROL, V_BYPASS, 
		v_active_height == vactive ? V_BYPASS : 0);

	// set deinterlace control
	SetRegister(VIP_V_SCALER_CONTROL, V_DEINTERLACE_ON, deinterlace ? V_DEINTERLACE_ON : 0);
	SetRegister(VIP_V_DEINTERLACE_CONTROL, EVENF_OFFSET, evenOffset << 0);
	SetRegister(VIP_V_DEINTERLACE_CONTROL, ODDF_OFFSET, oddOffset << 11);

	SetRegister(VIP_V_SCALER_CONTROL, V_DEINTERLACE_ON, deinterlace ? V_DEINTERLACE_ON : 0);
	
	PRINT(("CTheater100::SetScaler(active=%d/%d/%d/%d, scale=%d/%d)\n",
		Register(VIP_SCALER_IN_WINDOW, H_IN_WIND_START) >> 0,
		Register(VIP_SCALER_IN_WINDOW, V_IN_WIND_START) >> 16,
		hactive, vactive,
		Register(VIP_H_SCALER_CONTROL, H_SCALE_RATIO),
		Register(VIP_V_SCALER_CONTROL, V_SCALE_RATIO)));
}

int CTheater100::CurrentLine()
{
	return Register(VIP_VS_LINE_COUNT) & VS_LINE_COUNT;
}

void CTheater100::PrintToStream()
{
	PRINT(("<<< Rage Theater Registers >>>\n"));
	for (int index = 0x0400; index <= 0x06ff; index += 4) {
		int value = Register(index);
		value = value; // unused var if debug is off
		PRINT(("REG_0x%04x = 0x%08x\n", index, value));
	}	
}