audio.c

车载DVD osdIC TW8816原厂代码

//============ Audio ====================================================

#include "Config.h"

#include	"reg.h"
#include	"typedefs.h"
#include	"i2c.h"
#include	"main.h"
#include    "dispinfo.h"
#include	"osdmenu.h"
#include    "printf.h"
#include	"tw88.h"
#include	"etc_eep.h"
#include 	"audio.h"

#ifdef SUPPORT_MSP_AUDIO
static	IDATA BYTE	AudioVol = 50, 
					AudioBalance = 50, 
					AudioBass = 50,
					AudioTreble = 46;
					//AudioEffect = 0;
#else					
static	IDATA BYTE	AudioVol = 50;
#endif					
		bit   TVTunerAudioActive=0;
static  bit   AudioMuteOn=0;

extern CODE struct RegisterInfo UserRange;

#ifdef SUPPORT_MSP_AUDIO
CODE struct RegisterInfo MSPVolRange=     {0x50, 0x7d,0x66};				
CODE struct RegisterInfo MSPBalanceRange= {-127,  127,   0};				
CODE struct RegisterInfo MSPBassRange=    { -12,   12,   0};				
CODE struct RegisterInfo MSPTrebleRange=  { -12,   15,   2};		
#else
CODE struct RegisterInfo MSPVolRange=     {0x10, 0xe0,0x80};				
#endif

BYTE ResetMSP(void)
{
#ifdef SUPPORT_MSP_AUDIO
	BYTE mspdata[3];

	#ifdef DEBUG_AUDIO
	dPrintf("\r\n++(ResetMSP)\r\nTVVol:%d", (WORD)AudioVol);
	#endif

	AudioVol     = GetAudioVolEE();
	AudioBalance = GetAudioBalanceEE();
	AudioBass    = GetAudioBassEE();
	AudioTreble  = GetAudioTrebleEE();
	//AudioEffect  = GetAudioEffectEE();

	mspdata[0] = 0;
	mspdata[1] = 0x80;
	mspdata[2] = 0;
	WriteI2Cn_(MSPI2CAddress, mspdata, 3);

	mspdata[0] = 0;
	mspdata[1] = 0;
	mspdata[2] = 0;
	WriteI2Cn_(MSPI2CAddress, mspdata, 3);

	#ifdef DEBUG_AUDIO
	dPuts("\r\n__(ResetMSP)");
	#endif
	return 0;
#else
	AudioVol     = GetAudioVolEE();

	return 0;
#endif		
}

void SetMSPVol(void)
{
#ifdef SUPPORT_MSP_AUDIO
	BYTE voldata[5];
	int vol;

	Mapping1( AudioVol, &UserRange, &vol, &MSPVolRange );

	voldata[0] = 0x12;
	voldata[1] = 0;
	voldata[2] = 0;
	voldata[3] = (BYTE)vol;
	voldata[4] = 0;
	WriteI2Cn_(MSPI2CAddress, voldata, 5);	//LJY010202
	
	#ifdef DEBUG_AUDIO
	dPrintf("\r\n++(SetMSPVol)MSPVol:0x%x, AudioVol:%d__", (WORD)vol, (WORD)AudioVol);
	#endif
#else
	int vol;

	Mapping1( AudioVol, &UserRange, &vol, &MSPVolRange );

	#ifndef	BACKLIGHT_CCFL
	WriteTW88(0xff, 0x01); // page 1
	WriteTW88(0x33, vol); // FPPWM 
	WriteTW88(0xff, 0x00); // page 0
	#endif

       if (P2_3) 
	   	P2_3 = FALSE; // Mute Pin  of TDA7496
#endif
}

#ifdef SUPPORT_MSP_AUDIO
void SetMSPBalance(void)
{
	BYTE valdata[5];
	int val;

	Mapping1( AudioBalance, &UserRange, &val, &MSPBalanceRange );
	
	valdata[0] = 0x12;
	valdata[1] = 0;		
	valdata[2] = 1;
	valdata[3] = (BYTE)val;
	valdata[4] = 0;
	WriteI2Cn_(MSPI2CAddress, valdata, 5);

	#ifdef DEBUG_AUDIO
	dPrintf("\r\n++(SetMSPBalance)MSPBal:0x%x, AudioBalance:%d__", (WORD)val, (WORD)AudioBalance);
	#endif
}

void SetMSPBass(void)
{
	BYTE valdata[5];
	int val;

	Mapping1( AudioBass, &UserRange, &val, &MSPBassRange );
	
	valdata[0] = 0x12;
	valdata[1] = 0;
	valdata[2] = 2;
	valdata[3] = (BYTE)val;
	valdata[4] = 0;
	WriteI2Cn_(MSPI2CAddress, valdata, 5);

	#ifdef DEBUG_AUDIO
	dPrintf("\r\n++(SetMSPBass)MSPBass:0x%x, AudioBass:%d__", (WORD)val, (WORD)AudioBass);
	#endif
}

