mcrvsn.c

这是一个SIGMA方案的PMP播放器的UCLINUX程序,可播放DVD,VCD,CD MP3...有很好的参考价值.

	*(pN + 11+3) = (WORD)ITvEncoder_Read(pITvEncoder, 0x1F39);
	*(pN + 12+3) = (WORD)ITvEncoder_Read(pITvEncoder, 0x1F3A);
	*(pN + 13+3) = LOBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3B));
	*(pN + 14+3) = HIBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3B));
	*(pN + 15+3) = LOBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3C));
	*(pN + 16+3) = HIBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3C));
	*(pN + 17+3) = LOBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3D));
	*(pN + 18+3) = HIBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3D));
	*(pN + 19+3) = LOBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3E));
	*(pN + 20+3) = HIBYTE(ITvEncoder_Read(pITvEncoder, 0x1F3E));
	*(pN + 21+3) = (WORD)ITvEncoder_Read(pITvEncoder, 0x1F3F);
	*(pN + 22+3) = HIBYTE(ITvEncoder_Read(pITvEncoder, 0x1F33));

	CSigmaTv__EndAccessMacrovision(pITvEncoder);
}

void CSigmaTv__WriteMacrovision( ITvEncoder* pITvEncoder, WORD* pN )
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;
	DWORD data = 0;
	DWORD QuasarVersion = IDecoder_GetQuasarVersion(this->m_pIDecoder);

	CSigmaTv__StartAccessMacrovision(pITvEncoder);

	if( QuasarVersion >= EM847XA_Q4 )
		data = ((*(pN + 22 + 3))<<8) | *(pN + 0);	// N22 from table
	else
		data = *(pN + 0);	// N22 not supported
	ITvEncoder_Write(pITvEncoder, 0x1F33, data);

	data = ((*(pN + 2))<<8) | *(pN + 1);
	ITvEncoder_Write(pITvEncoder, 0x1F34, data);
	data = ((*(pN + 4))<<8) | *(pN + 3);
	ITvEncoder_Write(pITvEncoder, 0x1F35, data);
	data = ((*(pN + 6))<<8) | *(pN + 5);
	ITvEncoder_Write(pITvEncoder, 0x1F36, data);

	data = (((*(pN + 8)) & 7)<<3) | ((*(pN + 8+1)) & 7);
	data = (data<<8) | *(pN + 7);
	ITvEncoder_Write(pITvEncoder, 0x1F37, data);
	data = (((*(pN + 10+2)) & 7)<<3) | ((*(pN + 10+3)) & 7);
	data = (data<<8) | (((*(pN + 9+1)) & 7)<<3) | ((*(pN + 9+2)) & 7);
	ITvEncoder_Write(pITvEncoder, 0x1F38, data);

	ITvEncoder_Write(pITvEncoder, 0x1F39, *(pN + 11+3));
	ITvEncoder_Write(pITvEncoder, 0x1F3A, *(pN + 12+3));

	data = ((*(pN + 14+3))<<8) | *(pN + 13+3);
	ITvEncoder_Write(pITvEncoder, 0x1F3B, data);
	data = ((*(pN + 16+3))<<8) | *(pN + 15+3);
	ITvEncoder_Write(pITvEncoder, 0x1F3C, data);
	data = ((*(pN + 18+3))<<8) | *(pN + 17+3);
	ITvEncoder_Write(pITvEncoder, 0x1F3D, data);
	data = ((*(pN + 20+3))<<8) | *(pN + 19+3);
	ITvEncoder_Write(pITvEncoder, 0x1F3E, data);

	ITvEncoder_Write(pITvEncoder, 0x1F3F, *(pN + 21+3));

	CSigmaTv__EndAccessMacrovision(pITvEncoder);
}

