myvtm/Module/mod_sipphone/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 "libaudioqueue.h"
#include "rvc_media_common.h"
#include <string.h>
#include "iaudionsinterface.h"

#ifdef RVC_OS_WIN
#include <portaudio.h>
#endif

#ifndef AUDIO_CLOCK
#define AUDIO_CLOCK	8000
#endif

#ifndef AUDIO_SHM_FRAME_TIME
#define AUDIO_SHM_FRAME_TIME	20 // 20ms
#endif

#ifndef RVC_MAX_BUFFER_LEN
#define RVC_MAX_BUFFER_LEN 512
#endif

#ifndef RVC_AUDIO_BUFFER_SIZE
#define RVC_AUDIO_BUFFER_SIZE 1024
#endif

#ifndef RVC_AUDIO_FRAME_LEN
#define RVC_AUDIO_FRAME_LEN	320
#endif

#ifndef RVC_MIN_AUDIO_SERIESNUMBER
#define RVC_MIN_AUDIO_SERIESNUMBER 10000
#endif // !RVC_MIN_AUDIO_SERIESNUMBER


char straudiodata[RVC_MAX_BUFFER_LEN] = {0};
int iaudiolen = 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;

#ifdef RVC_OS_WIN
	audiomicspk2_t* micspkstream;
#else
	audiomicspkpulse_t* micspkstream;
#endif // RVC_OS_WIN

	audiodsp_t *dspstream;
	audioresize_t *resizestream;
	audiortp_t *rtpstream;
	audiocodec_t *codecstream;
	rtp_session_t *rtpsess;
	Clibaudioqueue*remoteaudioqueue;
	bool baudiorecved;
	bool brtpinsertqueue;
#ifdef RVC_OS_LINUX
	//audio noise suppression
	IAudioNs* audionsobj;
	IAudioNs* audioplaynsobj;
	//FILE* pFile;
	int iaudio_seriesnumber;
#endif
};

#ifdef RVC_OS_WIN
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;
}
#else
static int tx_audio_callback(void* audiodata, void* userdata)
{
	audio_session_t* session = (audio_session_t*)userdata;
	int used = 0;

	return used;
}

static int rvc_audio_ns(void* pdst, size_t udstlen, void* psrc, size_t usrclen, void* user_data)
{
	int iret = -1;
	audio_session_t* session = (audio_session_t*)user_data;
	if (NULL != pdst && NULL != psrc) {
		if (NULL != session && NULL != session->audionsobj) {
			session->audionsobj->NsProcess((char*)pdst, udstlen, (char*)psrc, usrclen);
			//memcpy(pdst, psrc, usrclen);
			iret = 0;
		}
	}

	return iret;
}


static int rvc_audio_play_ns(void* pdst, size_t udstlen, void* psrc, size_t usrclen, void* user_data)
{
	int iret = -1;
	audio_session_t* session = (audio_session_t*)user_data;
	if (NULL != pdst && NULL != psrc) {
		if (NULL != session->audioplaynsobj) {
			session->audioplaynsobj->NsProcess((char*)pdst, udstlen, (char*)psrc, usrclen);
			//memcpy(pdst, psrc, usrclen);
			iret = 0;
		}
	}

	return iret;
}

