myvtm/Module/mod_sipphone/unix/audio_session.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "audio_session.h"
#include "Event.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

#define AUDIO_CLOCK	8000

#define AUDIO_SHM_FRAME_TIME	20 // 20ms

#ifndef RVC_MAX_BUFFER_LEN
#define RVC_MAX_BUFFER_LEN 512
#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 // _WIN32

	audiodsp_t *dspstream;
	audioresize_t *resizestream;
	audiortp_t *rtpstream;
	audiocodec_t *codecstream;
	rtp_session_t *rtpsess;


	Clibaudioqueue* remoteaudioqueue;
	//bool brtpinsertqueue;
	//audio noise suppression
	IAudioNs* audionsobj;
	IAudioNs* audioplaynsobj;
	bool baudiorecved;
	//FILE* pFile;
	int iaudio_seriesnumber;
};

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

static int tx_audio_callback(void* audiodata, void* userdata)
{
	audio_session_t* session = (audio_session_t*)userdata;
	int used = 0;

	return used;
}

static void send_hook_callback(const char *buf, int size, void *arg)
{
	//LOG_FUNCTION();
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send audio pkt");
	if ((g_nAudioSendNum%60) ==0)
	{
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send audio pkt num %d,single size %d",g_nAudioSendNum,size);
	}
	g_nAudioSendNum++;
}

static void recv_hook_callback(const char *buf, int size, void *arg)
{
	//LOG_FUNCTION();
	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;
	}
}


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));
}

#if defined(RVC_OS_LINUX)
static int execute_cmd_return_result(const char* cmd, char* result)
{
    char buf_ps[1024];
    char ps[1024] = { 0 };
    FILE* ptr;
    strcpy(ps, cmd);
    if ((ptr = popen(ps, "r")) != NULL) {
        while (fgets(buf_ps, 1024, ptr) != NULL) {
            strcat(result, buf_ps);
            if (strlen(result) > 1024)
                break;
        }
        pclose(ptr);
        return 0;
    } else {
		sprintf(result, "popen %s error: %d", ps, errno);
        return -1;
    }
}

#endif //RVC_OS_LINUX



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, &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 audiomicspkpulse_create failed!");
		goto on_error;
	}
	//音频回调
	media->micspkstream->user_data = media;
	media->micspkstream->on_rx_audio = &rx_audio_callback;
	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->on_audio_device_event = &audio_device_event;

	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_Low, 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_Low, 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_Low, 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_Low, 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_Low, 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, &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->user_data = media;
		media->micspkstream->on_rx_audio = &rx_audio_callback;
		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->on_audio_device_event = &audio_device_event;
		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->brtpinsertqueue = false;
	session->baudiorecved = false;
	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+");
	//}
	
	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;
	}

	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;
	////}

	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 {
		audio_log_set_func(NULL);
#ifdef RVC_OS_WIN
		int icnt, ocnt;
		rc = audio_get_dev_count(&icnt, &ocnt);
		if (rc == 0) {
			int i;
			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, (LPCSTR)str);
			}
			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, (LPCSTR)str);
			}
		}
#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) {
					//audio_log_set_func(__audio_log_func);
					return CSimpleStringA(info->name);
				}
				ii++;
			}
		} else {
			if (info->maxOutputChannels) {
				if (idx == ii) {
					//audio_log_set_func(__audio_log_func);
					return CSimpleStringA(info->name);
				}
				ii++;
			}
		}
	}
	//audio_log_set_func(__audio_log_func);
	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;
}


int get_audio_dev_name(char*devname,char*in_dev,char*out_dev)
{
	int icnt, ocnt;
	int rc = audio_get_dev_count(&icnt, &ocnt);
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get audio input num=%d,output num=%d",icnt,ocnt);
	if (rc == 0) 
	{
		int i;
		CSimpleStringA tmp;
		for (i = 0; i < icnt; ++i) 
		{		
			tmp = audio_get_dev_name(TRUE, i);
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("input dev = %s!", tmp);
			if (strstr(tmp,devname)!=NULL)
			{
				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get input dev = %s!", tmp);
				memcpy(in_dev,tmp.GetData(),tmp.GetLength());
				rc++;
			}
		}
		for (i = 0; i < ocnt; ++i) 
		{
			tmp = audio_get_dev_name(FALSE, i);
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("output dev = %s!", tmp);
			if (strstr(tmp,devname)!=NULL)
			{
				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get output dev = %s!", tmp);
				memcpy(out_dev,tmp.GetData(),tmp.GetLength());
				rc++;
			}
		}
		return rc;
	}
	else
	{
		return rc;
	}
}
#endif