dspinterface.cpp

基于h323协议的软phone

        dsp_audio_out = DSP_AUDIO_TO_SIO;
    }
#endif
    else {
        dsp_audio_out = DSP_AUDIO_TO_SPEAKERPHONE;
    }

    dspMgr->generateDtmf( dsp_tone, dsp_tone_dir, dsp_audio_out, gst1, gst2, gnet);
}

/**/
void setRingType(unsigned short ringType)
{
    ring_type = ringType;
}

/***************************************************************************
 *
 *  PlayRing()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Send control message to DSP to play ringing
 *
 **************************************************************************/

void PlayRing()
{
#ifdef CHECKDSP
checkDSP(-1);
#endif
    printf("PlayRing()\n");
    //chenguoyin
    //SetSpeakerphone(TRUE);
	//on_speakerphone = TRUE;
	isPlayRing = 1;
   // return;
   
    dspMgr->startRinger( ring_type );
}

/***************************************************************************
 *
 *  StopRing()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Send control message to DSP to stop ringing
 *
 **************************************************************************/

void StopRing()
{
#ifdef CHECKDSP
checkDSP(-1);
#endif
	//chenguoyin
	//SetSpeakerphone(FALSE);
	//on_speakerphone = FALSE;
	isPlayRing = 0;
	//return;
	
    dspMgr->stopRinger();
}

/***************************************************************************
 *
 *  SetSpeakerphone( int on_speakerphone )
 *
 *  Arguments
 *      Input: Whether to enable or disable speakerphone
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Send control message to DSP to set speakerphone
 *
 **************************************************************************/

void SetSpeakerphone( int on_speakerphone )
{
    if( on_speakerphone ){
        dspMgr->setAudioDestination( DSP_AUDIO_TO_SPEAKERPHONE );
        dspMgr->setAudioSource( DSP_INPUT_SPEAKERPHONE );
        input_source = DSP_INPUT_SPEAKERPHONE;
        output_dest = DSP_AUDIO_TO_SPEAKERPHONE;
    }
    else {
        dspMgr->setAudioDestination( DSP_AUDIO_TO_HANDSET );
        dspMgr->setAudioSource( DSP_INPUT_HANDSET );
        input_source = DSP_INPUT_HANDSET;
        output_dest = DSP_AUDIO_TO_HANDSET;

    }
	/*  check if any tone is currently active, if yes, stop the tone and
	 *  play the tone again. This will play the tone into the
	 *  handset/speakerphone whichever is active currently.
	 *  speaker-handset-tone-switching
	 */
	if (cur_tone != null_tone)
	{
		tone_type tmp_tone = cur_tone;
		StopTone ();
		PlayTone (tmp_tone);
	}

}

/***************************************************************************
 *
 *  IncreaseVolume()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Send control message to DSP to set volume
 *
 **************************************************************************/

void IncreaseVolume()
{
    dspMgr->increaseVolume();
}

/***************************************************************************
 *
 *  DecreaseVolume()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Send control message to DSP to set volume
 *
 **************************************************************************/

void DecreaseVolume()
{
    dspMgr->decreaseVolume();
}

/***************************************************************************
 *
 *  increaseRingerAmplitude()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Send control message to DSP to set ringer volume
 *
 **************************************************************************/
void IncreaseRingerAmplitude()
{
    dspMgr->increaseRingerAmplitude();
    if ( ring_volume < DSP_RINGER_AMPLITUDE_MAX )
    {
    	++ ring_volume;
    }
}

/***************************************************************************
 *
 *  decreaseRingerAmplitude()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Send control message to DSP to set ringer volume
 *
 **************************************************************************/
void DecreaseRingerAmplitude()
{
    dspMgr->decreaseRingerAmplitude();
    if ( ring_volume > DSP_RINGER_AMPLITUDE_MIN )
    {
    	-- ring_volume;
    }
}


void SetAudioSource(unsigned short audioIn)
{
	input_source = audioIn;
	dspMgr->setAudioSource(audioIn);
}

void SetAudioDestination(unsigned short audioOut)
{
    output_dest = audioOut;
	dspMgr->setAudioDestination(audioOut);
}


/***************************************************************************
 *
 *  ToggleMute()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:
 *  1. Toggle Mute on IP Phone
 *
 **************************************************************************/

void ToggleMute()
{
    if (muted)
    	dspMgr->muteOff();
    else
		dspMgr->muteOn();
    muted = (muted+1)&1;
}

