csigmatv.c

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

/******************************************************************************/
/*  CSigmaTv.c : Implementation of the SigmaTv interface
*  REALmagic Quasar Hardware Library
*  Created by Aurelia Popa-Radu
*  Copyright Sigma Designs Inc
*  Sigma Designs Proprietary and confidential
*  Created on 9/23/99
*  Description:
/******************************************************************************/

/****h* HwLib/CSigmaTv_implementation
 * NAME
 *	HwLib/CSigmaTv_implementation
 * DESCRIPTION
 *  CSigmaTv implementation of the ITvEncoder interface:
 *  void CSigmaTv__Init(ITvEncoder* pITvEncoder)
 *  void CSigmaTv__Write(ITvEncoder* pITvEncoder, DWORD addr, DWORD Data)
 *  DWORD CSigmaTv__Read(ITvEncoder* pITvEncoder, DWORD addr)
 *  BOOL CSigmaTv__WriteN(ITvEncoder* pITvEncoder, DWORD addr, BYTE* pData, int n)
 *  BOOL CSigmaTv__ReadN(ITvEncoder* pITvEncoder, DWORD addr, BYTE* pData, int n)
 *  void CSigmaTv__SetTVStandard(ITvEncoder* pITvEncoder, DWORD TvStandard)
 *  void CSigmaTv__SendCCData(ITvEncoder* pITvEncoder, BYTE field, BYTE* pData)
 *  void CSigmaTv__ShowCloseCaption(ITvEncoder* pITvEncoder)
 *  void CSigmaTv__HideCloseCaption(ITvEncoder* pITvEncoder)
 * COPYRIGHT
 *  Copyright Sigma Designs Inc
 *  Sigma Designs Proprietary and confidential
/******************************************************************************/

#include "pch.h"

#include "ctvenc.h"
#include "csigmatv.h"
#include "regs840x.h"

//WORD SigmaTv_NtscMaster_G[]={1716, 1,  0,  525,  1,  1,  1,  0, 263, 859, 263, 858};
WORD SigmaTv_NtscMaster[]	= {1716, 2,200,  525,  1,100,  2,958, 263, 958, 265, 100};
WORD SigmaTv_NtscMasterInv[]= {1716, 2,200,  525,  1,958,  3,100, 264, 100, 265, 958};

//WORD SigmaTv_PalMaster_G[]= {1728, 1,  0,  625,  1,  1,  1,  0, 313, 865, 314, 864};
WORD SigmaTv_PalMaster[]	= {1728, 2,200,  625,  1,100,  2,964, 313, 964, 315, 100};
WORD SigmaTv_PalMasterInv[] = {1728, 2,200,  625,  1,964,  3,100, 314, 100, 315, 964};

WORD SigmaTv_NtscSlave656_G[]=	{1716,1686,246,  525, 20,  1,260,  0, 282, 859, 522, 858};
WORD SigmaTv_PalSlave656_G[]=	{1728,1680,240,  625, 23,  1,311,  0, 335, 865, 623, 864};


void CSigmaTv__InitVtable(ITvEncoder* pITvEncoder);

void CSigmaTv__Init(ITvEncoder* pITvEncoder)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;
	DWORD SymbolTableSize;

	QueryInterface(this->m_dwInstance, IID_IDECODER, (void**)&(this->m_pIDecoder));
	IDecoder_GetSymbolTable(this->m_pIDecoder, &this->pQ, &SymbolTableSize);

	// Initialize virtual table with proper functions
	this->VTable.Write					= CSigmaTv__Write;
	this->VTable.Read					= CSigmaTv__Read;
	this->VTable.WriteN					= CSigmaTv__WriteN;
	this->VTable.ReadN					= CSigmaTv__ReadN;
	this->VTable.SetTVStandard			= CSigmaTv__SetTVStandard;
	this->VTable.ReadMacrovision		= CSigmaTv__ReadMacrovision;
	this->VTable.WriteMacrovision		= CSigmaTv__WriteMacrovision;
	this->VTable.EnableMacrovision		= CSigmaTv__EnableMacrovision;
	this->VTable.SendCCData				= CSigmaTv__SendCCData;
	this->VTable.ShowCloseCaption		= CSigmaTv__ShowCloseCaption;
	this->VTable.HideCloseCaption		= CSigmaTv__HideCloseCaption;

	CSigmaTv__InitVtable(pITvEncoder);

	this->TVRegsTable = (BYTE*)this->SigmaTvRegs;

	// The following values are for NTSC
	this->SigmaTvRegs[0] = 0x0000;	// SIGMATV_CONFIG				0x1F30
	this->SigmaTvRegs[1] =   1716;	// SIGMATV_HSYNC_PERIOD			0x1F31
	this->SigmaTvRegs[2] =      2;	// SIGMATV_HSYNC_0				0x1F32
	this->SigmaTvRegs[3] =    200;	// SIGMATV_HSYNC_1				0x1F33
	this->SigmaTvRegs[4] =    525;	// SIGMATV_VSYNC_PERIOD			0x1F34
	this->SigmaTvRegs[5] =      1;	// SIGMATV_VSYNC_ODD_LINE_0		0x1F35
	this->SigmaTvRegs[6] =      2;	// SIGMATV_VSYNC_ODD_PIXEL_0	0x1F36
	this->SigmaTvRegs[7] =      2;	// SIGMATV_VSYNC_ODD_LINE_1		0x1F37
	this->SigmaTvRegs[8] =      2;	// SIGMATV_VSYNC_ODD_PIXEL_1	0x1F38
	this->SigmaTvRegs[9] =    263;	// SIGMATV_VSYNC_EVEN_LINE_0	0x1F39
	this->SigmaTvRegs[10] =   362;	// SIGMATV_VSYNC_EVEN_PIXEL_0	0x1F3A
	this->SigmaTvRegs[11] =   264;	// SIGMATV_VSYNC_EVEN_LINE_1	0x1F3B
	this->SigmaTvRegs[12] =   362;	// SIGMATV_VSYNC_EVEN_PIXEL_1	0x1F3C