void CSigmaTv__EnableMacrovision(ITvEncoder* pITvEncoder, DWORD Level)	// should be protected
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;
	WORD* pMcrVsn;
	DWORD QuasarVersion = IDecoder_GetQuasarVersion(this->m_pIDecoder);
	int i;

	if(Level == CURRENT_MACROVISION)	
		Level = this->CurrentMacrovision;
	else
		this->CurrentMacrovision = Level;

	// check CGMS capability on fly - only EM847X support it
	if( QuasarVersion >= EM847XA_Q4 )
	{
		CSigmaTv__StartAccessReg(pITvEncoder);
		ITvEncoder_Write( pITvEncoder, SIGMATV_CONFIG, 0x4000 | this->SigmaTvRegs[0] );// change set
		if( this->CurrentTvStandard == SET_NTSC)
		{
		// CGMS= copy generation management system= bit3,2= copyright, copy generation
		// APS= analogue protection system= bit1,0= pseudo sync pulse, inverted split color burst
		// IEC 61880 - Video and accompanied data using the vertical blanking interval
		// WORD0 = aspect ratio = 00,01,10,11 = 4x3,16x9,letterbox,reserved
		// WORD1 = 0000, 1111 = WORD2 valid info, no info
		// WORD2 = bit 7,8= copyright, bits 9,10 = APS; bit 11=analog source
		//	        +-WORD0-+---WORD1----+--------WORD2------------+-------CRCC-------+
		//Bit:         1  2    3  4  5  6   7  8  9 10 11 12 13 14   15 16 17 18 19 20
		//0x1f32,bit:  0  1    2  3  4  5   6  7  8  9 10 11 12 13   14 15
		//0x1f33,bit:													    0  1  2  3
		//0x1f33: bit5= SoftwareCRC generation, bit7/6= CGMS enabled on odd/even field
			WORD temp = 
				((Level & 1) ? 8 : 0) |
				((Level & 2) ? 4 : 0) |
				((Level & 4) ? 2 : 0) |
				((Level & 8) ? 1 : 0);
			QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("CGMS for NTSC Level=%x -> %x"), Level, temp ));

			// programm IEC_Bits 7,8,9,10 according to evMacrovisionFlags
			this->SigmaTvRegs35[3] = (WORD)(((this->CGMSWSS ^ 0xc0000000)>>24) | ((this->CGMSWSS & 0xF0000)>>16));
			this->SigmaTvRegs35[2] = (WORD)((this->CGMSWSS & 0xF03F) | (temp << 6));
		}
		else
		{
			this->SigmaTvRegs35[3] = 0;//(WORD)(((this->CGMSWSS ^ 0xc0000000)>>24) | ((this->CGMSWSS & 0xF0000)>>16));
			this->SigmaTvRegs35[2] = 0;//(WORD)((this->CGMSWSS & 0xF03F) | (temp << 6));
			QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("WSS for not NTSC not implemented ") ));
		}

		ITvEncoder_Write( pITvEncoder, SIGMATV_CONFIG+2, this->SigmaTvRegs35[2] );
		ITvEncoder_Write( pITvEncoder, SIGMATV_CONFIG+3, this->SigmaTvRegs35[3] );

		ITvEncoder_Write( pITvEncoder, SIGMATV_CONFIG, this->SigmaTvRegs[0] );// change set
		CSigmaTv__EndAccessReg(pITvEncoder);
	}

	Level &= MACROVISION_APS_MASK;
	CSigmaTv__StartAccessMacrovision(pITvEncoder);
	if(Level == MACROVISION_APS_OFF)	// Disable Macrovision
		pMcrVsn = SigmaTvMacrovisionOff;
	else	//Enable Macrovision
	{
		if( this->CurrentTvStandard == evTvHdtvStandard_480P )
			pMcrVsn = SigmaTv480PMacrovisionOn;
		else if( this->CurrentTvStandard == evTvHdtvStandard_576P )
			pMcrVsn = SigmaTv576PMacrovisionOn;
		else if( this->CurrentTvStandard == SET_PAL )	// No levels for PAL macrovision
			pMcrVsn = SigmaTvPalMacrovisionOn;
		else if( this->CurrentTvStandard == SET_PAL60 )// No levels for PAL60 macrovision
			pMcrVsn = SigmaTvNtscMacrovision1;
		else	// assume NTSC mode
		{
			switch(Level)
			{
			case MACROVISION_APS_1:
				pMcrVsn = SigmaTvNtscMacrovision1;
				break;
			case MACROVISION_APS_2:
				pMcrVsn = SigmaTvNtscMacrovision2;
				break;
			case MACROVISION_APS_3:
			default:
				pMcrVsn = SigmaTvNtscMacrovision3;
				break;
			}
		}

/*		if( QuasarVersion >= EM847XA_Q4 )
		{
// N22 enables the RGB macrovision. It should be 0 for any DVD macrovision but AD717X has macrovision enabled
			if( (this->YcYuvRgb == COMPONENT_RGB) || (this->YcYuvRgb == COMPONENT_RGB_SCART) )
				pMcrVsn[0] |= 0x100;	// N22 is 1
			else
				pMcrVsn[0] &= ~0x100;	// N22 is 0
		}
*/
	}
	for (i=0;i<13; i++)
		ITvEncoder_Write( pITvEncoder, SIGMATV_CONFIG+3+i, pMcrVsn[i] );
	CSigmaTv__EndAccessMacrovision(pITvEncoder);
}

