h323f.cpp

基于h323协议的软phone

    for (i = 0; i < size; i++)
    {
        if (val <= *table++)
            return (i);
    }
    return (size);
}
unsigned char
linear2ulaw(
    int	pcm_val)	/* 2's complement (16-bit range) */
{
    int	mask;
    int	seg;
    unsigned char	uval;

    /* if someone has passed in a bum short (e.g. they manipulated an
     * int rather than a short, so the value looks positive, not
     * negative) fix that */
    if(pcm_val & 0x8000)
    {
	pcm_val = - (~pcm_val & 0x7fff) - 1;
    }

    /* Get the sign and the magnitude of the value. */
    if (pcm_val < 0)
    {
        pcm_val = BIAS - pcm_val;
        mask = 0x7F;
    }
    else
    {
        pcm_val += BIAS;
        mask = 0xFF;
    }

    /* Convert the scaled magnitude to segment number. */
    seg = search(pcm_val, seg_end, 8);

    /*
     * Combine the sign, segment, quantization bits;
     * and complement the code word.
     */
    if (seg >= 8)		/* out of range, return maximum value. */
        return (0x7F ^ mask);
    else
    {
        uval = (seg << 4) | ((pcm_val >> (seg + 3)) & 0xF);
        return (uval ^ mask);
    }

}

void readRTPPacket
    (
        IN  HRTPSESSION  hRTP,
        IN  void *       rtpSess
    )
{
	unsigned char dBuf[1024];
	rtpParam p;
	HRTPSESSION rtpSession = (HRTPSESSION)rtpSess;
	
	if (rtpSession == NULL)
	{
		//printf("wpCallInfo[sId].rtpSession == NULL, return...\n");
		return;
	}
	if (rtpReadEx(rtpSession, (void * )dBuf, 1024, 0, &p) < 0)
		//(timerGetTimeInSeconds() - rtp_start_time)*8, &p) < 0)
	{
		//printf("rtpReadEx return error, return...\n");
		return;
	}
	int temp;
	//将711u解码成PCM格式
	for (int i = 0; i < 160; i++)
	{
		temp = ulaw2linear(dBuf[p.sByte+i]);
		lpData[2*i] = temp & 0x00ff;
		lpData[2*i+1] = temp >> 8;
	}

	WaveHead.lpData=(LPSTR)lpData;
	WaveHead.dwBufferLength=320;
	WaveHead.dwFlags=0L;
	WaveHead.dwLoops=0L;

	//往WAV设备中添加数据
	if (waveOutPrepareHeader(hWaveOut,&WaveHead, sizeof(WAVEHDR)))
	{
		closeWav();
		return;
	}

	if (waveOutWrite(hWaveOut,&WaveHead,sizeof(WAVEHDR)))
	{
		closeWav();
		return;
	}	
	//Sleep(20);
}
void  StartRec()
{
	MMRESULT m_mmr;
	int i;
	
	WaveInHdr = new WAVEHDR[2];
	waveInReset(hWaveIn);
	for(i=0;i<2;i++)
	{
		ZeroMemory(&WaveInHdr[i],sizeof(WAVEHDR));
		WaveInHdr[i].lpData = new char[SIZE_AUDIO_FRAME];
		WaveInHdr[i].dwBufferLength = SIZE_AUDIO_FRAME;
		m_mmr = waveInPrepareHeader(hWaveIn,&WaveInHdr[i],sizeof(WAVEHDR));
		if (m_mmr)
		{
			AfxMessageBox("waveInPrepareHeader failed");
			return;
		}
		m_mmr = waveInAddBuffer(hWaveIn,&WaveInHdr[i],sizeof(WAVEHDR));
		if (m_mmr)
		{
			AfxMessageBox("waveInAddBuffer failed");
			return;
		}
	}
	m_mmr = waveInStart(hWaveIn);  
	if (m_mmr)
	{
		AfxMessageBox("waveInStart failed");
		return;
	}
}

