//
|
// Created by lilin on 2019-12-10.
|
//
|
|
#include "BaresipObj.h"
|
|
BaresipObj::BaresipObj(JavaListener *javaListener) {
|
this->javaListener = javaListener;
|
|
}
|
|
BaresipObj::~BaresipObj() {
|
|
}
|
static void dtmf_handler(struct call *call, char key, void *arg){
|
LOGE("收到key=%c",key);
|
}
|
static void ua_exit_handler(void *arg)
|
{
|
(void)arg;
|
LOGD("ua exited -- stopping main runloop\n");
|
re_cancel();
|
}
|
static void ua_event_handler( ua *ua, enum ua_event ev,
|
struct call *call, const char *prm, void *arg)
|
{
|
|
player *player = baresip_player();
|
BaresipObj *baresip = (BaresipObj *)(arg);
|
|
const char * str= uag_event_str(ev);
|
LOGE( "event_str==%s" ,str);
|
baresip->javaListener->onBaresipState( str);
|
switch (ev) {
|
case UA_EVENT_REGISTERING:
|
case UA_EVENT_UNREGISTERING:
|
case UA_EVENT_REGISTER_OK:
|
if(ev==UA_EVENT_REGISTER_OK){
|
char codec[100]="";
|
list * a= baresip_aucodecl(); struct le *le;int num=0;
|
for (le = list_head(a); num<list_count(a) ; le = le->next){
|
aucodec *ac =(aucodec *) le->data;
|
strcat(codec,ac->name);strcat(codec,",");num++;
|
}
|
strcat(codec,"=");
|
list * c = baresip_vidcodecl();num=0;
|
for (le = list_head(c); num<list_count(c) ; le = le->next) {
|
vidcodec *ac = (vidcodec *)le->data;
|
strcat(codec,ac->name);strcat(codec,",");num++;
|
}
|
baresip->javaListener->onBaresipCodec( codec);
|
}
|
|
break;
|
case UA_EVENT_REGISTER_FAIL:
|
|
break;
|
case UA_EVENT_CALL_INCOMING:
|
baresip->barecall=call;
|
(void)play_file(&baresip->bareplay, player, "ring.wav", 5);
|
|
break;
|
case UA_EVENT_CALL_RINGING:
|
|
break;
|
case UA_EVENT_CALL_PROGRESS:
|
|
break;
|
case UA_EVENT_CALL_ESTABLISHED:
|
mem_deref(baresip->bareplay); baresip->bareplay =NULL;
|
LOGE("收到set key=");
|
//call_set_handlers( call, NULL, dtmf_handler, NULL);
|
break;
|
case UA_EVENT_CALL_MENC:
|
|
break;
|
case UA_EVENT_CALL_TRANSFER:
|
|
break;
|
case UA_EVENT_CALL_TRANSFER_FAILED:
|
|
break;
|
case UA_EVENT_CALL_CLOSED:
|
mem_deref(baresip->bareplay); baresip->bareplay =NULL;
|
baresip->javaListener->onBaresipVstop();
|
baresip->barecall= NULL;
|
break;
|
case UA_EVENT_AUDIO_ERROR:
|
mem_deref(call); baresip->barecall= NULL;
|
goto out;
|
default:
|
goto out;
|
}
|
|
out:
|
return;
|
}
|
static void net_debug_log() {
|
char debug_buf[2048];
|
int l;
|
l = re_snprintf(&(debug_buf[0]), 2047, "%H", net_debug, baresip_network());
|
if (l != -1) {
|
debug_buf[l] = '\0';
|
LOGD("1.%s\n", debug_buf);
|
}
|
}
|
|
static void ua_print_sip_status_log() {
|
char debug_buf[2048];
|
int l;
|
l = re_snprintf(&(debug_buf[0]), 2047, "%H", ua_print_sip_status);
|
if (l != -1) {
|
debug_buf[l] = '\0';
|
LOGD("2.%s\n", debug_buf);
|
}
|
}
|
////////////////////////
|
|
struct vidsrc_st {
|
const struct vidsrc *vs; /* inheritance */
|
pthread_t thread;
|
bool run;
|
struct vidsz sz;
|
vidsrc_frame_h *frameh;
|
void *arg;
|
FrameQueue *frameQueue=NULL;
|
};
|
BaresipObj *xbaresipObj=NULL;
|
|
static struct vidsrc *mod_avf;
|
|
static void destructorsrc(void *arg)
|
{
|
vidsrc_st *st = (vidsrc_st *)arg;
|
st->frameQueue->notifyQueue();
|
st->frameQueue->clearQueue();
|
st->frameQueue=NULL;
|
if (st->run) {
|
st->run = false;
|
pthread_join(st->thread, NULL);
|
}
|
}
|
|
static void *read_thread(void *data)
|
{
|
struct vidsrc_st *st =(struct vidsrc_st *) data;
|
int64_t pts;
|
uint64_t timestamp; unsigned i;
|
while (st->run) {
|
if( st->frameQueue==NULL ){ break;}
|
AVFrame *frame=st->frameQueue->getAvFrame();
|
if( frame==NULL ){ continue;}
|
struct vidframe vf;
|
vf.fmt =VID_FMT_YUV420P;
|
st->sz.w=frame->width ;st->sz.h=frame->height;
|
vf.size =st->sz;
|
for (i=0; i<4; i++) {
|
vf.data[i] = frame->data[i];
|
vf.linesize[i] = frame->linesize[i];
|
}
|
pts = frame->pts;
|
timestamp = pts * VIDEO_TIMEBASE * 1 / 25;
|
// LOGE("当前pts==%lld",pts);
|
st->frameh(&vf, timestamp, st->arg);
|
|
if (frame) {
|
av_frame_free(&frame);
|
}
|
}
|
LOGE("停止");
|
return NULL;
|
}
|
|
static int allocsrc(struct vidsrc_st **stp, const struct vidsrc *vs,
|
struct media_ctx **mctx, struct vidsrc_prm *prm,
|
const struct vidsz *size, const char *fmt,
|
const char *dev, vidsrc_frame_h *frameh,
|
vidsrc_error_h *errorh, void *arg)
|
{
|
vidsrc_st *st;
|
uint32_t i;
|
int ret, err = 0;
|
double input_fps = 0;
|
|
(void)mctx;
|
(void)fmt;
|
(void)errorh;
|
|
if (!stp || !vs || !prm || !size || !frameh)
|
return EINVAL;
|
|
st = static_cast<vidsrc_st *>(mem_zalloc(sizeof(*st), destructorsrc));
|
if (!st)
|
return ENOMEM;
|
if(xbaresipObj->frameQueue==NULL){xbaresipObj->frameQueue = new FrameQueue();}
|
|
//需要发送开始send
|
st->frameQueue= xbaresipObj->frameQueue;
|
st->vs = vs;
|
st->sz = *size;
|
st->frameh = frameh;
|
st->arg = arg;
|
|
st->sz.w =640;
|
st->sz.h =480;
|
|
st->run = true;
|
err = pthread_create(&st->thread, NULL, read_thread, st);
|
if (err) {
|
st->run = false;
|
goto out;
|
}
|
//set
|
//g_ctx.st=st;
|
out:
|
if (err)
|
mem_deref(st);
|
else
|
*stp = st;
|
|
return err;
|
}
|
struct vidisp_st {
|
const struct vidisp *vd; /**< Inheritance (1st) */
|
struct vidsz size;
|
};
|
static struct vidisp *vid;
|
static int display(struct vidisp_st *st, const char *title, const struct vidframe *frame, uint64_t timestamp)
|
{
|
AVFrame *avFrame = av_frame_alloc();
|
for (int i=0; i<4; i++) {
|
avFrame->data[i]=frame->data[i] ;
|
avFrame->linesize[i]=frame->linesize[i] ;
|
}
|
int width=frame->size.w,height=frame->size.h;
|
|
uint8_t *t= avFrame->data[0];
|
|
xbaresipObj->javaListener->onBaresipVyuv( width,height,avFrame->data[0],avFrame->data[1],avFrame->data[2]);
|
|
av_frame_free(&avFrame);
|
av_free(avFrame);
|
avFrame=NULL;
|
|
return 0;
|
}
|
static void hide(struct vidisp_st *st) {
|
if (!st)
|
return;
|
}
|
static void destructordispl(void *arg)
|
{
|
}
|
static int allocdispl(struct vidisp_st **stp, const struct vidisp *vd,
|
struct vidisp_prm *prm, const char *dev,
|
vidisp_resize_h *resizeh, void *arg)
|
{
|
struct vidisp_st *st;
|
st = static_cast<vidisp_st *>(mem_zalloc(sizeof(*st), destructordispl));
|
if (!st)
|
return ENOMEM;
|
st->vd = vd;
|
*stp = st;
|
return 0;
|
}
|
|
////////////729////////////////
|
|
struct g729_aucodec {
|
struct aucodec ac;
|
uint32_t bitrate;
|
};
|
int g729_fmtp_enc(struct mbuf *mb, const struct sdp_format *fmt,
|
bool offer, void *arg)
|
{
|
const struct g729_aucodec *g729 = static_cast<const g729_aucodec *>(arg);
|
(void)offer;
|
|
if (!mb || !fmt || !g729)
|
return 0;
|
return mbuf_printf(mb, "a=fmtp:%s bitrate=%u\r\n", fmt->id, g729->bitrate);
|
}
|
|
static uint32_t g729_bitrate(const char *fmtp)
|
{
|
struct pl pl, bitrate;
|
|
if (!fmtp)
|
return 0;
|
|
pl_set_str(&pl, fmtp);
|
|
if (fmt_param_get(&pl, "bitrate", &bitrate))
|
return pl_u32(&bitrate);
|
return 0;
|
}
|
|
bool g729_fmtp_cmp(const char *lfmtp, const char *rfmtp, void *arg)
|
{
|
const struct g729_aucodec *g729 = static_cast<const g729_aucodec *>(arg);
|
(void)lfmtp;
|
if (!g729)
|
return false;
|
if (g729->bitrate != g729_bitrate(rfmtp))
|
return false;
|
|
return true;
|
}
|
|
|
struct auenc_state {
|
bcg729EncoderChannelContextStruct *encoder;
|
|
};
|
|
static void g729_encode_updatedestructor(void *arg)
|
{
|
struct auenc_state *aes = static_cast<auenc_state *>(arg);
|
closeBcg729EncoderChannel(aes->encoder);
|
}
|
int g729_encode_update(struct auenc_state **aesp, const struct aucodec *ac,
|
struct auenc_param *prm, const char *fmtp)
|
{
|
struct auenc_state *aes;
|
(void)prm;
|
(void)fmtp;
|
|
if (!aesp || !ac)
|
return EINVAL;
|
|
aes = *aesp;
|
|
if (aes)
|
return 0;
|
|
aes = static_cast<auenc_state *>(mem_alloc(sizeof(*aes), g729_encode_updatedestructor));
|
if (!aes)
|
return ENOMEM;
|
aes->encoder = initBcg729EncoderChannel(0);
|
|
*aesp = aes;
|
LOGE("729编码init1");
|
return 0;
|
}
|
|
|
int g729_encode1(struct auenc_state *aes, uint8_t *buf, size_t *len,
|
int fmt, const void *sampv, size_t sampc)
|
{
|
|
if (!aes || !buf || !len || !sampv)
|
return EINVAL;
|
int16_t *ddp = (int16_t *) sampv;
|
uint8_t *edp = buf;
|
int total_len = 0;
|
while (sampc >= 80) {
|
uint8_t frameSize;
|
bcg729Encoder(aes->encoder, ddp, edp, &frameSize);
|
ddp += 80;
|
sampc -= 80;
|
edp += frameSize;
|
total_len += frameSize;
|
}
|
*len = total_len;
|
|
return 0;
|
}
|
|
struct audec_state {
|
bcg729DecoderChannelContextStruct *decoder;
|
};
|
static void g729_decode_updatedestructor(void *arg)
|
{
|
struct audec_state *ads = static_cast<audec_state *>(arg);
|
closeBcg729DecoderChannel(ads->decoder);
|
}
|
int g729_decode_update(struct audec_state **adsp, const struct aucodec *ac,
|
const char *fmtp)
|
{
|
//const struct g729_aucodec *g729 = (struct g729_aucodec *)ac;
|
struct audec_state *ads;
|
(void)fmtp;
|
|
if (!adsp || !ac)
|
return EINVAL;
|
|
ads = *adsp;
|
|
if (ads)
|
return 0;
|
|
ads = static_cast<audec_state *>(mem_alloc(sizeof(*ads), g729_decode_updatedestructor));
|
if (!ads)
|
return ENOMEM;
|
|
ads->decoder = initBcg729DecoderChannel( );
|
|
*adsp = ads;
|
|
return 0;
|
}
|
|
|
int g729_decode1(struct audec_state *ads,
|
int fmt, void *sampv, size_t *sampc,
|
const uint8_t *buf, size_t len)
|
{
|
//size_t framec;
|
|
if (!ads || !sampv || !sampc || !buf)
|
return EINVAL;
|
|
|
int total_sampc = 0;
|
int16_t *ddp = (int16_t *) sampv;
|
LOGE("====%d",len);
|
while (len >= 10) {
|
bcg729Decoder(ads->decoder, const_cast<uint8_t *>(buf), 10, 0, 0, 0, ddp ) ;
|
buf += 10;
|
len -= 10;
|
ddp += 80;
|
total_sampc += 80;
|
}
|
*sampc = total_sampc;
|
|
return 0;
|
}
|
|
static struct g729_aucodec g729 = {
|
.ac = {
|
.le=LE_INIT,
|
.pt="18",
|
.name = "G729",
|
.srate = 8000,
|
.crate = 8000,
|
.ch = 1,
|
.pch = 1,
|
.encupdh = g729_encode_update,
|
.ench = g729_encode1,
|
.decupdh = g729_decode_update,
|
.dech = g729_decode1,
|
.fmtp_ench = g729_fmtp_enc,
|
.fmtp_cmph = g729_fmtp_cmp,
|
},
|
.bitrate = 8000
|
};
|
/////snd/////
|
////////////////////////////
|
|
struct sndfile_enc {
|
struct aufilt_enc_st af; /* base class */
|
enum aufmt fmt;
|
FILE *file = NULL;
|
};
|
|
struct sndfile_dec {
|
struct aufilt_dec_st af; /* base class */
|
enum aufmt fmt;
|
FILE *file = NULL;
|
};
|
static void enc_destructor(void *arg)
|
{
|
struct sndfile_enc *st = static_cast<sndfile_enc *>(arg);
|
fclose(st->file);LOGE("关闭文件");
|
list_unlink(&st->af.le);
|
}
|
|
|
static void dec_destructor(void *arg)
|
{
|
struct sndfile_dec *st = static_cast<sndfile_dec *>(arg);
|
// fclose(st->file);LOGE("关闭文件");
|
list_unlink(&st->af.le);
|
}
|
|
static int encodeaudio_update(struct aufilt_enc_st **stp, void **ctx,
|
const struct aufilt *af, struct aufilt_prm *prm,
|
const struct audio *au)
|
{
|
struct sndfile_enc *st;
|
int err = 0;
|
(void)ctx;
|
(void)af;
|
(void)au;
|
|
if (!stp || !prm)
|
return EINVAL;
|
|
st = static_cast<sndfile_enc *>(mem_zalloc(sizeof(*st), enc_destructor));
|
if (!st)
|
return EINVAL;
|
st->file=fopen("/data/data/lilin.com/files/2.pcm","wb");
|
st->fmt = static_cast<aufmt>(prm->fmt);
|
if(st->fmt==AUFMT_S16LE ){
|
LOGE( "====ok lalal =%d=%d",prm->srate , prm->ch);
|
}
|
|
*stp = (struct aufilt_enc_st *)st;
|
|
return err;
|
}
|
static int encodeaudio(struct aufilt_enc_st *st, void *sampv, size_t *sampc)
|
{
|
struct sndfile_enc *sf = (struct sndfile_enc *)st;
|
size_t num_bytes;
|
|
if (!st || !sampv || !sampc)
|
return EINVAL;
|
|
// num_bytes = *sampc * aufmt_sample_size(sf->fmt);
|
LOGE("编码写");
|
fwrite(sampv, *sampc, aufmt_sample_size(sf->fmt) ,sf->file);
|
// LOGE("encodeaudio=%d", num_bytes);
|
|
return 0;
|
}
|
|
static int decodeaudio_update(struct aufilt_dec_st **stp, void **ctx,
|
const struct aufilt *af, struct aufilt_prm *prm,
|
const struct audio *au)
|
{
|
struct sndfile_dec *st;
|
int err = 0;
|
(void)ctx;
|
(void)af;
|
(void)au;
|
|
if (!stp || !prm)
|
return EINVAL;
|
|
st = static_cast<sndfile_dec *>(mem_zalloc(sizeof(*st), dec_destructor));
|
if (!st)
|
return EINVAL;
|
|
//st->file=fopen("/data/data/lilin.com/files/1.pcm","wb");
|
|
st->fmt = static_cast<aufmt>(prm->fmt);
|
if(st->fmt==AUFMT_S16LE ){
|
LOGE( "====ok lalal =%d=%d",prm->srate , prm->ch);
|
}
|
|
*stp = (struct aufilt_dec_st *)st;
|
|
return err;
|
}
|
static int decodeaudio(struct aufilt_dec_st *st, void *sampv, size_t *sampc)
|
{
|
struct sndfile_dec *sf = (struct sndfile_dec *)st;
|
size_t num_bytes;
|
|
if (!st || !sampv || !sampc)
|
return EINVAL;
|
|
//num_bytes = *sampc * aufmt_sample_size(sf->fmt);
|
//LOGE("解码写");
|
//fwrite(sampv, *sampc, aufmt_sample_size(sf->fmt) ,sf->file);
|
//LOGE("decodeaudio=%d", num_bytes);
|
|
return 0;
|
}
|
|
|
static struct aufilt sndfile = { LE_INIT, "sndfile", encodeaudio_update, encodeaudio, decodeaudio_update, decodeaudio };
|
|
/////
|
|
static void signal_handler(int sig)
|
{
|
static bool term = false;
|
if (term) {
|
mod_close();
|
exit(0);
|
}
|
term = true;
|
LOGD("liili terminated by signal (%d)\n", sig);
|
ua_stop_all(false);
|
}
|
void *baresipthreadrun(void *arg){
|
|
BaresipObj *baresipobj = (BaresipObj *)(arg);
|
|
avdevice_register_all();
|
avformat_network_init();
|
|
int err;
|
const char *path = "/data/data/lilin.com/files";
|
|
//runLoggingThread();
|
|
err = libre_init();
|
if (err)
|
goto out;
|
conf_path_set(path);
|
log_enable_debug(true);
|
err = conf_configure();
|
if (err) {
|
LOGD("conf_configure() failed: (%d)\n", err);
|
goto out;
|
}
|
|
err = baresip_init(conf_config());
|
if (err) {
|
LOGD("baresip_init() failed (%d)\n", err);
|
goto out;
|
}
|
|
play_set_path(baresip_player(), path);
|
|
err = ua_init("baresip v", true, true, false);
|
if (err) {
|
LOGD("ua_init() failed (%d)\n", err);
|
goto out;
|
}
|
|
uag_set_exit_handler(ua_exit_handler, NULL);
|
uag_event_register(ua_event_handler, arg);
|
|
err = conf_modules();
|
if (err) {
|
LOGE("conf_modules() failed (%d)\n", err);
|
goto out;
|
}
|
struct le *le;
|
for (le = list_head(uag_list()); le != NULL; le = le->next) {
|
baresipobj->bareua = (struct ua *)le->data;
|
}
|
|
net_debug_log();
|
ua_print_sip_status_log();
|
|
|
//reg
|
xbaresipObj=baresipobj;
|
aucodec_register(baresip_aucodecl(), (struct aucodec *)&g729);
|
vidisp_register(&vid, baresip_vidispl(), "opengl", allocdispl, NULL, display, hide);
|
vidsrc_register(&mod_avf, baresip_vidsrcl(), "avformat", allocsrc, NULL);
|
|
//aufilt_register(baresip_aufiltl(), &sndfile); 声音保存demo
|
|
baresipobj-> baresipstate=1;
|
LOGD("Running main loop\n");
|
err = re_main(signal_handler);
|
LOGD("end Running main loop\n");
|
out:
|
if (err) {
|
LOGE("stopping UAs due to error: (%d)\n", err);
|
ua_stop_all(true);
|
} else {
|
LOGE("main loop exit\n");
|
}
|
LOGD("closing");
|
ua_close();
|
module_app_unload();
|
conf_close();
|
baresip_close();
|
uag_event_unregister(ua_event_handler);
|
LOGD("unloading modules end ...");
|
// mod_close();
|
|
// libre_close();
|
return 0;
|
}
|
void BaresipObj::startbaresip() {
|
pthread_create(&baresipthread,NULL,baresipthreadrun,this);
|
}
|
void BaresipObj::stopbaresip() {
|
LOGD("unloading modules 111...");
|
ua_stop_all(true);
|
pthread_join(baresipthread ,NULL);
|
LOGD("unloading modules 222 ...");
|
//ua_close();
|
// module_app_unload();
|
//conf_close();
|
// baresip_close();
|
// mod_close();
|
//libre_close();
|
}
|
void BaresipObj::baresipreg(const char *sipaddress) {
|
re_thread_enter();
|
if(bareua!= NULL)ua_destroy(bareua);
|
int err= ua_alloc( &bareua, sipaddress);
|
ua_register(bareua);
|
re_thread_leave();
|
}
|
|
void BaresipObj::baresipjie() {
|
re_thread_enter();
|
if(barecall!=NULL){
|
mem_deref(bareplay); bareplay=NULL;
|
|
if(call_has_video(barecall) ){
|
javaListener->onBaresipVstart();
|
}
|
ua_answer(bareua, barecall );
|
}
|
re_thread_leave();
|
}
|
|
int BaresipObj::bareisreg() {
|
re_thread_enter();
|
int state =ua_isregistered(bareua)?1:0;
|
if(state==0){ ua_register(bareua);state=1; LOGE("重新注册了");}
|
re_thread_leave();
|
return state;
|
}
|
|
void BaresipObj::baresipgua() {
|
if( barecall !=nullptr ){
|
re_thread_enter();
|
ua_hangup(bareua, barecall, 0, NULL);
|
re_thread_leave();
|
}
|
}
|
|
int BaresipObj::baresipcall(const char *sipaddress) {
|
int err =-1;
|
if (list_count(ua_calls(bareua)) > 1) {
|
LOGE("YOU TONG HUA!!");return err;
|
}
|
re_thread_enter();
|
//reset
|
err= ua_connect(bareua,&barecall,NULL,sipaddress,VIDMODE_OFF);
|
|
re_thread_leave();
|
return err;
|
}
|
|
int BaresipObj::baresipcallv(const char *sipaddress) {
|
int err =-1;
|
if (list_count(ua_calls(bareua)) > 1) {
|
LOGE("YOU TONG HUA!!");return err;
|
}
|
re_thread_enter();
|
//reset
|
err= ua_connect(bareua,&barecall,NULL,sipaddress,VIDMODE_ON);
|
javaListener->onBaresipVstart();
|
re_thread_leave();
|
return err;
|
}
|
|
|