// writing 0x4000(bit 14 set) in SIGMATV_CONFIG changes the functions of registers 0x1F31...0x1F36
	this->SigmaTvRegs35[0] = 	0x4000;	// SIGMATV_CONFIG				0x1F30
	this->SigmaTvRegs35[1] =	0x7200;	// SIGMATV_CONFIG2 = master		0x1F31
	this->SigmaTvRegs35[2] =	     0;	// SIGMATV_CGMS_LO_WSS			0x1F32
	this->SigmaTvRegs35[3] =	     0;	// SIGMATV_CGMS_HI_WSS			0x1F33
	this->SigmaTvRegs35[4] =	     0;	// SIGMATV_HSYNC_WIDTH			0x1F34
	this->SigmaTvRegs35[5] =	     0;	// SIGMATV_VSYNC_START			0x1F35
	this->SigmaTvRegs35[6] =	     0;	// SIGMATV_VSYNC_WIDTH			0x1F36

	ITvEncoder_InitTvEncoder( pITvEncoder );
}

void CSigmaTv__Write(ITvEncoder* pITvEncoder, DWORD addr, DWORD Data)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;

	IDecoder_WriteReg(this->m_pIDecoder, addr, Data);
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("WriteSigmaTv at %x = %x"), addr, Data));
}

DWORD CSigmaTv__Read(ITvEncoder* pITvEncoder, DWORD addr)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;
	DWORD Data;

	Data = IDecoder_ReadReg(this->m_pIDecoder, addr);
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("ReadSigmaTv at %x = %x"), addr, Data));
	return Data;
}

BOOL CSigmaTv__WriteN(ITvEncoder* pITvEncoder, DWORD addr, BYTE* pData, int n)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;
	int i;

	for (i=0;i<n/2; i++)
		IDecoder_WriteReg(this->m_pIDecoder, addr+i, *(WORD*)(pData+2*i));
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("WriteSigmaTv at %x = %x"), addr, *pData));
	return TRUE;
}

BOOL CSigmaTv__ReadN(ITvEncoder* pITvEncoder, DWORD addr, BYTE* pData, int n)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;
	int i;

	for (i=0;i<n/2; i++)
		*(WORD*)(pData+2*i) = (WORD)IDecoder_ReadReg(this->m_pIDecoder, addr+i);
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("ReadSigmaTv at %x = %x"), addr, *pData));
	return TRUE;
}

void CSigmaTv__StartAccessReg(ITvEncoder* pITvEncoder)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;
	CommonSymbolTable* pQ = (CommonSymbolTable*)this->pQ;

	IDecoder_WriteDM(this->m_pIDecoder, pQ->TVEncReg_Access.addr, 2);
	OSTimeDelay(5);
	if(IDecoder_ReadDM(this->m_pIDecoder, pQ->TVEncReg_Access.addr) != 2 )
	{
		QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("TVEncReg_Access TIMEOUT %x!"),
		   IDecoder_ReadDM(this->m_pIDecoder, pQ->TVEncReg_Access.addr) ));
	}
	ITvEncoder_Write( pITvEncoder, SIGMATV_CONFIG, this->SigmaTvRegs[0] );
}

void CSigmaTv__EndAccessReg(ITvEncoder* pITvEncoder)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;
	CommonSymbolTable* pQ = (CommonSymbolTable*)this->pQ;

	ITvEncoder_Write( pITvEncoder, SIGMATV_CONFIG, this->SigmaTvRegs[0] );
	IDecoder_WriteDM(this->m_pIDecoder, pQ->TVEncReg_Access.addr, 0);
}

