myvtm/Module/mod_sipphone/win/audio_session.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "audio_session.h"


#include <memutil.h>
#include <rtp.h>
#include <rtpsession.h>

#include <audioframework.h>
#include <portaudio.h>
#include "libaudioqueue.h"

#include "rvc_media_common.h"

#define AUDIO_CLOCK	8000
#define AUDIO_SHM_FRAME_TIME	20 // 20ms

#ifndef RVC_MAX_BUFFER_LEN
#define RVC_MAX_BUFFER_LEN 1024
#endif

#ifndef RVC_AUDIO_FRAME_LEN
#define RVC_AUDIO_FRAME_LEN	320
#endif

char straudiodata[RVC_MAX_BUFFER_LEN] = {0};
int iIndex = 0;
int iLastLeft = 0;

static int g_nAudioRecvNum = 0;
static int g_nAudioSendNum = 0;

enum e_media_dir 
{
	DIR_NONE = 0,
	DIR_TX = 1, 
	DIR_RX = 2,
	DIR_BOTH = 3,
};

typedef struct audio_recorder_t audio_recorder_t;
typedef struct audio_phonemedia_t audio_phonemedia_t;

struct audio_session_t
{
	audio_session_conf_t conf;
	audio_session_phonemedia_conf_t phonemedia_conf;
	audio_session_t *owner;

	apr_pool_t *pool;
	audioengine_t *engine;
	audiocontext_t *context;
	audiobridge_t *bridge;
	apr_pool_t *micspk_pool;
	audiomicspk2_t *micspkstream;
	audiodsp_t *dspstream;
	audioresize_t *resizestream;
	audiortp_t *rtpstream;
	audiocodec_t *codecstream;
	rtp_session_t *rtpsess;
	Clibaudioqueue*remoteaudioqueue;
	bool brtpinsertqueue;
	bool baudiorecved;
};

static int on_rx_audio(char *frame,void*userdata)
{
	audio_session_t*session = (audio_session_t*)userdata;
	int used = 0;

	if (DOUBLERECORD_CALLTYPE != session->phonemedia_conf.eCalltype)
	{
		if (frame) 
		{
			audio_frame frm;
			frm.bitspersample = 16;
			frm.format = 1;
			frm.data = frame;
			frm.framesize = 160;   //注意此参数可能不准确，网络传输的包大小可能是不定长的，取音频数据时慎用此参数
			//写入实际的单个包大小
			//frm.framesize = strlen(frame);  //不能使用此方法，网络传输的包大小可能是不定长的
			frm.nchannels = 1;
			frm.samplespersec = 8000;
			if (!session->remoteaudioqueue->InsertAudio(&frm)) 
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d", frm.framesize);
				used = -1;
			}
		}
	}
	return used;
}

static void m_on_send_hook(const char *buf, int size, void *arg)
{
	g_nAudioSendNum++;
}

static bool phonemedia_rtp_record(audio_session_t* pseesion)
{
	bool bret = false;
	if (NULL == pseesion){
		return bret;
	}

	if (true == pseesion->brtpinsertqueue){
		if (DOUBLERECORD_CALLTYPE == pseesion->phonemedia_conf.eCalltype){
			if (eStand2sType == pseesion->phonemedia_conf.eDeviceType){
				if (DEV_PICKUP == pseesion->phonemedia_conf.dev_type){
					bret = true;
				}
			}
		}
	}

	return bret;
}