void SetMSPTreble(void)
{
	BYTE valdata[5];
	int val;

	Mapping1( AudioTreble, &UserRange, &val, &MSPTrebleRange );
	
	valdata[0] = 0x12;
	valdata[1] = 0;
	valdata[2] = 3;
	valdata[3] = (BYTE)val;
	valdata[4] = 0;
	WriteI2Cn_(MSPI2CAddress, valdata, 5);

	#ifdef DEBUG_AUDIO
	dPrintf("\r\n++(SetMSPTreble)MSPTreble:0x%x, AudioTreble:%d__", (WORD)val, (WORD)AudioTreble);
	#endif
}
#endif

void AudioOff(void)
{
#ifdef SUPPORT_MSP_AUDIO
	BYTE mspdata[5];

	#ifdef DEBUG_AUDIO
	dPuts("\r\n++(AudioOff)--");
	#endif

	mspdata[0] = 0x12;
	mspdata[1] = 0x00;
	mspdata[2] = 0x00;
	mspdata[3] = 0xff;
	mspdata[4] = 0x00;
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);
#else
       P2_3 = TRUE; // Mute Pin  of TDA7496
#endif
}

#define END_OF_LOOP	0xff

#ifdef SUPPORT_TV
BYTE AudioAutoStdDetection(void)
{
#ifdef SUPPORT_MSP_AUDIO
	BYTE mspdata[5], loop=0;
	WORD ret;

	mspdata[0] = 0x10;
	mspdata[1] = 0x00;
	mspdata[2] = 0x20;				// Standard selection
	mspdata[3] = 0x00;
	mspdata[4] = 0x01;				// Auto Std Detection
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);
	do {
		mspdata[0] = 0x00;
		mspdata[1] = 0x7E;
		I2CReadByteMSP(MSPI2CAddress, 0x11, mspdata, 2);
		if( loop==END_OF_LOOP )
			break;
		loop++;
		ret = mspdata[0];
		ret = ( ret << 8 ) | mspdata[1];
	} while( ret > 0x7ff );
	#ifdef DEBUG_AUDIO
	dPrintf("\r\n(AudioAutoStdDetection)Auto Detection:0x%x", (WORD)ret );
	#endif

	if( loop==END_OF_LOOP )		ret = 0;

	return ret;
#else
	return 0;
#endif
}
#endif


void ExtAudio(void)
{
#ifdef SUPPORT_MSP_AUDIO
	BYTE mspdata[5], loop=0;
	WORD ret;

	AudioOff();

	mspdata[0] = 0x10;
	mspdata[1] = 0x00;
	mspdata[2] = 0x30;				// MODUS register: Automatic-on
	mspdata[3] = 0x20;
	mspdata[4] = 0x03;
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);

	mspdata[0] = 0x12;
	mspdata[1] = 0x00;
	mspdata[2] = 0x13;				// SCART switch
	mspdata[3] = 0x00;				
	mspdata[4] = 0x00;				
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);

	mspdata[0] = 0x12;
	mspdata[1] = 0x00;
	mspdata[2] = 0x08;				// source select
	mspdata[3] = 0x02;				// SCART input
	mspdata[4] = 0x20;				// stereo(transparent)
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);

	mspdata[0] = 0x12;
	mspdata[1] = 0x00;
	mspdata[2] = 0x0d;				// SCART input prescale
	mspdata[3] = 0x50;
	mspdata[4] = 0x00;
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);
	ret = AudioAutoStdDetection();

	#ifdef DEBUG_AUDIO
	if( !ret ) {
		dPuts("\r\n--Fail to Audio AutoDetect");
	}
	#endif
	AudioOn();			//SetMSPVol();
#else
	switch(GetInputSelection())
	{
#ifdef SUPPORT_TV
	case TV:
		P2_1 = 0; // A0 of 4052B
		P2_2 = 0; // A1 of 4052B
		break;
#endif		
#ifdef SUPPORT_PC
	case PC:
		P2_1 = 0; // A0 of 4052B
		P2_2 = 1; // A1 of 4052B
		break;	
#endif		
	default:	
		P2_1 = 1; // A0 of 4052B
		P2_2 = 0; // A1 of 4052B
		break;	
	}
#endif
}