void GetData(char *pBuffer, void* rtpSess)
{
	int i,j;
	unsigned char dBuf[160];
	rtpParam p;
	

	RvUint8 sendCodec = PCMU;
	HRTPSESSION rtpSession = (HRTPSESSION)rtpSess;
	p.marker = 0;
	m_soLock.Lock ();

	for(i=0;i<3;i++)
	{
		switch (sendCodec)
		{
			case PCMU:
			case PCMA: 
				rtp_last_time += G711_TIMESTAMP_INTERVAL; break;
			case G729:
				rtp_last_time += G729_TIMESTAMP_INTERVAL; break;	
			case G7231:
				rtp_last_time += G723_TIMESTAMP_INTERVAL; break;
			default:
				rtp_last_time += G711_TIMESTAMP_INTERVAL; break;
		}
		p.timestamp = rtp_last_time;
		p.payload = sendCodec;
		p.sByte = 12;
		for(j=0;j<160;j++)
			dBuf[j] = linear2ulaw(((short*)pBuffer)[j+i*160]);
		rtpWrite(rtpSession, (void *)dBuf, sizeof(dBuf)+p.sByte, &p);
		Sleep(20);
	}
	m_soLock.Unlock ();


}
DWORD WINAPI AudioInThreadProc(void* rtpSess)
{

/*	CWaveIn *pWaveIn;
	pWaveIn = (CWaveIn *)lpParameter;
*/
	char buffer[960];
	MSG msg;
	while(GetMessage(&msg,0,0,0))
	{
		switch(msg.message )
		{
			case MM_WIM_OPEN:
				break;
			case MM_WIM_CLOSE:
				break;
			case MM_WIM_DATA:
				WAVEHDR* pWH=(WAVEHDR*)msg.lParam;
				waveInUnprepareHeader((HWAVEIN)msg.wParam,pWH,sizeof(WAVEHDR));
			
				if(pWH->dwBytesRecorded!=SIZE_AUDIO_FRAME)
					break;

				memcpy(buffer,pWH->lpData,pWH->dwBytesRecorded);
				GetData (buffer,rtpSess);

				waveInPrepareHeader((HWAVEIN)msg.wParam,pWH,sizeof(WAVEHDR));
				
				waveInAddBuffer(hWaveIn,pWH,sizeof(WAVEHDR));

				break;
		}
	}
	TRACE("AudioInThreadProc exit.\n");
	return msg.wParam;

}
#include "rvwpt.h"
int startJbAndRtp(HRTPSESSION rtpSession)
{
	
	char remoteIPAddress[16];
	int remoteRtpPort;
	HANDLE m_hAudioIn;
	MMRESULT m_mmr;
	DWORD m_dwAudioInId;// = 0;
	//hWaveIn = 0;

	//unsigned char  ip[4];

	sprintf(remoteIPAddress, "%u.%u.%u.%u", 
		appCallInfo[callIndex].codec.remoteRtpIpAddr & 0xFF, 
		(appCallInfo[callIndex].codec.remoteRtpIpAddr >> 8) & 0xFF,
		(appCallInfo[callIndex].codec.remoteRtpIpAddr >> 16) & 0xFF,
		appCallInfo[callIndex].codec.remoteRtpIpAddr >> 24);
	remoteRtpPort = appCallInfo[callIndex].codec.remoteRtpPort;

#ifndef INCLUDE_RV_RTP
	Sptr<RtpSession> rtpSession = new RtpSession(
									remoteIPAddress, 
									remoteRtpPort, FIRST_RTP_PORT + callId * 2,
									remoteRtpPort + 1, FIRST_RTP_PORT + callId * 2 + 1);

	rtpSession->setApiFormat (AppGetPayload(appCallInfo[callId].codec.tx), 240, 240);
	rtpSession->setNetworkFormat (AppGetPayload(appCallInfo[callId].codec.rx), 240, 240);
	Sptr<DTMFDevice> _DTMFDevice = new DTMFDevice();
	rtpSession->setDTMFInterface(_DTMFDevice);
	rtpManager->addSession(rtpSession);
	sId = rtpSession->getId();
#endif

	memset(&pFormat, 0, sizeof(WAVEFORMATEX));
	memset(&InFormat, 0, sizeof(WAVEFORMATEX));
	/*pFormat.wf.wFormatTag = WAVE_FORMAT_PCM;
	pFormat.wf.nChannels = 1;
	pFormat.wf.nSamplesPerSec = 64000;
	pFormat.wf.nBlockAlign = 1;
	pFormat.wf.nAvgBytesPerSec =	pFormat.wf.nSamplesPerSec * pFormat.wf.nBlockAlign;
	pFormat.wBitsPerSample = 8;*/
	
	int numChannels = 1, sampleRate = 8000, bitsPerSample = 16;
	pFormat.wFormatTag = WAVE_FORMAT_PCM;
	pFormat.nChannels = (WORD)numChannels;
	pFormat.nSamplesPerSec = sampleRate;
	pFormat.wBitsPerSample = (WORD)bitsPerSample;
	pFormat.nBlockAlign = (WORD)(numChannels*(bitsPerSample+7)/8);
	pFormat.nAvgBytesPerSec = pFormat.nSamplesPerSec*pFormat.nBlockAlign;
	pFormat.cbSize = 0;

	InFormat.wFormatTag = WAVE_FORMAT_PCM;
	InFormat.nChannels = (WORD)numChannels;
	InFormat.nSamplesPerSec = sampleRate;
	InFormat.wBitsPerSample = (WORD)bitsPerSample;
	InFormat.nBlockAlign = (WORD)(numChannels*(bitsPerSample+7)/8);
	InFormat.nAvgBytesPerSec = InFormat.nSamplesPerSec*InFormat.nBlockAlign;
	InFormat.cbSize = 0;

/*
	InFormat.wFormatTag = WAVE_FORMAT_PCM;
	InFormat.nChannels = (WORD)numChannels;
	InFormat.nSamplesPerSec = sampleRate;
	InFormat.nAvgBytesPerSec = numChannels * sampleRate * bitsPerSample / 8;
	InFormat.nBlockAlign = bitsPerSample * numChannels / 8;
	InFormat.wBitsPerSample = bitsPerSample;
	InFormat.cbSize = 0;
*/	
	if (waveOutOpen(&hWaveOut,WAVE_MAPPER, (WAVEFORMATEX*)&pFormat,(DWORD)NULL,
		0,CALLBACK_WINDOW))
	{
		AfxMessageBox("wave out open failed");
		return closeWav();
	}
	m_hAudioIn=CreateThread(0,0,AudioInThreadProc,(void* )rtpSession,0,&m_dwAudioInId);
	if(!m_hAudioIn)
	{
		AfxMessageBox("can not create thread!");
		return 0;
	}

	m_mmr=waveInOpen(&hWaveIn,WAVE_MAPPER,&InFormat,
		m_dwAudioInId,0,CALLBACK_THREAD);
	if(m_mmr)
	{
		AfxMessageBox("wave in open failed");
	/*	return closeInWav();*/
	}
	StartRec();

	rtpSetEventHandler(rtpSession, readRTPPacket, (void*)rtpSession);
	     
	return 0;
}
/**
 * 停止播放等待铃声；
 * 发送WP_SEND_CONN_ACK，接通voice开始通话；
 * 若出错则产生to_dead_end_state事件
 */