/*unsigned short getVolume()
{
	unsigned short vlm, i;
	dspMgr->getVolume(DSP_AUDIO_TO_HANDSET, &vlm);
	for ( i = 0; i < DSP_VOLUME_STEP_NUM; ++i )
	{
		if ( vlm == gDSPhstvolumeMap[i] )
		{
			return i;
		}
	}
	return (DSP_VOLUME_STEP_MAX - 2);
}

int setVolume(unsigned short volume)
{
    int i;
	for ( i = DSP_RINGER_AMPLITUDE_MAX; i > DSP_RINGER_AMPLITUDE_MIN; --i )
	{
		DecreaseRingerAmplitude();
	}
	for ( i = DSP_RINGER_AMPLITUDE_MIN; i < volume; ++i )
	{
		IncreaseRingerAmplitude();
	}
	volume /= 2;
	return dspMgr->setVolume(DSP_AUDIO_TO_HANDSET, volume) &&
	       dspMgr->setVolume(DSP_AUDIO_TO_SPEAKERPHONE, volume) &&
	       dspMgr->setVolume(DSP_AUDIO_TO_SPEAKER2, volume);
}*/

void setHandSetVolume(unsigned short volume)
{
	dspMgr->setVolume(DSP_AUDIO_TO_HANDSET, volume);
}

unsigned short getHandSetVolume()
{
	unsigned short vlm, i;
	dspMgr->getVolume(DSP_AUDIO_TO_HANDSET, &vlm);
	for ( i = 0; i < DSP_VOLUME_STEP_NUM; ++i )
	{
		if ( vlm == gDSPhstvolumeMap[i] )
		{
			return i;
		}
	}
	return DSP_RESET_VOLUME_HANDSET;
}

void setSpeakerPhoneVolume(unsigned short volume)
{
	dspMgr->setVolume(DSP_AUDIO_TO_SPEAKERPHONE, volume);
}

unsigned short getSpeakerPhoneVolume()
{
	unsigned short vlm, i;
	dspMgr->getVolume(DSP_AUDIO_TO_SPEAKERPHONE, &vlm);
	for ( i = 0; i < DSP_VOLUME_STEP_NUM; ++i )
	{
		if ( vlm == gDSPspkvolumeMap[i] )
		{
			return i;
		}
	}
	return DSP_RESET_VOLUME_SPEAKER;
}

void setRingVolume(unsigned short ringVolume)
{
    int i;
    for ( i = DSP_RINGER_AMPLITUDE_MAX; i > DSP_RINGER_AMPLITUDE_MIN; --i )
	{
		DecreaseRingerAmplitude();
	}
	for ( i = DSP_RINGER_AMPLITUDE_MIN; i < ringVolume; ++i )
	{
		IncreaseRingerAmplitude();
	}
}

unsigned short getRingVolume()
{
    return ring_volume;
}

/* APA*/
#ifdef PPA
/***************************************************************************
 *  startLec()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:Start LEC for ppaChannelNumber 
 **************************************************************************/

void  startLec()
{	
   dspMgr->ppaLineEchoCancellerStart(ppaChannelNum);
}

/***************************************************************************
 * StopVoice()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:Stop LEC for ppaChannelNumber
 ***************************************************************************/
void  stopLec()
{
	dspMgr->ppaLineEchoCancellerStop(ppaChannelNum);

}
/***************************************************************************
 *  getDtmfDigit()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:get Dtmf Digit for particular channel 
 **************************************************************************/
int    getDtmfDigit(unsigned int *dtmfDigitTbl)
{	
	int retVal = 0;
     
	retVal = dspMgr->ppaGetDtmfDigit(dtmfDigitTbl);

	return retVal;
}

/***************************************************************************
 * ppaDtmfEnable()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:dtmf Enable for ppaChannelNumber
 *
 **************************************************************************/
void  ppaDtmfEnable(void)
{
	dspMgr->ppaDtmfDetectionEnable(ppaChannelNum);

}
/***************************************************************************
 * dtmfDisable()
 *
 *  Arguments
 *      Input: Nothing
 *
 *  Returns:   Nothing
 *
 *  Description:dtmf Enable for ppaChannelNumber
 *
 **************************************************************************/
void  ppaDtmfDisable(void)
{
	dspMgr->ppaDtmfDetectionDisable(ppaChannelNum);

}

/***************************************************************************
 * ppaCandenceSwitch()
 *
 *  Arguments
 *      Input: portNumber and Enable/Disable Value
 *
 *  Returns:   Nothing
 *
 *  Description:Switch on the Cadence
 *
 **************************************************************************/

static void ppaCandenceSwitch (unsigned short ppaPortNumber, unsigned short cadenceEnable)
{
	
	switch(ppaPortNumber)
	{
    	case 0x0000:
		    if(cadenceEnable)
			{
               port0CadOn = 1;
			}
			else
			{
				port0CadOn = 0;
			}
            break;
        case 0x0001:
            if(cadenceEnable)
			{
               port1CadOn = 1;
			}
			else
			{
			   port1CadOn = 0;
			}
            break;
		case 0x0002:
		    if(cadenceEnable)
			{
               port2CadOn = 1;
			}
			else
			{
				port2CadOn = 0;
			}
            break;
        case 0x0003:
            if(cadenceEnable)
			{
               port3CadOn = 1;
			}
			else
			{
			   port3CadOn = 0;
			}
            break;
         default:
            break;
	}
}
#endif /* #ifdef PPA */