static void m_on_recv_hook(const char *buf, int size, void *arg)
{
	rtp_hdr *hdr = (rtp_hdr*)buf;
	audio_session_t* psession = (audio_session_t*)arg;

	if (false == psession->baudiorecved){
		//char strmsg[MAX_PATH] = { 0 };
		//_snprintf(strmsg, MAX_PATH, "received first audio packet, and packet size is %d, rtp port (%d <-----> %d).", size, psession->phonemedia_conf.local_rtp_port, psession->phonemedia_conf.remote_rtp_port);
		//LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_AUDIO_STREAM_RECEIVED, strmsg);
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(strmsg);
		psession->baudiorecved = true;
	}

	if ((g_nAudioRecvNum%100) == 0){
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv audio pkt num %d, single size %d",g_nAudioRecvNum,size);
		//if (psession->phonemedia_conf.eDeviceType == eStand2sType){
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("current hand free flag is %d, call type = %d, pt = %d,arg addr is 0x%08x.",(int)psession->phonemedia_conf.dev_type, psession->phonemedia_conf.eCalltype, hdr->pt, arg);
		//}	
	}
	
	if (0 == psession->phonemedia_conf.dev_type && DOUBLERECORD_CALLTYPE == psession->phonemedia_conf.eCalltype){
		if (false == psession->brtpinsertqueue){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("rtp stream insert to audio queue flag is set to true.");
		}
		psession->brtpinsertqueue = true;
	}
	g_nAudioRecvNum++;

	if (true == phonemedia_rtp_record(psession)){
		char strbuffer[RVC_MAX_BUFFER_LEN]={0};
		int outsize = RVC_MAX_BUFFER_LEN;
		switch(hdr->pt)
		{
		case RTP_PT_PCMA:
			audiocodec_pcma_decode(buf+sizeof(rtp_hdr), size-sizeof(rtp_hdr), strbuffer, &outsize);
			break;
		case RTP_PT_PCMU:
			audiocodec_pcmu_decode(buf+sizeof(rtp_hdr), size-sizeof(rtp_hdr), strbuffer, &outsize);
			break;
		case RTP_PT_G729:
			audiocodec_g729a_decode(buf+sizeof(rtp_hdr), size-sizeof(rtp_hdr), strbuffer, &outsize);
			break;
		default:
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audiocodec_decode not support audio pt(%d).", hdr->pt);
			break;
		}

		if (psession && psession->remoteaudioqueue){
			int iCount = (outsize+iLastLeft)/RVC_AUDIO_FRAME_LEN;
			memcpy(straudiodata+iLastLeft, strbuffer, iCount*RVC_AUDIO_FRAME_LEN-iLastLeft);
			for(int i = 0; i < iCount; i++)
			{
				audio_frame frm;
				char straudio[RVC_AUDIO_FRAME_LEN]={0};
				memcpy(straudio, straudiodata+i*RVC_AUDIO_FRAME_LEN, RVC_AUDIO_FRAME_LEN);
				frm.bitspersample = 16;
				frm.format = 1;
				frm.data = straudio;
				frm.framesize = RVC_AUDIO_FRAME_LEN;   //注意此参数可能不准确，网络传输的包大小可能是不定长的，取音频数据时慎用此参数
				frm.nchannels = 1;
				frm.samplespersec = 8000;
				if (!psession->remoteaudioqueue->InsertAudio(&frm)) 
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d", frm.framesize);
				}
			}
			memset(straudiodata, 0, RVC_MAX_BUFFER_LEN);									//清空缓存
			iLastLeft = (outsize + iLastLeft) % RVC_AUDIO_FRAME_LEN;						//上次剩余不足RVC_AUDIO_FRAME_LEN的buffer
			if ((0 != iLastLeft) && (iCount*RVC_AUDIO_FRAME_LEN < outsize)){
				memcpy(straudiodata, strbuffer+iCount*RVC_AUDIO_FRAME_LEN, iLastLeft);		//暂存上一次的未入队列的音频数据
			}
		}
		else{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pseesion->remoteaudioqueue is null.");
		}
	}
}


static void audio_device_event(int bopen, int iret, int bmicro, int idev, const char* strmessage, void* user_data)
{
	char strinfo[MAX_PATH] = { 0 };
	DWORD errorcode = 0;
	if (bopen){
		if (DEV_PICKUP == idev) {
			char strpickup[] = "[pickup]";
			_snprintf(strinfo, MAX_PATH, "%s%s", strmessage, strpickup);
			if (0 == iret) {
				if (bmicro) {
					errorcode = EVENT_MOD_SIP_PICKUP_IN_AUDIO_DEVICE_OPEN_SUCCESS;
				}
				else {
					errorcode = EVENT_MOD_SIP_PICKUP_OUT_AUDIO_DEVICE_OPEN_SUCCESS;
				}
			}
			else {
				if (bmicro) {
					errorcode = EVENT_MOD_SIP_PICKUP_IN_AUDIO_DEVICE_OPEN_FAILED;
				}
				else {
					errorcode = EVENT_MOD_SIP_PICKUP_OUT_AUDIO_DEVICE_OPEN_FAILED;
				}
			}
		}
		else {
			char strhandfree[] = "[hand free]";
			_snprintf(strinfo, MAX_PATH, "%s%s", strmessage, strhandfree);
			if (0 == iret) {
				if (bmicro) {
					errorcode = EVENT_MOD_SIP_HANDFREE_IN_AUDIO_DEVICE_OPEN_SUCCESS;
				}
				else {
					errorcode = EVENT_MOD_SIP_HANDFREE_OUT_AUDIO_DEVICE_OPEN_SUCCESS;
				}
			}
			else {
				if (bmicro) {
					errorcode = EVENT_MOD_SIP_HANDFREE_IN_AUDIO_DEVICE_OPEN_FAILED;
				}
				else {
					errorcode = EVENT_MOD_SIP_HANDFREE_OUT_AUDIO_DEVICE_OPEN_FAILED;
				}
			}
		}
	}
	else {
		if (DEV_PICKUP == idev) {
			char strpickup[] = "[pickup]";
			_snprintf(strinfo, MAX_PATH, "%s%s", strmessage, strpickup);
			if (bmicro) {
				errorcode = EVENT_MOD_SIP_PICKUP_IN_AUDIO_DEVICE_CLOSE;
			}
			else {
				errorcode = EVENT_MOD_SIP_PICKUP_OUT_AUDIO_DEVICE_CLOSE;
			}
		}
		else {
			char strhandfree[] = "[hand free]";
			_snprintf(strinfo, MAX_PATH, "%s%s", strmessage, strhandfree);
			if (bmicro) {
				errorcode = EVENT_MOD_SIP_HANDFREE_IN_AUDIO_DEVICE_CLOSE;
			}
			else {
				errorcode = EVENT_MOD_SIP_HANDFREE_OUT_AUDIO_DEVICE_CLOSE;
			}
		}
	}

	LogWarn(Severity_Low, Error_Debug, errorcode, strinfo);
}