int h323_wait_for_connect_state_receive_connect_event(s_event* psEvent, s_task*
    psTask)
{	    	
	
	wp_msg = (WrapperMsg *) psEvent->pMsg;

	appCallInfo[callIndex].ipAddr[3] = wp_msg->d.codec.remoteRtpIpAddr>> 24;
	appCallInfo[callIndex].ipAddr[2] = (wp_msg->d.codec.remoteRtpIpAddr >> 16) & 0xFF;
	appCallInfo[callIndex].ipAddr[1] = (wp_msg->d.codec.remoteRtpIpAddr >> 8) & 0xFF;
	appCallInfo[callIndex].ipAddr[0] = wp_msg->d.codec.remoteRtpIpAddr & 0xFF;
	strncpy(appCallInfo[callIndex].display, 
		wp_msg->baseInfo.display, MAX_DISPLAY_LENGTH);
	appCallInfo[callIndex].display[MAX_DISPLAY_LENGTH] = '\0';
	appCallInfo[callIndex].codec.remoteRtpIpAddr = wp_msg->d.codec.remoteRtpIpAddr;
	appCallInfo[callIndex].codec.remoteRtpPort = wp_msg->d.codec.remoteRtpPort;
	appCallInfo[callIndex].codec.rx = wp_msg->d.codec.rx;
	appCallInfo[callIndex].codec.tx = wp_msg->d.codec.tx;
		
	if(transferred_flag)
	{
		awaiting_transfer = FALSE;
		transferred_flag = FALSE;
	}
	
	if(forwarded_flag)
		forwarded_flag = FALSE;
/*
	if (callActor == CALLER_ACTOR)
	{
		SetRemoteName(appCallInfo[callIndex].display, digit_set);
		SetRemoteNumber(digit_set);	
	}
	else
	{
		SetRemoteName(appCallInfo[callIndex].display, appCallInfo[callIndex].e164Num);
		SetRemoteNumber(appCallInfo[callIndex].e164Num);
	}
*/	
//	H323TRACE("remote name = %s\n", appCallInfo[callIndex].display);
	//H323TRACE("digit_set = %s\n", digit_set);
//	H323TRACE("remote number = %s\n", remoteNumber);
	
	/* 通知菜单复位 */
/*	menu_event = reset_event;
	PreserveLcdMessage = FALSE;
*/
	

     //if(AppGetCodec(appCallInfo[callIndex].codec.rx) != codeTypeNum)
	 //       AppSetCodec(AppGetCodec(appCallInfo[callIndex].codec.rx), 
	//	        AppGetCodec(appCallInfo[callIndex].codec.tx));
	
	startJbAndRtp(wp_msg->rtpSession);
/*	
	StartVoice();
	
	startVoiceTime = getCurrentTime();
*/
	
	

	/* 开始通话，设置计时器 */
	DeleteTimer(&h323_timer);
	
	return null_event;

}

