audio.c

dm270 source code

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Input Channel Select			 				*
*	Input		:	which input channel										*	
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_Input_SelChannel(unsigned char channel)
{
	switch(channel)
	{
		case	Channel_1:
			DEV_ADEC_AdclPath_LINSEL(INPUT1);
			DEV_ADEC_AdcrPath_RINSEL(INPUT1);
			Vol_InputChannel_Index = 1;
			break;

		case	Channel_2:
			DEV_ADEC_AdclPath_LINSEL(INPUT2);
			DEV_ADEC_AdcrPath_RINSEL(INPUT2);
			Vol_InputChannel_Index = 2;
			break;

		case	Channel_3:
			DEV_ADEC_AdclPath_LINSEL(INPUT3);
			DEV_ADEC_AdcrPath_RINSEL(INPUT3);
			Vol_InputChannel_Index = 3;
			break;
	}
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Input Step Volume				 				*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_Input_StepVolume(BOOL trueorfalse)
{
	if(trueorfalse)			//	TRUE  = input volume step Up,
							//	FALSE = input volume step Down
	{
		R_input_vol += API_Vol_StepIndex;
		if(R_input_vol >= 63)	R_input_vol = 63;
		else					R_input_vol += 0;
		
		L_input_vol += API_Vol_StepIndex;
		if(L_input_vol >= 63)	L_input_vol = 63;
		else					L_input_vol += 0;
		
	}
	else
	{
		R_input_vol -= API_Vol_StepIndex;
		if(R_input_vol <= 0)	R_input_vol = 0;
		else					R_input_vol -= 0;
		
		L_input_vol -= API_Vol_StepIndex;
		if(L_input_vol <=0)		L_input_vol = 0;
		else					L_input_vol -= 0;
	}
	
	DEV_ADEC_LeftInputVol_LINVOL(L_input_vol);
	DEV_ADEC_RightInputVol_RINVOL(R_input_vol);
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Input Set Volume				 				*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_Input_SetVolume(unsigned char vol)
{
	L_input_vol = vol;
	R_input_vol = vol;
	DEV_ADEC_LeftInputVol_LINVOL(L_input_vol);
	DEV_ADEC_RightInputVol_RINVOL(R_input_vol);
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output CHannnel Select	 					*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_Output_SelChannel(unsigned char channel)
{
	switch(channel)
	{
		case	Channel_1:
			API_AUDIO_PowerStandBy(TRUE);
			DEV_ADEC_PwrMgmt2_OUT2(FALSE);
			DEV_ADEC_PwrMgmt2_OUT1(TRUE);
			Vol_OutputChannel_Index = 1;
			API_AUDIO_PowerStandBy(FALSE);
			break;
		
		case	Channel_2:
			API_AUDIO_PowerStandBy(TRUE);
			DEV_ADEC_PwrMgmt2_OUT1(FALSE);
			DEV_ADEC_PwrMgmt2_OUT2(TRUE);
			Vol_OutputChannel_Index = 2;
			API_AUDIO_PowerStandBy(FALSE);
			break;
	}
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output Step Volume 		 					*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_Output_StepVolume(BOOL trueorfalse)
{
	if(trueorfalse)
	{
		R_output_vol += API_Vol_StepIndex;

		if(R_output_vol >= 127)		R_output_vol = 127;
		else if(R_output_vol <= 47)	R_output_vol = 47 + API_Vol_StepIndex;
		else						R_output_vol += 0;
		
		L_output_vol += API_Vol_StepIndex;
		if(L_output_vol >= 127)		L_output_vol = 127;
		else if(L_output_vol <= 47)	L_output_vol = 47 + API_Vol_StepIndex;
		else						L_output_vol += 0;
		
	}
	else
	{
		R_output_vol -= API_Vol_StepIndex;
		if(R_output_vol <= 47)			R_output_vol = 47;
		else if(R_output_vol >= 127)	R_output_vol = 127 - API_Vol_StepIndex;
		else							R_output_vol -= 0;
		
		L_output_vol -= API_Vol_StepIndex;
		if(L_output_vol <=47)			L_output_vol = 47;
		else if(L_output_vol >= 127)	L_output_vol = 127 - API_Vol_StepIndex;
		else							L_output_vol -= 0;
	}

	API_OutputVolumeIndex = L_output_vol + R_output_vol - 94;

	if(Vol_OutputChannel_Index == 1)
	{
		DEV_ADEC_LOUT1Vol_LOUT1VOL(L_output_vol);
		DEV_ADEC_ROUT1Vol_ROUT1VOL(R_output_vol);
	}
	else
	{
		DEV_ADEC_LOUT2Vol_LOUT2VOL(L_output_vol);
		DEV_ADEC_ROUT2Vol_ROUT2VOL(R_output_vol);
	}
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output Set Volume 		 					*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_Output_SetVolume(unsigned char volR ,unsigned char volL)
{
	int	tempR, tempL;
	int	steptemp;
	
	steptemp = (127-47)/API_Vol_StepSet;
	
	if( volR == 0 )
	{
		tempR = 47;
	}
	else if( volR > 0 && volR < (API_Vol_StepSet+1) )
	{
		tempR = 127 - steptemp*( API_Vol_StepSet - volR );
	}
	else	tempR = 127;

	if( volL == 0 )
	{
		tempL = 47;
	}
	else if( volL > 0 && volL < (API_Vol_StepSet+1) )
	{
		tempL = 127 - steptemp*( API_Vol_StepSet - volL );
	}
	else	tempL = 127;

	L_output_vol = tempR;
	R_output_vol = tempL;
	API_OutputVolumeIndex = L_output_vol + R_output_vol - 94;
	
	if(Vol_OutputChannel_Index == 1)
	{
		DEV_ADEC_LOUT2Vol_LOUT2VOL(OutputMute);
		DEV_ADEC_ROUT2Vol_ROUT2VOL(OutputMute);
		DEV_ADEC_LOUT1Vol_LOUT1VOL(L_output_vol);
		DEV_ADEC_ROUT1Vol_ROUT1VOL(R_output_vol);
	}
	else
	{
		DEV_ADEC_LOUT1Vol_LOUT1VOL(OutputMute);
		DEV_ADEC_ROUT1Vol_ROUT1VOL(OutputMute);
		DEV_ADEC_LOUT2Vol_LOUT2VOL(L_output_vol);
		DEV_ADEC_ROUT2Vol_ROUT2VOL(R_output_vol);
	}
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Step Volume Balance			 				*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_StepBalance(BOOL trueorfalse)
{
	int	vol_temp1;
	int	vbr_index;
	int	vbl_index;
	
	if(trueorfalse)		//	TRUE	:Right Volume Up
	{					//	FALSE	:Left Volume Up
		if(API_Balance_ValueIndex == 10)	API_Balance_ValueIndex = 10;
		else								API_Balance_ValueIndex += API_Balance_StepIndex;
	}
	else
	{
		if(API_Balance_ValueIndex == 0)		API_Balance_ValueIndex = 0;
		else								API_Balance_ValueIndex -= API_Balance_StepIndex;
	}
	
	vbr_index = API_Balance_ValueIndex;
	vbl_index = 10 - API_Balance_ValueIndex;
	vol_temp1 = API_OutputVolumeIndex;
	vol_temp1 *= vbr_index;
	vol_temp1 /= 10;
	R_output_vol = vol_temp1 + 47;
	vol_temp1 = API_OutputVolumeIndex;
	vol_temp1 *= vbl_index;
	vol_temp1 /= 10;
	L_output_vol = vol_temp1 + 47;

	if(Vol_OutputChannel_Index == 1)
	{
			DEV_ADEC_LOUT1Vol_LOUT1VOL(L_output_vol);
			DEV_ADEC_ROUT1Vol_ROUT1VOL(R_output_vol);
	}		
	else
	{
			DEV_ADEC_LOUT2Vol_LOUT2VOL(L_output_vol);
			DEV_ADEC_ROUT2Vol_ROUT2VOL(R_output_vol);
	}
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output Step Volume Treble 					*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_StepTreble(BOOL trueorfalse)
{
	if(trueorfalse)		//	TRUE	:Up
	{					//	FALSE	:Down
		if(API_Treble_ValueIndex == 1)	API_Treble_ValueIndex = 1;
		else							API_Treble_ValueIndex -= API_Treble_StepIndex;
	}
	
	else
	{
		if(API_Treble_ValueIndex == 11)	API_Treble_ValueIndex = 11;
		else							API_Treble_ValueIndex += API_Treble_StepIndex;
	}
	
	DEV_ADEC_TrebleCtrl_TRBL(API_Treble_ValueIndex);
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output Set Volume Treble 						*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_SetTreble(unsigned char value)
{
	if(value >=11)		API_Treble_ValueIndex = 11;
	else if(value <=1)	API_Treble_ValueIndex = 1;
	else				API_Treble_ValueIndex = value;
	DEV_ADEC_TrebleCtrl_TRBL(API_Treble_ValueIndex);
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output Step Volume Bass 		 				*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_StepBass(BOOL trueorfalse)
{
	if(trueorfalse)		//	TRUE	:Up
	{					//	FALSE	:Down
		if(API_Bass_ValueIndex == 1)	API_Bass_ValueIndex = 1;
		else							API_Bass_ValueIndex -= API_Bass_StepIndex;
	}
	
	else
	{
		if(API_Bass_ValueIndex == 11)	API_Bass_ValueIndex = 11;
		else							API_Bass_ValueIndex += API_Bass_StepIndex;
	}
	
	DEV_ADEC_BassCtrl_BASS(API_Bass_ValueIndex);
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output Set Volume Bass 		 				*
*	Return		:	None													*
*	Description	:															*
*--------------------------------------------------------------------------*/
void	API_AUDIO_SetBass(unsigned char value)
{
	if(value >=11)		API_Bass_ValueIndex = 11;
	else if(value <=1)	API_Bass_ValueIndex = 1;
	else				API_Bass_ValueIndex = value;
	DEV_ADEC_BassCtrl_BASS(API_Bass_ValueIndex);
}

/*--------------------------------------------------------------------------*
*	Brief		:	API Audio Output Mute Off		 		 				*
*	Return		:	None													*