static void m_on_recv_hook_backup(const char *buf, int size, void *arg)
{
	rtp_hdr *hdr = (rtp_hdr*)buf;
	audio_session_t* pseesion = (audio_session_t*)arg;
	g_nAudioRecvNum++;
	//if ((g_nAudioRecvNum%60) == 0)
	//{
	//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv audio pkt num %d,single size %d",g_nAudioRecvNum,size);
	//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pt = %d,arg addr is 0x%08x.",hdr->pt, arg);
	//}
	if (g_nAudioRecvNum % 2)
	{
		memset(straudiodata, 0, RVC_MAX_BUFFER_LEN);
		memcpy(straudiodata, buf+sizeof(rtp_hdr), size-sizeof(rtp_hdr));
		iIndex = (size-sizeof(rtp_hdr));
	} 
	else
	{
		memcpy(straudiodata+iIndex, buf+sizeof(rtp_hdr), size-sizeof(rtp_hdr));
		iIndex = 0;

		char strbuffer[RVC_MAX_BUFFER_LEN]={0};
		int outsize = RVC_MAX_BUFFER_LEN;
		switch(hdr->pt)
		{
		case RTP_PT_PCMA:
			audiocodec_pcma_decode(straudiodata, 2*(size-sizeof(rtp_hdr)), strbuffer, &outsize);
			break;
		case RTP_PT_PCMU:
			audiocodec_pcmu_decode(straudiodata, 2*(size-sizeof(rtp_hdr)), strbuffer, &outsize);
			break;
		case RTP_PT_G729:
			audiocodec_g729a_decode(straudiodata, 2*(size-sizeof(rtp_hdr)), strbuffer, &outsize);
			break;
		default:
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audiocodec_decode not support audio pt(%d).", hdr->pt);
			break;
		}

		if (pseesion && pseesion->remoteaudioqueue){
			int iCount = outsize/320;
			for(int i = 0; i < iCount; i++)
			{
				audio_frame frm;
				char straudio[320]={0};
				memcpy(straudio, strbuffer+i*320, 320);
				frm.bitspersample = 16;
				frm.format = 1;
				frm.data = straudio;
				frm.framesize = 320;   //注意此参数可能不准确，网络传输的包大小可能是不定长的，取音频数据时慎用此参数
				////写入实际的单个包大小
				//frm.framesize = strlen(frame);  //不能使用此方法，网络传输的包大小可能是不定长的
				frm.nchannels = 1;
				frm.samplespersec = 8000;
				if (!pseesion->remoteaudioqueue->InsertAudio(&frm)) 
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d", frm.framesize);
				}
			}
		}
		else{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pseesion->remoteaudioqueue is null.");
		}
	}
}
//static int translate_id(int in_direction, int idx);

static int phonemedia_stop(audio_session_t *session, int b_record_turn_off);

static void phonemedia_reconfig(audio_session_t *media, const audio_session_phonemedia_conf_t *conf)
{
	memcpy(&media->phonemedia_conf, conf, sizeof(audio_session_phonemedia_conf_t));
}