void CSigmaTv__SetTVStandard(ITvEncoder* pITvEncoder, DWORD TvStandard)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;

	if( TvStandard == SET_PAL )
	{
		// PAL-B,D,G,H,I settings
		this->SigmaTvRegs[0] = (this->SigmaTvRegs[0] & ~SIGMATV_MASK) | SIGMATV_PAL;// SIGMATV_CONFIG				0x1F30

		// Note: Other method to make it work IGS_FieldInverted=1 and IGS,AD71xx,SigmaTv = Ok if:
		// - write in DICOM_TvOut the FieldInvert=0, not 1
		// - xchange Top and BottomFieldStart to 263, 1; this change only the Vga capture
		if( this->InvertField )
		{
			// It starts with even field. Field even=bottom= nVSync goes low when nHSync is hi.
			OSmemcpy(this->SigmaTvRegs+1, SigmaTv_PalMasterInv, sizeof(SigmaTv_PalMasterInv));
		}
		else
		{
			// It starts with odd field. Field odd=top= nVSync goes low when nHSync is low.
			OSmemcpy(this->SigmaTvRegs+1, SigmaTv_PalMaster, sizeof(SigmaTv_PalMaster));
		}
	}
	else
	{
		if( TvStandard == SET_PAL60 )
			this->SigmaTvRegs[0] = (this->SigmaTvRegs[0] & ~SIGMATV_MASK) | SIGMATV_PAL60;// SIGMATV_CONFIG				0x1F30
		else if( TvStandard == SET_PALM )
			this->SigmaTvRegs[0] = (this->SigmaTvRegs[0] & ~SIGMATV_MASK) | SIGMATV_PALM;// SIGMATV_CONFIG				0x1F30
		else	// NTSC
			this->SigmaTvRegs[0] = (this->SigmaTvRegs[0] & ~SIGMATV_MASK) | SIGMATV_NTSC;// SIGMATV_CONFIG				0x1F30

		if( this->InvertField )
		{
			// It starts with even field. Field even=bottom= nVSync goes low when nHSync is hi.
			OSmemcpy(this->SigmaTvRegs+1, SigmaTv_NtscMasterInv, sizeof(SigmaTv_NtscMasterInv));
		}
		else
		{
			// It starts with odd field. Field odd=top= nVSync goes low when nHSync is low.
			OSmemcpy(this->SigmaTvRegs+1, SigmaTv_NtscMaster, sizeof(SigmaTv_NtscMaster));
		}
	}
	this->CurrentTvStandard = TvStandard;

	CSigmaTv__EnableMacrovision(pITvEncoder, CURRENT_MACROVISION);
}

void CSigmaTv__SendCCData(ITvEncoder* pITvEncoder, BYTE field, BYTE* pData)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;
	DWORD Data;
	CommonSymbolTable* pQ = (CommonSymbolTable*)this->pQ;

	if ( (this->CC_Enable == 0) || (this->CC_UserEnable == 0) )
		return;

	if( (Data = IDecoder_ReadDM(this->m_pIDecoder, pQ->TVEncReg_Access.addr)) != 0 )
	{
		QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT("CC_TVEncReg_Access PROBLEM %x "), Data));
		return;
	}

	Data = ( *(pData+1) )|( (*pData)<<8 );
	if( field & 0x80 )	// line21_switch = 1 -> valid data
	{
		if( (field & 0x01) == 0)
		{
			this->CC_FieldEnable |= SIGMATV_CCF1;
			CSigmaTv__Write( pITvEncoder, SIGMATV_CC_DATA, Data);	// CloseCaption registers
		}
		else
		{
			this->CC_FieldEnable |= SIGMATV_CCF2;
			// Extended data not supported yet
		}
	}
	else				// line21_switch = 0 -> invalid data
	{
		if( (field & 0x01) == 0)
			this->CC_FieldEnable &= ~SIGMATV_CCF1;
		else
			this->CC_FieldEnable &= ~SIGMATV_CCF2;
	}
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("_%x "), this->CC_FieldEnable));

	this->SigmaTvRegs[0] = (this->SigmaTvRegs[0] | SIGMATV_CCF12) ^ this->CC_FieldEnable;
//	CSigmaTv__Write(pITvEncoder, SIGMATV_CONFIG, this->SigmaTvRegs[0]);
}

void CSigmaTv__ShowCloseCaption(ITvEncoder* pITvEncoder)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;

	this->CC_Enable = (this->CC_UserEnable) ? (SIGMATV_CCF1 | SIGMATV_CCF2):0;
	this->CC_FieldEnable = this->CC_Enable;
	this->SigmaTvRegs[0] = (this->SigmaTvRegs[0] | SIGMATV_CCF12) ^ this->CC_FieldEnable;
	CSigmaTv__StartAccessReg(pITvEncoder);
	CSigmaTv__Write(pITvEncoder, SIGMATV_CONFIG, this->SigmaTvRegs[0]);
	CSigmaTv__EndAccessReg(pITvEncoder);
}

void CSigmaTv__HideCloseCaption(ITvEncoder* pITvEncoder)
{
	CTvEncoder* this = (CTvEncoder*) pITvEncoder;

	this->CC_Enable = 0;
	this->CC_FieldEnable = 0;
	this->SigmaTvRegs[0] = (this->SigmaTvRegs[0] | SIGMATV_CCF12) ^ this->CC_FieldEnable;
	CSigmaTv__StartAccessReg(pITvEncoder);
	CSigmaTv__Write(pITvEncoder,SIGMATV_CONFIG, this->SigmaTvRegs[0]);
	CSigmaTv__EndAccessReg(pITvEncoder);
}