static int rvc_audio_playing_data(void* pdata, size_t ulen, void* user_data)
{
	int iret = -1;

	audio_session_t* session = (audio_session_t*)user_data;
	if (DOUBLERECORD_CALLTYPE == session->phonemedia_conf.eCalltype) {
		if (iaudiolen + ulen <= RVC_MAX_BUFFER_LEN) {
			memcpy(straudiodata + iaudiolen, pdata, ulen);
			iaudiolen += ulen;
			if (iaudiolen >= RVC_AUDIO_FRAME_LEN) {
				audio_frame frm;
				char straudio[RVC_AUDIO_FRAME_LEN] = { 0 };
				memcpy(straudio, straudiodata, 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;
				frm.iseriesnumber = session->iaudio_seriesnumber++;
				if (!session->remoteaudioqueue->InsertAudio(&frm)) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d.", frm.framesize);
				}
				//else {
				//	if (NULL != session->pFile) {
				//		fwrite(frm.data, RVC_AUDIO_FRAME_LEN, 1, session->pFile);
				//	}
				//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d insert audio(seriesnumber = %d) success! frame count:%d.", __FUNCTION__, __LINE__, frm.iseriesnumber, frm.framesize);
				//}
				memset(straudiodata, 0, RVC_MAX_BUFFER_LEN);
				iaudiolen = 0;
			}
		}
		iret = 0;
	}

	return iret;
}

#endif

static int rx_audio_callback(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;
		#ifdef RVC_OS_LINUX
			frm.iseriesnumber = g_nAudioRecvNum;
		#endif
			if (!session->remoteaudioqueue->InsertAudio(&frm)) 
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertAudio failed! frameCount:%d", frm.framesize);
				used = -1;
			}
		}
	}
	return used;
}

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

static void recv_hook_callback(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){
		LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_AUDIO_STREAM_RECEIVED, CSimpleStringA::Format("received first audio packet, and packet size is %d.", size).GetData());
		psession->baudiorecved = true;
	}
	
#ifdef RVC_OS_WIN
	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_AUDIO_BUFFER_SIZE]={0};
		int outsize = RVC_AUDIO_BUFFER_SIZE;
		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_AUDIO_BUFFER_SIZE);									//清空缓存
			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.");
		}
	}
#endif
}


static void audio_device_event(bool bopen, int iret, bool 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 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;

	in_dev = &session->conf.in_dev[conf->dev_type][0];
	out_dev = &session->conf.out_dev[conf->dev_type][0];
	
	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;
	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_Low, Error_InvalidState, EVENT_MOD_SIP_AUDIO_RTP_CREATE, CSimpleStringA::Format("audio rtp session create2 failed and local port is %d, rc=%d", conf->local_rtp_port, rc).GetData());
		goto on_error;
	}


	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;
#ifdef RVC_OS_WIN
	//create Spk 
status = audiomicspk2_create(media->micspk_pool, media->engine, opt_micspk, AUDIO_CLOCK, in_dev, out_dev, conf->dev_type, &audio_device_event, &media->micspkstream);
#else
	status = audiomicspkpulse_create(media->micspk_pool, media->engine, opt_micspk, AUDIO_CLOCK, in_dev, out_dev, conf->dev_type, &audio_device_event, &media->micspkstream);
#endif
	if (status != APR_SUCCESS){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_SIP_AUDIO_MICSPK_CREATE_FAILED, "create audio audio micspk create failed!");
		goto on_error;
	}
	//音频回调
	media->micspkstream->user_data = media;
	media->micspkstream->on_rx_audio = &rx_audio_callback;
#ifdef RVC_OS_LINUX
	media->micspkstream->on_tx_audio = &tx_audio_callback;
	media->micspkstream->on_audio_ns = &rvc_audio_ns;
	media->micspkstream->on_audio_play_ns = &rvc_audio_play_ns;
	media->micspkstream->on_audio_playing = &rvc_audio_playing_data;
#endif


	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);
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_RECV_HOOK, (const void*)&recv_hook_callback);
		audiortp_set_param(media->rtpstream, AUDIO_RTP_FLAG_SEND_HOOK, (const void*)&send_hook_callback);
		//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) {
#ifdef _WIN32
		audiomicspk2_destroy(media->micspkstream);
#else
		audiomicspkpulse_destroy(media->micspkstream);