static int phonemedia_start(audio_session_t *session)
{
	audio_session_t *media = session;
	audio_session_phonemedia_conf_t *conf = &media->phonemedia_conf;
	apr_status_t status;
	int rc;
	int opt_micspk;
	const char *in_dev;
	const char *out_dev;
	int in_agc;
	int out_agc;
	int in_ns;
	int out_ns;
	int aec;
	const char *codec;
	int istoptype;

	in_dev = &session->conf.in_dev[conf->dev_type][0];
	out_dev = &session->conf.out_dev[conf->dev_type][0];
	istoptype = media->conf.istoptype;

	opt_micspk = AMS_OPT_AS_STREAM;
	if (conf->dir & DIR_TX) {
		opt_micspk |= AMS_OPT_PLAY;
	}
	if (conf->dir &DIR_RX) {
		opt_micspk |= AMS_OPT_RECORD;
	}

	in_agc = media->conf.agc_in[conf->dev_type];
	out_agc = media->conf.agc_out[conf->dev_type];
	in_ns = media->conf.ns_in[conf->dev_type];
	out_ns = media->conf.ns_out[conf->dev_type];
	aec = media->conf.aec[conf->dev_type];
	

	switch (conf->local_pt) {
	case 0:
		codec = "PCMU";
		if (conf->local_ptime == 0)
			conf->local_ptime = 20;
		if (conf->remote_ptime == 0)
			conf->remote_ptime = 20;
		break;
#if 0
	case 4:
		codec = "G723";
		if (conf->local_ptime == 0)
			conf->local_ptime = 30;
		if (conf->remote_ptime == 0)
			conf->remote_ptime = 30;
		break;
#endif
	case 8: 
		codec = "PCMA";
		if (conf->local_ptime == 0)
			conf->local_ptime = 20;
		if (conf->remote_ptime == 0)
			conf->remote_ptime = 20;
		break;
	case 18:
		codec = "G729";
		if (conf->local_ptime == 0)
			conf->local_ptime = 20;
		if (conf->remote_ptime == 0)
			conf->remote_ptime = 20;
		break;
	default:
		codec = NULL;
		break;
	}
	if (codec == NULL)
		goto on_error;
	//assert(conf->local_ptime == conf->remote_ptime);
	if (conf->local_ptime != conf->remote_ptime) {
		conf->local_ptime = conf->remote_ptime;
	}

	status = apr_pool_create(&media->pool, NULL);
	if (status != APR_SUCCESS) {
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_APR_POOL_CREATE_FAILED, "create media pool failed!");
		return Error_Resource;
	}

	status = audioengine_create(media->pool, &media->engine);
	if (status != APR_SUCCESS) {
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_ENGINE_CREATE_FAILED, "create audio engine failed!");
		goto on_error;
	}

	status = audioengine_start(media->engine);
	if (status != APR_SUCCESS) {
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_ENGINE_START_FAILED, "audio engine  start failed!");
		goto on_error;
	}

	rc = rtp_session_create2(conf->local_rtp_ip, conf->local_rtp_port, 
		2, &media->rtpsess);
	if (rc != 0) {
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_RTP_SESSION_CREATE_FAILED, CSimpleStringA::Format("audio rtp session create2 failed and local port is %d, rc=%d", conf->local_rtp_port, rc).GetData());
		//LogWarn(Severity_Middle, Error_Debug, EVENT_MOD_SIP_AUDIO_RTP_CREATE, strmsg);
		goto on_error;
	}

	//rc = rtp_session_reset2(media->rtpsess, conf->dir|RTP_SESSION_FLAG_NO_RTCP, conf->remote_rtp_ip, conf->remote_rtp_port, conf->remote_rtp_port+1);
	rc = rtp_session_reset2(media->rtpsess, conf->dir, conf->remote_rtp_ip, conf->remote_rtp_port, conf->remote_rtp_port+1);
	if (rc != 0) {
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_RTP_SESSION_RESET_FAILED, "audio rtp session reset failed!");
		goto on_error;
	}
	
	status = audiobridge_create(media->pool, media->engine, &media->bridge);
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_BRIDGE_CREATE_FAILED, "audio bridge create failed!");
		goto on_error;
	}

	status = apr_pool_create(&media->micspk_pool, media->pool);
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_APR_POOL_CREATE_FAILED, "create media micspk_pool failed!");
		goto on_error;
	}

	if (in_agc)
		opt_micspk |= AMS2_OPT_AGC;
	if (in_ns)
		opt_micspk |= AMS2_OPT_NS;
	if (aec)
		opt_micspk |= AMS2_OPT_AEC;
	//create Spk 
	status = audiomicspk2_create(media->micspk_pool, media->engine, opt_micspk, AUDIO_CLOCK, in_dev, out_dev, istoptype, conf->dev_type, &audio_device_event, &media->micspkstream);
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_MICSPK2_CREATE_FAILED, "create audio micspk2(windows) failed!");
		goto on_error;
	}
	//音频回调
	media->micspkstream->user_data = media;
	media->micspkstream->on_rx_audio = &on_rx_audio;
	//status = audiomicspk3_create(media->micspk_pool, media->engine, opt_micspk, AUDIO_CLOCK, in_dev, out_dev, &media->micspkstream);

	if (out_agc || out_ns) {
		int read_opt = AUDIO_DSP_NONE;
		int write_opt = AUDIO_DSP_NONE;
		if (out_agc)
			write_opt |= AUDIO_DSP_AGC;
		if (out_ns)
			write_opt |= AUDIO_DSP_DENOISE;

		status = audiodsp_create(media->micspk_pool, media->engine, read_opt, write_opt, AUDIO_CLOCK, &media->dspstream);
		if (status != APR_SUCCESS){
			LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_DSP_CREATE_FAILED, "create audio dsp failed!");
			goto on_error;
		}
	}