void CAD7170__EnableMacrovision( ITvEncoder* pITvEncoder, DWORD Level)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;
	BYTE CGMS_WSS[3] = {0,0,0};

	if(Level == CURRENT_MACROVISION)	
		Level = this->CurrentMacrovision;
	else
		this->CurrentMacrovision = Level;

	if( this->CurrentTvStandard == SET_NTSC)
	{
		CGMS_WSS[0] = 0x70;// reg 0x16 = CGMS_WSS_0
		CGMS_WSS[1] = // (BYTE)Level & MACROVISION_APS_MASK;	// reg 0x17 = CGMS_WSS_1
			((Level & 0x01) ? 0x02 : 0)
		  + ((Level & 0x02) ? 0x01 : 0);	// Bits are inverted (Jacques)
		CGMS_WSS[2] = // (BYTE)(BYTE)( (Level & MACROVISION_CGMS_MASK)<<4 );	// reg 0x18 = CGMS_WSS_2
			((Level & 0x04) ? 0x80 : 0)
		  + ((Level & 0x08) ? 0x40 : 0);	// Bits are inverted (Jacques)
		II2C_Write((II2C*)this->m_pII2C, 0x16, CGMS_WSS, 3);
	}
	else
	{
		CGMS_WSS[0] = 0x00;	// reg 0x16 = CGMS_WSS_0
		CGMS_WSS[1] = 0x00;	// reg 0x17 = CGMS_WSS_1
		CGMS_WSS[2] = 0x00;	// reg 0x18 = CGMS_WSS_2
		II2C_Write((II2C*)this->m_pII2C, 0x16, CGMS_WSS, 3);
	}

	Level &= MACROVISION_APS_MASK;
	if(Level == MACROVISION_APS_OFF)//Disable Macrovision
	{
		if( this->CurrentTvStandard == SET_PAL )
		{
			// disable pal macrovision
			II2C_Write((II2C*)this->m_pII2C, 0x1e, PalMacrovisionOff + 1, 18);
			return;
		}
		II2C_Write((II2C*)this->m_pII2C, 0x1e, DisMacroVision, 18);
	}
	else	//Enable Macrovision
	{
		if( this->CurrentTvStandard == SET_PAL )
		{
			// PAL mode. No levels for PAL macrovision
			II2C_Write((II2C*)this->m_pII2C, 0x1e, PalMacrovisionOn + 1, 18);
			return;
		}
		else if( this->CurrentTvStandard == SET_PAL60 )
		{
			switch(Level)
			{
			case MACROVISION_APS_1:
				II2C_Write((II2C*)this->m_pII2C, 0x1e, Pal60MacroVision01 + 1, 18);
				break;
			case MACROVISION_APS_2:
				II2C_Write((II2C*)this->m_pII2C, 0x1e, Pal60MacroVision10 + 1, 18);
				break;
			case MACROVISION_APS_3:
			default:
				II2C_Write((II2C*)this->m_pII2C, 0x1e, Pal60MacroVision11 + 1, 18);
				break;
			}
		}
		else
		{
			// assume NTSC mode
			switch(Level)
			{
			case MACROVISION_APS_1:
				II2C_Write((II2C*)this->m_pII2C, 0x1e, MacroVision01 + 1, 18);
				break;
			case MACROVISION_APS_2:
				II2C_Write((II2C*)this->m_pII2C, 0x1e, MacroVision10 + 1, 18);
				break;
			case MACROVISION_APS_3:
			default:
				II2C_Write((II2C*)this->m_pII2C, 0x1e, MacroVision11 + 1, 18);
				break;
			}
		}
	}
}

void CAD7175__EnableMacrovision( ITvEncoder* pITvEncoder, DWORD Level)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;

	if(Level == CURRENT_MACROVISION)	
		Level = this->CurrentMacrovision;
	else
		this->CurrentMacrovision = Level;

	Level &= MACROVISION_APS_MASK;
	if(Level == MACROVISION_APS_OFF)//Disable Macrovision
	{
		if( this->CurrentTvStandard == SET_PAL )
		{
			// disable pal macrovision
			II2C_Write((II2C*)this->m_pII2C, 18, PalMacrovisionOff, 18);
			return;
		}
		II2C_Write((II2C*)this->m_pII2C, 18, DisMacroVision, 18);
	}
	else	//Enable Macrovision
	{
		if( this->CurrentTvStandard == SET_PAL )
		{
			// PAL mode. No levels for PAL macrovision
			II2C_Write((II2C*)this->m_pII2C, 18, PalMacrovisionOn, 18);
			return;
		}
		else if( this->CurrentTvStandard == SET_PAL60 )
		{
			switch(Level)
			{
			case MACROVISION_APS_1:
				II2C_Write((II2C*)this->m_pII2C, 18, Pal60MacroVision01, 18);
				break;
			case MACROVISION_APS_2:
				II2C_Write((II2C*)this->m_pII2C, 18, Pal60MacroVision10, 18);
				break;
			case MACROVISION_APS_3:
			default:
				II2C_Write((II2C*)this->m_pII2C, 18, Pal60MacroVision11, 18);
				break;
			}
		}
		else
		{
			// assume NTSC mode
			switch(Level)
			{
			case MACROVISION_APS_1:
				II2C_Write((II2C*)this->m_pII2C, 18, MacroVision01, 18);
				break;
			case MACROVISION_APS_2:
				II2C_Write((II2C*)this->m_pII2C, 18, MacroVision10, 18);
				break;
			case MACROVISION_APS_3:
			default:
				II2C_Write((II2C*)this->m_pII2C, 18, MacroVision11, 18);
				break;
			}
		}
	}
}