#endif
		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;

	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];

	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) {
#ifdef _WIN32
			audiomicspk2_destroy(media->micspkstream);
#else
			audiomicspkpulse_destroy(media->micspkstream);
#endif
			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;

#ifdef RVC_OS_WIN
		audiomicspk2_create(media->micspk_pool, media->engine, opt_micspk, AUDIO_CLOCK, in_dev, out_dev, t, &audio_device_event, &media->micspkstream);
#else
		audiomicspkpulse_create(media->micspk_pool, media->engine, opt_micspk, AUDIO_CLOCK, in_dev, out_dev, t, &audio_device_event, &media->micspkstream);
#endif
		
		media->micspkstream->on_rx_audio = &rx_audio_callback;
#ifdef RVC_OS_LINUX
		media->micspkstream->on_tx_audio = &tx_audio_callback;
		media->micspkstream->on_audio_ns = &rvc_audio_ns;
		media->micspkstream->on_audio_play_ns = &rvc_audio_play_ns;
		media->micspkstream->on_audio_playing = &rvc_audio_playing_data;
		media->micspkstream->user_data = media;
#endif
		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;
}

static void __audionslog(void* user_data, const char* fmt, va_list arg)
{
	int n = vsnprintf(NULL, 0, fmt, arg);
	if (n >= MAX_PATH) {
		char* buf = (char*)malloc((size_t)(n + 1));
		vsnprintf(buf, n + 1, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
		free(buf);
	}
	else {
		char strlog[MAX_PATH] = { 0 };
		vsnprintf(strlog, MAX_PATH, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
	}
}


int audio_get_pcmrecord_filename(char* pbuffer, size_t ulen)
{
	int iret = -1;
	char strfile[MAX_PATH] = { 0 };
	struct tm* t;
	time_t tt;
	time(&tt);
	t = localtime(&tt);
	snprintf(strfile, MAX_PATH, "%4d%02d%02d%02d%02d%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
	if (NULL != pbuffer){
		iret = snprintf(pbuffer, MAX_PATH, "%s/%s_%s.pcm", "/opt/rvc/Temp/","agent_audio", strfile);
	}

	return iret;
}

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->baudiorecved = false;
	session->brtpinsertqueue = false;

#ifdef RVC_OS_WIN
#else
	audions_callback_t t_callback = { 0 };
	t_callback.debug = &__audionslog;
	session->audionsobj = CreateIAudioNsObj(&t_callback);
	if (NULL != session->audionsobj){
		session->audionsobj->SetNsParams(8000, 10, 2);
	}
	session->audioplaynsobj = CreateIAudioNsObj(&t_callback);
	if (NULL != session->audioplaynsobj) {
		session->audioplaynsobj->SetNsParams(8000, 10, 2);
	}
	session->iaudio_seriesnumber = RVC_MIN_AUDIO_SERIESNUMBER;
	//char strfile[MAX_PATH] = { 0 };
	//if (-1 != audio_get_pcmrecord_filename(strfile, MAX_PATH)) {
	//	session->pFile = fopen(strfile, "wb+");
	//}
#endif
	
	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;
	}
#ifdef RVC_OS_LINUX
	if (NULL != session->audionsobj) {
		DestroyIAudioNsObj(session->audionsobj);
		session->audionsobj = NULL;
	}

	if (NULL != session->audioplaynsobj) {
		DestroyIAudioNsObj(session->audioplaynsobj);
		session->audioplaynsobj = NULL;
	}

	////if (NULL != session->pFile) {
	////	fclose(session->pFile);
	////	session->pFile = NULL;
	////}
#endif
	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);
}

int audio_lib_init()
{
	audio_log_set_func(&__audio_log_func);

	int rc = audioframework_init();
	if (rc != 0) {
		return Error_Resource;
	} else {
#ifdef RVC_OS_WIN
		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());
		}
#endif
		audio_log_set_func(&__audio_log_func);
	}

	return 0;
}

void audio_lib_deinit()
{
	audioframework_term();
}


#ifdef RVC_OS_WIN

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 || 0 == strlen(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;
}
#endif