#if 0
	status = audioaec_create(media->pool, media->engine, AUDIO_CLOCK, FRAME_TIME, 
		AUDIO_AEC_OPT_READ_AS_CAPTURE, &media->aecstream);
	if (status != APR_SUCCESS)
		goto on_error;
#endif
	status = audioresize_create(media->pool, media->engine, FRAME_TIME*2*AUDIO_CLOCK/1000, 
		conf->remote_ptime*2*AUDIO_CLOCK/1000, FRAME_TIME*2*AUDIO_CLOCK/1000, 
		conf->local_ptime*2*AUDIO_CLOCK/1000, &media->resizestream);
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_RESIZE_CREATE_FAILED, "create audio resize failed!");
		goto on_error;
	}

	status = audiocodec_create(media->pool, media->engine, codec, AUDIO_CLOCK, FRAME_TIME, 
		AUDIO_CODEC_OPT_ENCODE_WRITE, &media->codecstream);
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_CODEC_CREATE_FAILED, "create audio codec failed!");
		goto on_error;
	}

	status = audiortp_create(media->pool, media->engine, media->rtpsess, &media->rtpstream);
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_RTP_CREATE_FAILED, "create audio rtp failed!");
		goto on_error;
	}

	g_nAudioRecvNum = 0;
	g_nAudioSendNum = 0;
	{
		int param;
		param = AUDIO_CLOCK;
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_SEND_CLOCK, &param);
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_RECV_CLOCK, &param);
		param = conf->local_pt;
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_SEND_PT, &param);
		param = conf->remote_pt;
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_RECV_PT, &param);
		param = conf->local_dtmf_pt;
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_SEND_DTMF, &param);
		param = conf->remote_dtmf_pt;
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_RECV_DTMF, &param);
		param = conf->local_ptime;
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_SEND_PTIME, &param);
		param = conf->remote_ptime;
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_RECV_PTIME, &param);
		//media->rtpstream->m_on_send_hook = &m_on_recv_hook;
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv hook addr %d,send hook addr %d", &m_on_recv_hook,&m_on_send_hook);
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_HOOK_ARG, media);
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AUDIO_RTP_FLAG_HOOK_ARG addr is 0x%08x.", media);
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_RECV_HOOK, &m_on_recv_hook);
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_SEND_HOOK, &m_on_send_hook);
		//audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_HOOK_ARG, media->rtpstream);
		audiortp_init(media->rtpstream);
	}

	if (conf->dir == DIR_TX) 
	{
		if (media->dspstream) 
		{
			audiostream_connect_pipeline(STREAM_DIR_READ, &media->micspkstream->base, &media->dspstream->base, NULL);
		} 
		else 
		{
			audiostream_connect_pipeline(STREAM_DIR_READ, &media->micspkstream->base, NULL);
		}
		audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_LEFT, &media->micspkstream->base);
		audiostream_connect_pipeline(STREAM_DIR_WRITE, &media->resizestream->base, &media->codecstream->base, &media->rtpstream->base, NULL);
		audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_RIGHT, &media->resizestream->base);
	} 
	else if (conf->dir == DIR_RX) 
	{
		if (media->dspstream) 
		{
			audiostream_connect_pipeline(STREAM_DIR_WRITE, &media->micspkstream->base, &media->dspstream->base, NULL);
		} 
		else 
		{
			audiostream_connect_pipeline(STREAM_DIR_WRITE, &media->micspkstream->base, NULL);
		}
		audiostream_connect_pipeline(STREAM_DIR_READ, &media->resizestream->base, &media->codecstream->base, &media->rtpstream->base, NULL);
		audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_LEFT, &media->micspkstream->base);
		audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_RIGHT, &media->resizestream->base);
	} 
	else 
	{
		if (media->dspstream) 
		{
			audiostream_connect_pipeline(STREAM_DIR_BOTH, &media->micspkstream->base, &media->dspstream->base, NULL);
		} 
		else 
		{
			audiostream_connect_pipeline(STREAM_DIR_BOTH, &media->micspkstream->base, NULL);
		}
		audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_LEFT, &media->micspkstream->base);
		audiostream_connect_pipeline(STREAM_DIR_BOTH, &media->resizestream->base, &media->codecstream->base, &media->rtpstream->base, NULL);
		audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_RIGHT, &media->resizestream->base);
	}

	status = audiocontext_create(media->pool, media->engine, &media->context);
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_CONTEXT_CREATE_FAILED, "create audio context failed!");
		goto on_error;
	}

	audiocontext_add_driver(media->context, &media->bridge->base);
	audioengine_start_context(media->engine, media->context);

	return 0;