void CAD7177__EnableMacrovision( ITvEncoder* pITvEncoder, DWORD Level)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;

	if(Level == CURRENT_MACROVISION)	
		Level = this->CurrentMacrovision;
	else
		this->CurrentMacrovision = Level;

	Level &= MACROVISION_APS_MASK;
	if(Level)	// don't play macrovision movies
	{
		*(this->TVRegsTable + 7) &= ~8;			// BlackOut for TV
		II2C_Write((II2C*)this->m_pII2C, 7, this->TVRegsTable + 7, 1);
	}
}

////////////////////////////////////////////////////////////////////////////
#if defined FS400_OBJECT

#include "ci2c.h"
#include "cfs400.h"

#define FS402_MV_REGISTERS 10
#define FS402_MVC 0x40

//FS400macrovision hex addr: 40-1 42-3 44-5 46-7 48-9 4a-b 4c-d 4e-f 50-1 52-3
//                          MVC  MV1  MV2  MV3  MV4  MV5  MV6  MV7  MV8  MV9
WORD FS402_NTSCMacroVision[4][FS402_MV_REGISTERS]=
{
	// NTSC macrovision off
	{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
	// NTSC Automatic Gain Control Pulses Only - level 1
	{0x0063, 0xb27d, 0xb590, 0xbd66, 0xf309, 0x000c, 0x0f00, 0xd06f, 0xfc20, 0x000f},
	// NTSC Automatic Gain Control Pulses Plus 2 Line Color Stripe - lever 2
	{0x00e3, 0x32dd, 0x3192, 0xbd6c, 0xf309, 0x000c, 0x0f00, 0xd06f, 0xfc20, 0x000f},
	// NTSC Automatic Gain Control Pulses Plus 4 Line Color Stripe - level 3
	{0x00e3, 0xb27d, 0xb590, 0xbd66, 0xf309, 0x000c, 0x0f00, 0xd06f, 0xfc20, 0x000f}
};

WORD FS402_PALMacroVision[2][FS402_MV_REGISTERS]=
{
	// PAL macrovision off
	{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
	// PAL Automatic Gain Control Pulses Only - level 1
	{0x0063, 0x54a5, 0xa225, 0xd378, 0xf105, 0x510f, 0x7ef4, 0x406e, 0x5720, 0x0005},
};

/****f* HwLib/IScanConverter_EnableMacrovision
 * USAGE
 *	BOOL IScanConverter_EnableMacrovision( IScanConverter* pIScanConverter, DWORD Level)
 *	BOOL Cfs400__EnableMacrovision(IScanConverter* pIScanConverter, DWORD Level)
 * DESCRIPTION
 *	IScanConverter_EnableMacrovision - sets the macrovision level according to the Tv standard.
 * PARAMETERS
 *	IN IScanConverter* pIScanConverter - pointer to the ScanConverter object
 *	IN DWORD Level - macrovision level
/********************************************************************************************/
// APS= analogue protection system= bit1,0= pseudo sync pulse, inverted split color burst
#define CURRENT_MACROVISION		0xFF
BOOL Cfs400__EnableMacrovision(IScanConverter* pIScanConverter, DWORD Level)
{
	Cfs400* this = (Cfs400*) pIScanConverter;
	int i;
	WORD* pw = &FS402_NTSCMacroVision[0][0];

	if(Level != CURRENT_MACROVISION)	
		this->CurrentMacrovision = Level & MACROVISION_APS_MASK;

	if(this->CurrentMacrovision != MACROVISION_APS_OFF)
	{
		if( this->CurrentTvStandard == SET_PAL )
			pw = &FS402_PALMacroVision[0][1];
		else
			// assume NTSC mode
			pw += this->CurrentMacrovision*FS402_MV_REGISTERS;
	}
	for(i=0; i<FS402_MV_REGISTERS; i++)
		Cfs400__Write(pIScanConverter, FS402_MVC + 2*i, pw + i);

	return TRUE;
}

#endif // FS400_OBJECT