ctvenc.c

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

/********************************************************************************************/
/*  CTvEncoder.c : Implementation of the TvEncoder interface
*  REALmagic Quasar Hardware Library
*  Created by Aurelia Popa-Radu
*  Copyright Sigma Designs Inc
*  Sigma Designs Proprietary and confidential
*  Created on 8/27/99
*  Description:
/********************************************************************************************/

/****h* HwLib/ITvEncoder_implementation
 * NAME
 *	HwLib/ITvEncoder_implementation
 * DESCRIPTION
 *  CTvEncoder implementation of the ITvEncoder interface.
 * COPYRIGHT
 *  Copyright Sigma Designs Inc
 *  Sigma Designs Proprietary and confidential
/********************************************************************************************/

#include "pch.h"

#include "ci2c.h"
#include "ctvenc.h"
#include "cad7170.h"
#include "cad7175.h"
#include "cad7177.h"
#include "csaa7128.h"
#include "csigmatv.h"

void CNoTvEncoder__Write(ITvEncoder* pITvEncoder, DWORD addr, DWORD Data){}
DWORD CNoTvEncoder__Read(ITvEncoder* pITvEncoder, DWORD addr) { return 0;}
BOOL CNoTvEncoder__WriteN(ITvEncoder* pITvEncoder, DWORD addr, BYTE* pData, int n){ return TRUE;}
BOOL CNoTvEncoder__ReadN(ITvEncoder* pITvEncoder, DWORD addr, BYTE* pData, int n){ return TRUE;}
QRESULT CTvEncoder__ProgramTVEx( ITvEncoder* pITvEncoder, DWORD TvMaster, DWORD nbits, 
	 DWORD ccir, DWORD TvStandard, DWORD DacsEnable, MASTERPARAMS* MP, DWORD Interlaced, DWORD Polarity)
{
	return E_NOT_SUPPORTED;
}