on_error:
	phonemedia_stop(media, TRUE);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("phonemedia_stop error!!!");
	return Error_Resource;
}

static int phonemedia_stop(audio_session_t *session, int b_record_turn_off)
{
	audio_session_t *media = session;
	if (media->context) {
		audioengine_stop_context(media->engine, media->context);
		audiocontext_remove_driver(media->context, &media->bridge->base);
		audiocontext_destroy(media->context);
		media->context = NULL;
	}
	if (media->engine) {
		audioengine_stop(media->engine);
		audioengine_destroy(media->engine);
		media->engine = NULL;
	}
	if (media->bridge) {
		audiobridge_destroy(media->bridge);
		media->bridge = NULL;
	}
	if (media->resizestream) {
		audioresize_destroy(media->resizestream);
		media->resizestream = NULL;
	}
	if (media->codecstream) {
		audiocodec_destroy(media->codecstream);
		media->codecstream = NULL;
	}
	if (media->rtpstream) {
		audiortp_destroy(media->rtpstream);
		media->rtpstream = NULL;
	}
	if (media->rtpsess) {
		unsigned short ilocal_port = 0;
		rtp_session_get_local_rtp_port(media->rtpsess, &ilocal_port);
		rtp_session_destroy(media->rtpsess);
		{
			LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_AUDIO_RTP_DESTROY, CSimpleStringA::Format("audio rtp(media->rtpsess) destroy and local port is %u.", ilocal_port).GetData());
		}
		media->rtpsess = NULL;
	}

	if (media->dspstream) {
		audiodsp_destroy(media->dspstream);
		media->dspstream = NULL;
	}

	if (media->micspkstream) {
		audiomicspk2_destroy(media->micspkstream);
		media->micspkstream = NULL;
		apr_pool_destroy(media->micspk_pool);
		media->micspk_pool = NULL;
	}

	if (media->pool) {
		apr_pool_destroy(media->pool);
		media->pool = NULL;
	}
	return 0;
}