int h323_wait_for_connect_state_to_query_availability_state(s_event* psEvent,
    s_task* psTask)
{
	return null_event;
}

/**
 * 播放忙音，产生to_dead_end_state
 */
int h323_wait_for_connect_state_receive_not_available_event(s_event* psEvent,
    s_task* psTask)
{
	AppTerminateAction(ST_H323_WAIT_FOR_CONNECT_STATE);
	return to_dead_end_state;
}

/**
 * 屏显号码，发送号码
 */
int h323_bidir_voice_state_digit_event(s_event* psEvent, s_task* psTask)
{	
	char digit;
	msg = (NonWrapperMsg *) psEvent->pMsg;
	
	if (msg->digit == 10)
		digit = '*';
	else if (msg->digit == 11)
		digit = '#';
	else
		digit = msg->digit + '0';

/*	switch (phoneconfig.conf_service.dtmftype)
	{
		case DTMF_H245STRING:
			wpSendUserInputId(callIndex, digit);
			break;
		case DTMF_RFC2833EVENT:
#ifndef INCLUDE_RV_RTP
			rtpManager->getSession(sId)->sendEvent(int(msg->digit));
#else
			wpSendDTMF2833(callIndex, digit, 0);
#endif
			break;
		case DTMF_Q931:
			wpSendInformation(callIndex, digit);
			break;
		default:
			break;
	}
*/	return null_event;
}

/**
 * 返回忙或进行呼叫转移
 */
int h323_bidir_voice_state_receive_query_availability_event(s_event* psEvent,
    s_task* psTask)
{
	wp_msg = (WrapperMsg *)psEvent->pMsg;
	AppReplyNotAvailOrFwd(wp_msg);
	return null_event;
}

/**
 * 发送WP_SEND_CALL_TRANSFER_SETUP，产生to_transfer_query_avail_state事件，
 * 若已使用2个通道，或request信息有误，发送响应出错消息
 */