QRESULT CTvEncoder__SetProperty( ITvEncoder* pITvEncoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
{
	return E_NOT_SUPPORTED;
}
QRESULT CTvEncoder__GetProperty( ITvEncoder* pITvEncoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
{
	return E_NOT_SUPPORTED;
}

/****f* HwLib/CTvEncoder__CreateInstance
 * USAGE
 *	NOT PRESENT in ITvEncoder interface
 *	void CTvEncoder__CreateInstance(void **pv, DWORD dwInstance)
 * DESCRIPTION
 *	CTvEncoder__CreateInstance - allocates memory for a new TvEncoder object,
 *	called by ModCreateInstance
 * PARAMETERS
 *	IN DWORD dwInstance - instance passed down by CreateInstance.
 *	OUT void** pv - Points to a 32-bit variable that receives the pointer to object
 * SEE ALSO
 *   CTvEncoder__CreateInstance
/********************************************************************************************/
void CTvEncoder__CreateInstance(void **pv, DWORD dwInstance)
{
    CTvEncoder__New((CTvEncoder **)pv, TEXT("TvEncoder"), TRUE, dwInstance);
}

/****f* HwLib/CTvEncoder__New
 * USAGE
 *	NOT PRESENT in ITvEncoder interface
 *	void CTvEncoder__New(CTvEncoder** ppCTvEncoder, TCHAR *pName, BOOL bAllocate, DWORD dwInstance)
 * DESCRIPTION
 *	CTvEncoder__New - allocates memory for a new TvEncoder object and plays the role of
 *	the constructor in C++.
 * PARAMETERS
 *	OUT CTvEncoder** ppCTvEncoder - Points to a 32-bit variable that receives the pointer to object
 *	IN TCHAR *pName - pointer to string containing the name of the object - debug purposes.
 *	BOOL bAllocate - usually called with TRUE to allocate memory for object.
 *	               - if FALSE ppCTvEncoder should point to an object already created.
 *	IN DWORD dwInstance - instance passed down by CreateInstance.
 * SEE ALSO
 *   ITvEncoder_Delete
/********************************************************************************************/
void CTvEncoder__New(CTvEncoder** ppCTvEncoder, TCHAR *pName, BOOL bAllocate, DWORD dwInstance)
{
	CTvEncoder *this = *ppCTvEncoder;

	if (bAllocate)
	{
		// Allocate CTvEncoder
		*ppCTvEncoder = OSmalloc(sizeof(CTvEncoder));
		this = (CTvEncoder*) *ppCTvEncoder;
		if(this == NULL)
			return;
		OSmemset(this, 0, sizeof(CTvEncoder));
	}

	// Call CObject constructor with bAllocate = FALSE
	CObject__New ((CObject**)ppCTvEncoder, pName, FALSE, dwInstance);
	// Call CI2C constructor
	CI2C__New ( (CI2C**)(&this->m_pII2C), pName, TRUE, dwInstance );
	if(this->m_pII2C == NULL)
	{
		if (bAllocate)
			OSfree(*ppCTvEncoder);
		*ppCTvEncoder = NULL;
	}

	// Initialize virtual table with "empty" functions
	this->VTable.Delete					= CTvEncoder__Delete;
	this->VTable.Init					= CTvEncoder__Init;
	this->VTable.Write					= CNoTvEncoder__Write;
	this->VTable.Read					= CNoTvEncoder__Read;
	this->VTable.WriteN					= CNoTvEncoder__WriteN;
	this->VTable.ReadN					= CNoTvEncoder__ReadN;
	this->VTable.SetRegistry			= CTvEncoder__SetRegistry;
	this->VTable.InitTvEncoder			= CTvEncoder__InitTvEncoder;
	this->VTable.ProgramTV				= CTvEncoder__ProgramTV;
	this->VTable.SetTVStandard			= CTvEncoder__SetTVStandard;
	this->VTable.GetCurrentTVStandard	= CTvEncoder__GetCurrentTVStandard;
	this->VTable.GetCurrentMacrovision	= CTvEncoder__GetCurrentMacrovision;
	this->VTable.SetCurrentYcYuvRgb		= CTvEncoder__SetCurrentYcYuvRgb;
	this->VTable.GetCurrentYcYuvRgb		= CTvEncoder__GetCurrentYcYuvRgb;
	this->VTable.IsVideoOnTv			= CTvEncoder__IsVideoOnTv;
	this->VTable.ReadMacrovision		= CTvEncoder__ReadMacrovision;
	this->VTable.WriteMacrovision		= CTvEncoder__WriteMacrovision;
	this->VTable.EnableMacrovision		= CTvEncoder__EnableMacrovision;
	this->VTable.SendCCData				= CTvEncoder__SendCCData;
	this->VTable.ShowCloseCaption		= CTvEncoder__ShowCloseCaption;
	this->VTable.HideCloseCaption		= CTvEncoder__HideCloseCaption;
	this->VTable.DisableTVBlackout		= CTvEncoder__DisableTVBlackout;
	this->VTable.SetPALSubcarrier		= CTvEncoder__SetPALSubcarrier;
	this->VTable.SetNTSCSubcarrier		= CTvEncoder__SetNTSCSubcarrier;
	this->VTable.GetPALSubcarrier		= CTvEncoder__GetPALSubcarrier;
	this->VTable.GetNTSCSubcarrier		= CTvEncoder__GetNTSCSubcarrier;
	this->VTable.GetTvIdentifier		= CTvEncoder__GetTvIdentifier;
	this->VTable.ProgramTVEx			= CTvEncoder__ProgramTVEx;
	this->VTable.InitPropertySet		= CTvEncoder__InitPropertySet;
	this->VTable.SetProperty			= CTvEncoder__SetProperty;
	this->VTable.GetProperty			= CTvEncoder__GetProperty;

	this->lpVtbl = &this->VTable;
}

/****f* HwLib/ITvEncoder_Delete
 * USAGE
 *	ITvEncoder_Delete(ITvEncoder* pITvEncoder, BOOL bDeleteObject)
 *	CTvEncoder__Delete(ITvEncoder* pITvEncoder, BOOL bDeleteObject)
 * DESCRIPTION
 *	ITvEncoder_Delete - frees memory for the specified TvEncoder object.
 *	ITvEncoder_Delete plays the role of the destructor in C++.
 * PARAMETERS
 *	IN ITvEncoder* pITvEncoder - pointer to the object created by a previous
 *		call to CTvEncoder__CreateInstance or CTvEncoder__New.
 *	BOOL bDeleteObject - usually called with TRUE to free memory for object.
 *				   - if FALSE doesn't free any memory.
 * SEE ALSO
 *   CTvEncoder__CreateInstance, CTvEncoder__New
/********************************************************************************************/
void CTvEncoder__Delete(ITvEncoder* pITvEncoder, BOOL bDeleteObject)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder ;

	if (this == NULL)
		return;

    // Release what we were using
	// Call CI2C Destructor
	II2C_Delete ( this->m_pII2C, bDeleteObject );
	// Call CObject Destructor
	CObject__Delete ((IObject*)this, FALSE);

	if (bDeleteObject)
	{
		// Delete CTvEncoder
		OSfree(pITvEncoder);
	}
}

/****f* HwLib/ITvEncoder_Init
 * USAGE
 *	BOOL ITvEncoder_Init(ITvEncoder* pITvEncoder, DWORD* pTvEncoderId)
 *	BOOL CTvEncoder__Init(ITvEncoder* pITvEncoder, DWORD* pTvEncoderId)
 * DESCRIPTION
 *	ITvEncoder_Init - initialize the TvEncoder object according to the TvEncoder identifier.
 *	For internal TvEncoder (SigmaTv) pTvEncoderId should point to "0" value. The CSigmaTv__Init
 *	function is called to initialize the object and the virtual table. pTvEncoderId remains 0.
 *	For external TvEncoder (AD7170, AD7175, AD7177) pTvEncoderId should point to "1" value.
 *	CTvEncoder__Check is called to find (based on I2C base address) what specific TvEncoder
 *	is present on the board. pTvEncoderId will receive the TvEncoder identifier(AD7175_ID,
 *	AD7170_ID or AD7177_ID) and the specific CAD717x__Init is called to initialize the object
 *	and the virtual table.
 *	If no I2C TvEncoder is found an "empty" TvEncoder object is created and the virtual table
 *	will contain only inopperant methods. This implementation permits the user to use the
 *	ITvEncoder methods without checking if pITvEncoder is NULL.
 *	It is called by CreateInstance.
 * PARAMETERS
 *	IN ITvEncoder* pITvEncoder - pointer to the TvEncoder object
 *	IN OUT DWORD* pTvEncoderId - pointer to the TvEncoder identifier
 * RETURN VALUE
 *	TRUE 
/********************************************************************************************/
BOOL CTvEncoder__Init(ITvEncoder* pITvEncoder, DWORD* pTvEncoderId)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder ;

	this->CurrentTvStandard = SET_NTSC;			//Ntsc
	this->CurrentMacrovision = 0;
	this->CC_Enable = 0;
	this->CC_UserEnable = 1;// let the close caption enabled by default
	this->CC_FieldEnable = 0;

	if (*pTvEncoderId == 0)
	{
		CSigmaTv__Init( pITvEncoder );
		*pTvEncoderId = 0;
		return TRUE;
	}
	if (*pTvEncoderId == 0x7F)
	{
		this->m_bEncoderRegs = 0x7F;
		II2C_Init( this->m_pII2C );
		// 0 delay seems to not work
		II2C_SetI2CAddress( this->m_pII2C, SAA7128_WRITE_ADDR, SAA7128_READ_ADDR, 1);
		Csaa7128__Init( pITvEncoder );
		return TRUE;
	}
	//find any I2c Tv encoder
	II2C_Init( this->m_pII2C );
	CTvEncoder__Check ( pITvEncoder );

	this->NTSC_SubcarrierFrequency = 0x21f07c16;
	this->PAL_SubcarrierFrequency = 0x2a098acb;
	this->PALM_SubcarrierFrequency = 0x21e6efa3;
	this->YcYuvRgb = COMPOSITE;

	// Initialize vtbl members
	switch( this->m_bEncoderRegs )
	{
	case AD7175_ID:
		CAD7175__Init( pITvEncoder );
		break;
	case AD7177_ID:
		CAD7177__Init( pITvEncoder );
		break;
	case AD7170_ID:
		CAD7170__Init( pITvEncoder );
		break;
	case AD7178_ID:
	case BT869_ID:
	case BT865_ID:
	case 0:
	default:
		QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("NO TV ENCODER")));
		//xreturn FALSE;
	}
	*pTvEncoderId = this->m_bEncoderRegs;
	return TRUE;
}