static int phonemedia_chang_dev(audio_session_t *session, e_dev_type t)
{
	audio_session_t *media = session;
	audio_session_phonemedia_conf_t *conf = &media->phonemedia_conf;
	int opt_micspk;
	const char *in_dev;
	const char *out_dev;
	int in_agc;
	int out_agc;
	int in_ns;
	int out_ns;
	int aec;
	int istoptype;

	in_dev = &session->conf.in_dev[t][0];
	out_dev = &session->conf.out_dev[t][0];

	in_agc = media->conf.agc_in[t];
	out_agc = media->conf.agc_out[t];
	in_ns = media->conf.ns_in[t];
	out_ns = media->conf.ns_out[t];
	aec = media->conf.aec[t];
	istoptype = media->conf.istoptype;

	opt_micspk = AMS_OPT_AS_STREAM;
	if (conf->dir & DIR_TX) {
		opt_micspk |= AMS_OPT_PLAY;
	}
	if (conf->dir & DIR_RX) {
		opt_micspk |= AMS_OPT_RECORD;
	}

	if (media->pool) {
		//apr_status_t status;
		audiocontext_remove_driver(media->context, &media->bridge->base);
		if (media->micspkstream) {
			audiomicspk2_destroy(media->micspkstream);
			media->micspkstream = NULL;
		}
		if (media->dspstream) {
			audiodsp_destroy(media->dspstream);
			media->dspstream = NULL;
		}
		apr_pool_destroy(media->micspk_pool);
		apr_pool_create(&media->micspk_pool, media->pool);
		if (in_agc)
			opt_micspk |= AMS2_OPT_AGC;
		if (in_ns)
			opt_micspk |= AMS2_OPT_NS;
		if (aec)
			opt_micspk |= AMS2_OPT_AEC;

		audiomicspk2_create(media->micspk_pool, media->engine, opt_micspk, AUDIO_CLOCK, in_dev, out_dev, istoptype, t, &audio_device_event, &media->micspkstream);
		media->micspkstream->on_rx_audio = &on_rx_audio;
		media->phonemedia_conf.dev_type = t;

		if (out_agc || out_ns) {
			int read_opt = AUDIO_DSP_NONE;
			int write_opt = AUDIO_DSP_NONE;
			if (out_agc)
				write_opt |= AUDIO_DSP_AGC;
			if (out_ns)
				write_opt |= AUDIO_DSP_DENOISE;
			audiodsp_create(media->micspk_pool, media->engine, read_opt, write_opt, AUDIO_CLOCK, &media->dspstream);		
		}
		if (conf->dir == DIR_TX) {
			if (media->dspstream) {
				audiostream_connect_pipeline(STREAM_DIR_READ, &media->micspkstream->base, &media->dspstream->base, NULL);
			} else {
				audiostream_connect_pipeline(STREAM_DIR_READ, &media->micspkstream->base, NULL);
			}
			audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_LEFT, &media->micspkstream->base);
			audiostream_connect_pipeline(STREAM_DIR_WRITE, &media->resizestream->base, &media->codecstream->base, &media->rtpstream->base, NULL);
			audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_RIGHT, &media->resizestream->base);
		} else if (conf->dir == DIR_RX) {
			if (media->dspstream) {
				audiostream_connect_pipeline(STREAM_DIR_WRITE, &media->micspkstream->base, &media->dspstream->base, NULL);
			} else {
				audiostream_connect_pipeline(STREAM_DIR_WRITE, &media->micspkstream->base, NULL);
			}
			audiostream_connect_pipeline(STREAM_DIR_READ, &media->resizestream->base, &media->codecstream->base, &media->rtpstream->base, NULL);
			audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_LEFT, &media->micspkstream->base);
			audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_RIGHT, &media->resizestream->base);
		} else {
			if (media->dspstream) {
				audiostream_connect_pipeline(STREAM_DIR_BOTH, &media->micspkstream->base, &media->dspstream->base, NULL);
			} else {
				audiostream_connect_pipeline(STREAM_DIR_BOTH, &media->micspkstream->base, NULL);
			}
			audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_LEFT, &media->micspkstream->base);
			audiostream_connect_pipeline(STREAM_DIR_BOTH, &media->resizestream->base, &media->codecstream->base, &media->rtpstream->base, NULL);
			audiobridge_set_leg(media->bridge, AUDIO_BRIDGE_LEG_RIGHT, &media->resizestream->base);
		}

		audiortp_reset_jitter(media->rtpstream);
		audiocontext_add_driver(media->context, &media->bridge->base);
		return 0;
	} else {
		return Error_NotInit;
	}
	
	return Error_Unexpect;
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//// audio session

int audio_session_create(const audio_session_conf_t *conf, audio_session_t **p_session)
{
	audio_session_t *session = ZALLOC_T(audio_session_t);
	session->remoteaudioqueue = new Clibaudioqueue(REC_COMMON_REMOTEAUDIO_SHM_QUEUE);
	session->brtpinsertqueue = false;
	session->baudiorecved = false;
	if (session) {
		memcpy(&session->conf, conf, sizeof(audio_session_conf_t));
		*p_session = session;
		return 0;
	} else {
		return Error_Resource;
	}
}

int audio_session_start_phonemedia(audio_session_t *session, const audio_session_phonemedia_conf_t *conf)
{
	int rc;
	if (!session)
		return Error_NotInit;
	if (session->pool) { // already started
		phonemedia_stop(session, FALSE);
	}
	phonemedia_reconfig(session, conf);
	rc = phonemedia_start(session);
	return rc;
}

int audio_session_change_dev(audio_session_t *session, e_dev_type t)
{
	return phonemedia_chang_dev(session, t);
}

int audio_session_stop(audio_session_t *session)
{
	return phonemedia_stop(session, TRUE);
}

void audio_session_destroy(audio_session_t *session)
{
	if (session->remoteaudioqueue)
	{
		delete session->remoteaudioqueue;
	}
	assert(session->pool == NULL);
	free(session);
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static void __stdcall __audio_log_func(int level, const char *s)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(s);
}