int h323_bidir_voice_state_call_transfer_request(s_event* psEvent, s_task*
    psTask)
{
	char forwardToNumber[40];
	wp_msg = (WrapperMsg *) psEvent->pMsg;
	if (callIndex != wp_msg->baseInfo.callIndex)
	{
		return null_event;
	}

	strncpy(forwardToNumber, wp_msg->d.CallForwardInfo.ForwardToNumber, 39);
	forwardToNumber[39] = '\0';
/*	strncpy(appCallInfo[callIndex].e164Num, 
		forwardToNumber, MAX_E164NUM_LENGTH);
	appCallInfo[callIndex].e164Num[MAX_E164NUM_LENGTH] = '\0';
*/
	/* Transfer has a cycle, do nothing, goto dead_end_state */
	if (wp_msg->d.CallForwardInfo.hasCycle)
	{				
		Sleep(TASKDELAY_ONE_SEC);
		AppTerminateAction( ST_H323_BIDIR_VOICE_STATE);			
		return to_dead_end_state;
	}

	if (wp_msg->d.CallForwardInfo.ForwardToAddrType == REROUTE_TYPE_IPADDR)
	{
		char ip[4];
		int i;
		for (i = 0; i < 4; i++)
		{
			ip[i] = (digit_set[4*i]-'0')*100+(digit_set[4*i+1]-'0')*10+(digit_set[4*i+2]-'0');
		}
		sprintf(digit_set, "*%u%u%u%u", ip[0], ip[1], ip[2], ip[3]);		
	}
	else
	{
		strncpy(digit_set, wp_msg->d.CallForwardInfo.ForwardToNumber,MAX_PHONE_NUMBER_LEN);
		digit_set[MAX_PHONE_NUMBER_LEN]='\0';
	}
	
	/* 通知菜单复位 */
/*	menu_event = reset_event;*/

	/* set starting_transfer flag here so that we can cleanly handle terminate events */
	starting_transfer = TRUE;

	callActor = CALLER_ACTOR;

	/* 设置响应转移请求的时间的计时器 */
	DeleteTimer(&h323_timer);
	h323_timer = CreateTimer(TEN_SEC);
	
	//return to_transfer_query_avail_state; 2004.05.09, change the transition
	return to_query_availability_state;
}


/**
 * 返回忙
 */
int h323_bidir_voice_state_call_transfer_identify_query(s_event* psEvent,
    s_task* psTask)
{

	return null_event;
}

/**
 * 清除全局量
 */
int h323_bidir_voice_state_call_transfer_abandon(s_event* psEvent, s_task*
    psTask)
{

	return null_event;
}


/**
 * 刷新LCD屏显内容
 */
int h323_bidir_voice_state_timeout_event(s_event* psEvent, s_task* psTask)
{
	msg = (NonWrapperMsg *)psEvent->pMsg;
	if ((msg->digit != h323_timer) && (msg->digit != call_forward_timer))
		return null_event;
	/* 计时器清零 */
	h323_timer = -1;
	return null_event;
}

int h323_bidir_voice_state_to_dead_end_state(s_event* psEvent, s_task* psTask)
{

	return null_event;
}

/**
 * 收到终结信号，如对方已挂机
 */
int h323_bidir_voice_state_receive_terminate_event(s_event* psEvent, s_task*
    psTask)
{
	//unsigned char oldCallActor;
	wp_msg = (WrapperMsg *) psEvent->pMsg;
	if (callIndex != wp_msg->baseInfo.callIndex)
	{
			return to_bidir_voice_state;
	}

/*	if(((WrapperMsg *) psEvent->pMsg)->reason == cmCallStateModeDisconnectedNormal)
	{
		LcdShowMessage(H323_REMOTE_HUNG_UP_THE_CALL);
	}
	else
	{
		LcdShowMessage(H323_UNKNOWN_ERROR);
	}

	recordCallTime();
*/
	AppTerminateAction(ST_H323_BIDIR_VOICE_STATE);
//	stopJbAndRtp();
//	StopVoice();

/*	taskDelay(sysClkRateGet()/10);*/
	if (call_numbers > 0)
	{
		return to_bidir_voice_state;
	}
	else
	{
/*		PlayBusyTone(FIFTEEN_SEC);*/
		return null_event;
	}
/*	AppTerminateAction(ST_H323_BIDIR_VOICE_STATE);*/
	return null_event;
	
}