/****f* HwLib/ITvEncoder_Write
 * USAGE
 *	void ITvEncoder_Write(ITvEncoder* pITvEncoder, DWORD addr, DWORD Data)
 *	void CTvEncoder__Write(ITvEncoder* pITvEncoder, DWORD addr, DWORD Data)
 * DESCRIPTION
 *	ITvEncoder_Write writes "Data" to address "addr".
/********************************************************************************************/
void CTvEncoder__Write(ITvEncoder* pITvEncoder, DWORD addr, DWORD Data)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;

	II2C_Write(this->m_pII2C, (BYTE)addr, (BYTE*)&Data, 1);
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("WriteTvEncoder at %x = %x"), addr, Data));
}

/****f* HwLib/ITvEncoder_Read
 * USAGE
 *	DWORD ITvEncoder_Read(ITvEncoder* pITvEncoder, DWORD addr)
 *	DWORD CTvEncoder__Read(ITvEncoder* pITvEncoder, DWORD addr)
 * DESCRIPTION
 *	ITvEncoder_Read returns data read from address "addr"
/********************************************************************************************/
DWORD CTvEncoder__Read(ITvEncoder* pITvEncoder, DWORD addr)
{
	CTvEncoder *this = (CTvEncoder*) pITvEncoder;
	DWORD Data = 0;

	II2C_Read(this->m_pII2C, (BYTE)addr, (BYTE*)&Data, 1);
	QDbgLog((QLOG_TRACE, QDebugLevelTrace, TEXT("ReadTvEncoder at %x = %x"), addr, Data));
	return Data;
}