//static char* utf8togb2312(const char* utf8)
//{
//	int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
//
//	wchar_t* wstr = new wchar_t[len + 1];
//	memset(wstr, 0, (len + 1)*sizeof(wchar_t));
//
//	MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
//	len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
//
//	char* str = new char[len + 1];
//	memset(str, 0, (len + 1)*sizeof(char));
//
//	WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
//
//	if (wstr) {
//		delete[]wstr;
//		wstr = NULL;
//	}
//	return str;
//}
//
//
//static char* gb2312toutf8(const char* gb2312)
//{
//	int len = MultiByteToWideChar(CP_ACP, 0, gb2312, -1, NULL, 0);
//	wchar_t* wstr = new wchar_t[len + 1];
//	memset(wstr, 0, (len + 1)*sizeof(wchar_t));
//
//	MultiByteToWideChar(CP_ACP, 0, gb2312, -1, wstr, len);
//	len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
//
//	char* str = new char[len + 1];
//	memset(str, 0, (len + 1)*sizeof(char));
//	WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
//	if (wstr) {
//		delete[] wstr;
//		wstr = NULL;
//	}
//	return str;
//}


int audio_lib_init()
{
	audio_log_set_func(&__audio_log_func);

	int rc = audioframework_init();
	if (rc != 0) {
		return Error_Resource;
	} else {
		int icnt, ocnt;
		audio_log_set_func(NULL);
		rc = audio_get_dev_count(&icnt, &ocnt);
		if (rc == 0) {
			int i;
			CSimpleStringA strJsonIn;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio input devices(%d):", icnt);
			for (i = 0; i < icnt; ++i) {
				CSimpleStringA str = audio_get_dev_name(true, i);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d = %s", i, str.GetData());
				strJsonIn += CSimpleStringA::Format("\"%d\":\"%s\",", i, str.GetData());
			}

			if (strJsonIn.GetLength() > 0) {
				strJsonIn[strJsonIn.GetLength() - 1] = '\0';
			}
			CSimpleStringA strJsonInData = CSimpleStringA::Format("audio in devices [{%s}]", strJsonIn.GetData());
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_SIPPHONE_GET_AUDIO_IN_INFOS, strJsonInData.GetData());

			CSimpleStringA strJsonOut;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio output devices(%d):", ocnt);
			for (i = 0; i < ocnt; ++i) {
				CSimpleStringA str = audio_get_dev_name(false, i);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d = %s", i, str.GetData());
				strJsonOut += CSimpleStringA::Format("\"%d\":\"%s\",", i, str.GetData());
			}
			if (strJsonOut.GetLength() > 0) {
				strJsonOut[strJsonOut.GetLength() - 1] = '\0';
			}
			CSimpleStringA strJsonOutData = CSimpleStringA::Format("audio out devices [{%s}]", strJsonOut.GetData());
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_SIPPHONE_GET_AUDIO_OUT_INFOS, strJsonOutData.GetData());
		}
		audio_log_set_func(&__audio_log_func);
	}

	return 0;
}

void audio_lib_deinit()
{
	audioframework_term();
}

int audio_get_dev_count(int *in_cnt, int *out_cnt)
{
	int icnt = 0, ocnt = 0;
	int cnt = Pa_GetDeviceCount();
	for (int i = 0; i < cnt; ++i) {
		const PaDeviceInfo *info = Pa_GetDeviceInfo(i);
		if (info->maxInputChannels)
			icnt ++;
		if (info->maxOutputChannels)
			ocnt ++;
	}
	if (in_cnt)
		*in_cnt = icnt;
	if (out_cnt)
		*out_cnt = ocnt;
	return 0;
}

CSimpleStringA audio_get_dev_name(bool in_direction, int idx)
{
	audio_log_set_func(NULL);
	int cnt = Pa_GetDeviceCount();
	int ii, i;
	for (i = 0, ii = 0; i < cnt; ++i) {
		const PaDeviceInfo *info = Pa_GetDeviceInfo(i);
		if (in_direction) {
			if (info->maxInputChannels) {
				if (idx == ii) {
					CSimpleStringA strInDevice = CSimpleStringA(info->name);
					return strInDevice;
				}
				ii++;
			}
		} else {
			if (info->maxOutputChannels) {
				if (idx == ii) {
					CSimpleStringA strOutDevice = CSimpleStringA(info->name);
					return strOutDevice;
				}
				ii++;
			}
		}
	}
	return CSimpleStringA();
}

int capture_get_audio_device_id(bool in_direction, const char *dev_name)
{
	if (NULL == dev_name) {
		return -1;
	}

	int cnt = Pa_GetDeviceCount();
	int ii, i;
	for (i = 0, ii = 0; i < cnt; ++i) {
		const PaDeviceInfo *info = Pa_GetDeviceInfo(i);
		if (in_direction) {
			if (info->maxInputChannels) {
				if (strstr(info->name, dev_name) != NULL) {
					return ii;
				}
				ii++;
			}
		} 
		else {
			if (info->maxOutputChannels) {
				if (strstr(info->name, dev_name) != NULL) {
					return ii;
				}
				ii++;
			}
		}
	}
	return -1;
}