#ifdef SUPPORT_PC
/*
void PCAudio(void)
{
	BYTE mspdata[5], loop=0;
	WORD ret;

	AudioOff();

	mspdata[0] = 0x10;
	mspdata[1] = 0x00;
	mspdata[2] = 0x30;				// MODUS register: Automatic-on
	mspdata[3] = 0x20;
	mspdata[4] = 0x03;
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);

	mspdata[0] = 0x12;
	mspdata[1] = 0x00;
	mspdata[2] = 0x13;				// SCART switch
	mspdata[3] = 0x02;				// SCART2->DSP
	mspdata[4] = 0x00;				
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);

	mspdata[0] = 0x12;
	mspdata[1] = 0x00;
	mspdata[2] = 0x08;				// source select
	mspdata[3] = 0x02;				// SCART input
	mspdata[4] = 0x20;				// stereo(transparent)
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);

	mspdata[0] = 0x12;
	mspdata[1] = 0x00;
	mspdata[2] = 0x0d;				// SCART input prescale
	mspdata[3] = 0x50;
	mspdata[4] = 0x00;
	WriteI2Cn_(MSPI2CAddress, mspdata, 5);

	ret = AudioAutoStdDetection();

	#ifdef DEBUG_AUDIO
	if( !ret ) {
		Puts("\r\n--Fail to Audio AutoDetect");
	}
	#endif
	AudioOn();			//SetMSPVol();
}
*/
#endif

BYTE GetAudioVol(void)
{
	return AudioVol;
}

BYTE ChangeVol(char amount)
{
	BYTE chg=0;

	CheckAndClearMuteOn();

	if( amount>0 ) {
		if( ((AudioVol+amount) <= UserRange.Max) ) 
			chg=1;
	}
	else {
		if( AudioVol>UserRange.Min  ) 
			chg=1;
	}

	if( chg ) {
		AudioVol += amount;
		SetAudioVolEE( AudioVol );
		SetMSPVol();
	}

	return AudioVol;
}

#ifdef SUPPORT_MSP_AUDIO
BYTE GetAudioBalance(void)
{
	return AudioBalance;
}

BYTE ChangeBalance(char amount)
{
	BYTE chg=0;

	if( amount>0 ) {
		if( ((AudioBalance+amount) <= UserRange.Max) ) {
			chg=1;
		}
	}
	else {
		if( AudioBalance>UserRange.Min  ) {
			chg=1;
		}
	}

	if( chg ) {
		AudioBalance += amount;
		SetAudioBalanceEE( AudioBalance );
		SetMSPBalance();
	}

	return AudioBalance;
}

BYTE GetAudioBass(void)
{
	return AudioBass;
}

BYTE ChangeBass(char amount)
{
	BYTE chg=0;

	if( amount>0 ) {
		if( ((AudioBass+amount) <= UserRange.Max) ) {
			chg = 1;
		}
	}
	else {
		if( AudioBass>UserRange.Min  ) {
			chg = 1;
		}
	}

	if( chg ) {
		AudioBass += amount;
		SetAudioBassEE( AudioBass );
		SetMSPBass();
	}

	return AudioBass;
}

BYTE GetAudioTreble(void)
{
	return AudioTreble;
}

BYTE ChangeTreble(char amount)
{
	BYTE chg=0;

	if( amount>0 ) {
		if( ((AudioTreble+amount) <= UserRange.Max) ) {
			chg = 1;
		}
	}
	else {
		if( AudioTreble>UserRange.Min  ) {
			chg = 1;
		}
	}

	if( chg ) {
		AudioTreble += amount;
		SetAudioTrebleEE( AudioTreble );
		SetMSPTreble();
	}

	return AudioTreble;
}

/*

BYTE GetAudioEffect(void)
{
	return AudioEffect;
}

BYTE ChangeAudioEffect(char amount)
{
	BYTE valdata[5];

	amount = 0;			//ignore
	AudioEffect = 0xff - AudioEffect;

	valdata[0] = 0x12;
	valdata[1] = 0;
	valdata[2] = 5;
	valdata[3] = AudioEffect;
	valdata[4] = 0;
	WriteI2Cn_(MSPI2CAddress, valdata, 5);

	SetAudioEffectEE( AudioEffect );
	return AudioEffect;
}
*/
#endif

void ToggleAudioMute(void)
{
	if( AudioMuteOn ) {
		AudioOn();			//SetMSPVol();
		AudioMuteOn = 0;
	}
	else {
		AudioOff();
		AudioMuteOn = 1;
	}
}

void CheckAndClearMuteOn(void)
{
	if( AudioMuteOn ) {
		AudioOn();			//SetMSPVol();
		AudioMuteOn = 0;
		ClearMuteInfo();
	}
}

/*void SetAudioMute(BYTE on )
{
		AudioMuteOn = on;
}
*/
BYTE IsAudioMuteOn(void)
{
	return (BYTE)AudioMuteOn;
}

void ResetAudioValue()
{
	SetAudioVolEE( 50 );
#ifdef SUPPORT_MSP_AUDIO	
	SetAudioBalanceEE( 50 );
	SetAudioBassEE( 50 );
	SetAudioTrebleEE( 50 );
//	SetAudioEffectEE( 0 );
#endif
}