RtpSession* rtp_listen(const char *remote_addr, unsigned short remote_port) {
RtpSession *rtpSession;
recv_ts=0;
send_ts=0;
rtpSession=rtp_session_new(RTP_SESSION_SENDRECV);
rtp_session_set_scheduling_mode(rtpSession,TRUE);
rtp_session_set_blocking_mode(rtpSession,FALSE);
#ifdef HAVE_RTCP_ORTP
rtp_session_set_local_addr(rtpSession,INADDR_DSPSERVER,LOCAL_RTP_PORT,LOCAL_RTCP_PORT);
#else
rtp_session_set_local_addr(rtpSession,INADDR_DSPSERVER,LOCAL_RTP_PORT);
#endif
rtp_session_set_remote_addr(rtpSession, remote_addr, remote_port );
rtp_session_set_connected_mode(rtpSession,TRUE);
rtp_session_set_symmetric_rtp(rtpSession,TRUE);
rtp_session_enable_adaptive_jitter_compensation(rtpSession,adapt);
rtp_session_set_jitter_compensation(rtpSession,jittcomp);
rtp_session_set_payload_type(rtpSession,0);
rtp_session_set_time_jump_limit (rtpSession, timestamp_jump_limit);
//rtp_session_signal_connect(rtpSession,"ssrc_changed",(RtpCallback)ssrc_cb,0);
rtp_session_signal_connect(rtpSession,"ssrc_changed",(RtpCallback)rtp_session_reset,0);
rtp_session_signal_connect(rtpSession,"timestamp_jump",(RtpCallback)rtp_session_resync,0);
rtp_listening = 1;
rtp_connected = 1;
return rtpSession;
}
RtpSession * create_duplex_rtpsession( int locport, bool_t ipv6){
RtpSession *rtpr;
rtpr=rtp_session_new(RTP_SESSION_SENDRECV);
rtp_session_set_recv_buf_size(rtpr,MAX_RTP_SIZE);
rtp_session_set_scheduling_mode(rtpr,0);
rtp_session_set_blocking_mode(rtpr,0);
rtp_session_enable_adaptive_jitter_compensation(rtpr,TRUE);
rtp_session_set_symmetric_rtp(rtpr,TRUE);
rtp_session_set_local_addr(rtpr,ipv6 ? "::" : "0.0.0.0",locport);
rtp_session_signal_connect(rtpr,"timestamp_jump",(RtpCallback)rtp_session_resync,(long)NULL);
rtp_session_signal_connect(rtpr,"ssrc_changed",(RtpCallback)rtp_session_resync,(long)NULL);
return rtpr;
}
// Constructors
MastTool::MastTool( const char* tool_name, RtpSessionMode mode )
{
int log_level = ORTP_WARNING|ORTP_ERROR|ORTP_FATAL;
// Initialise defaults
this->session = NULL;
this->profile = &av_profile;
this->mimetype = new MastMimeType();
this->payloadtype = NULL;
this->payloadtype_index = -1;
this->tool_name = tool_name;
this->payload_size_limit = DEFAULT_PAYLOAD_LIMIT;
// Initialise the oRTP library
ortp_init();
// Set the logging message level
#ifdef DEBUGGING
MAST_DEBUG( "Compiled with debugging enabled" );
log_level |= ORTP_DEBUG;
log_level |= ORTP_MESSAGE;
#endif
ortp_set_log_level_mask(log_level);
// Create RTP session
session = rtp_session_new( mode );
if (session==NULL) {
MAST_FATAL( "Failed to create oRTP session.\n" );
}
// Enabled multicast loopback
rtp_session_set_multicast_loopback(session, TRUE);
// Callbacks
rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)ssrc_changed_cb, 0);
rtp_session_signal_connect(session,"payload_type_changed",(RtpCallback)pt_changed_cb, 0);
rtp_session_signal_connect(session,"network_error",(RtpCallback)network_error_cb, 0);
// Set the MPEG Audio payload type to 14 in the AV profile
rtp_profile_set_payload(profile, RTP_MPEG_AUDIO_PT, &payload_type_mpeg_audio);
// Set RTCP parameters
this->set_source_sdes();
}
RtpSession * create_duplex_rtpsession(int loc_rtp_port, int loc_rtcp_port, bool_t ipv6) {
RtpSession *rtpr;
rtpr = rtp_session_new(RTP_SESSION_SENDRECV);
rtp_session_set_recv_buf_size(rtpr, MAX(ms_get_mtu() , MS_MINIMAL_MTU));
rtp_session_set_scheduling_mode(rtpr, 0);
rtp_session_set_blocking_mode(rtpr, 0);
rtp_session_enable_adaptive_jitter_compensation(rtpr, TRUE);
rtp_session_set_symmetric_rtp(rtpr, TRUE);
rtp_session_set_local_addr(rtpr, ipv6 ? "::" : "0.0.0.0", loc_rtp_port, loc_rtcp_port);
rtp_session_signal_connect(rtpr, "timestamp_jump", (RtpCallback)rtp_session_resync, (long)NULL);
rtp_session_signal_connect(rtpr, "ssrc_changed", (RtpCallback)rtp_session_resync, (long)NULL);
rtp_session_set_ssrc_changed_threshold(rtpr, 0);
disable_checksums(rtp_session_get_rtp_socket(rtpr));
return rtpr;
}
static int rtp_setup( struct rtp_spook_input *conf )
{
// ??RTP??
conf->session=rtp_session_new(RTP_SESSION_RECVONLY);
rtp_session_set_scheduling_mode(conf->session,1);
rtp_session_set_blocking_mode(conf->session,1);
rtp_session_set_local_addr(conf->session,"0.0.0.0", conf->localport);
rtp_session_set_connected_mode(conf->session,TRUE);
rtp_session_set_symmetric_rtp(conf->session,TRUE);
rtp_session_enable_adaptive_jitter_compensation(conf->session,TRUE);
rtp_session_set_jitter_compensation(conf->session,40);
rtp_session_set_payload_type(conf->session,0);
rtp_session_signal_connect(conf->session,"ssrc_changed",(RtpCallback)ssrc_cb,0);
rtp_session_signal_connect(conf->session,"ssrc_changed",(RtpCallback)rtp_session_reset,0);
return 0;
}
RtpSession * ms_create_duplex_rtp_session(const char* local_ip, int loc_rtp_port, int loc_rtcp_port, int mtu) {
RtpSession *rtpr;
rtpr = rtp_session_new(RTP_SESSION_SENDRECV);
rtp_session_set_recv_buf_size(rtpr, MAX(mtu , MS_MINIMAL_MTU));
rtp_session_set_scheduling_mode(rtpr, 0);
rtp_session_set_blocking_mode(rtpr, 0);
rtp_session_enable_adaptive_jitter_compensation(rtpr, TRUE);
rtp_session_set_symmetric_rtp(rtpr, TRUE);
rtp_session_set_local_addr(rtpr, local_ip, loc_rtp_port, loc_rtcp_port);
rtp_session_signal_connect(rtpr, "timestamp_jump", (RtpCallback)rtp_session_resync, NULL);
rtp_session_signal_connect(rtpr, "ssrc_changed", (RtpCallback)rtp_session_resync, NULL);
rtp_session_set_ssrc_changed_threshold(rtpr, 0);
rtp_session_set_rtcp_report_interval(rtpr, 2500); /* At the beginning of the session send more reports. */
rtp_session_set_multicast_loopback(rtpr,TRUE); /*very useful, specially for testing purposes*/
disable_checksums(rtp_session_get_rtp_socket(rtpr));
return rtpr;
}
int main(int argc, char *argv[])
{
RtpSession *session;
unsigned char buffer[160];
int err;
FILE *outfile;
uint32_t ts=0;
int have_more;
if (argc<3){
printf("%s",help);
return -1;
}
ortp_init();
ortp_scheduler_init();
/* set the telephony event payload type to 96 in the av profile.*/
rtp_profile_set_payload(&av_profile,96,&payload_type_telephone_event);
session=rtp_session_new(RTP_SESSION_RECVONLY);
rtp_session_set_scheduling_mode(session,1);
rtp_session_set_blocking_mode(session,1);
rtp_session_set_local_addr(session,"0.0.0.0",atoi(argv[2]));
rtp_session_set_payload_type(session,0);
/* register for telephony events */
rtp_session_signal_connect(session,"telephone-event",(RtpCallback)recv_tev_cb,0);
outfile=fopen(argv[1],"wb");
if (outfile==NULL) {
perror("Cannot open file");
return -1;
}
signal(SIGINT,stophandler);
while(runcond)
{
have_more=1;
while (have_more){
err=rtp_session_recv_with_ts(session,buffer,160,ts,&have_more);
if (err>0) {
size_t ret = fwrite(buffer,1,err,outfile);
assert( ret == err );
}
}
ts+=160;
//ortp_message("Receiving packet.");
}
fclose(outfile);
rtp_session_destroy(session);
ortp_exit();
ortp_global_stats_display();
printf("Total dtmf events received: %i\n",dtmf_count);
return 0;
}
static void post_configure_audio_streams(LinphoneCall*call){
AudioStream *st=call->audiostream;
LinphoneCore *lc=call->core;
float mic_gain=lp_config_get_float(lc->config,"sound","mic_gain",1);
float thres = 0;
float recv_gain;
float ng_thres=lp_config_get_float(lc->config,"sound","ng_thres",0.05);
float ng_floorgain=lp_config_get_float(lc->config,"sound","ng_floorgain",0);
int dc_removal=lp_config_get_int(lc->config,"sound","dc_removal",0);
if (!call->audio_muted)
audio_stream_set_mic_gain(st,mic_gain);
else
audio_stream_set_mic_gain(st,0);
recv_gain = lc->sound_conf.soft_play_lev;
if (recv_gain != 0) {
linphone_core_set_playback_gain_db (lc,recv_gain);
}
if (st->volsend){
ms_filter_call_method(st->volsend,MS_VOLUME_REMOVE_DC,&dc_removal);
float speed=lp_config_get_float(lc->config,"sound","el_speed",-1);
thres=lp_config_get_float(lc->config,"sound","el_thres",-1);
float force=lp_config_get_float(lc->config,"sound","el_force",-1);
int sustain=lp_config_get_int(lc->config,"sound","el_sustain",-1);
float transmit_thres=lp_config_get_float(lc->config,"sound","el_transmit_thres",-1);
MSFilter *f=NULL;
f=st->volsend;
if (speed==-1) speed=0.03;
if (force==-1) force=25;
ms_filter_call_method(f,MS_VOLUME_SET_EA_SPEED,&speed);
ms_filter_call_method(f,MS_VOLUME_SET_EA_FORCE,&force);
if (thres!=-1)
ms_filter_call_method(f,MS_VOLUME_SET_EA_THRESHOLD,&thres);
if (sustain!=-1)
ms_filter_call_method(f,MS_VOLUME_SET_EA_SUSTAIN,&sustain);
if (transmit_thres!=-1)
ms_filter_call_method(f,MS_VOLUME_SET_EA_TRANSMIT_THRESHOLD,&transmit_thres);
ms_filter_call_method(st->volsend,MS_VOLUME_SET_NOISE_GATE_THRESHOLD,&ng_thres);
ms_filter_call_method(st->volsend,MS_VOLUME_SET_NOISE_GATE_FLOORGAIN,&ng_floorgain);
}
if (st->volrecv){
/* parameters for a limited noise-gate effect, using echo limiter threshold */
float floorgain = 1/mic_gain;
ms_filter_call_method(st->volrecv,MS_VOLUME_SET_NOISE_GATE_THRESHOLD,&thres);
ms_filter_call_method(st->volrecv,MS_VOLUME_SET_NOISE_GATE_FLOORGAIN,&floorgain);
}
parametrize_equalizer(lc,st);
if (lc->vtable.dtmf_received!=NULL){
/* replace by our default action*/
audio_stream_play_received_dtmfs(call->audiostream,FALSE);
rtp_session_signal_connect(call->audiostream->session,"telephone-event",(RtpCallback)linphone_core_dtmf_received,(unsigned long)lc);
}
}
int video_stream_start (VideoStream *stream, RtpProfile *profile, const char *rem_rtp_ip, int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload, int jitt_comp, MSWebCam *cam){
PayloadType *pt;
RtpSession *rtps=stream->ms.session;
MSPixFmt format;
MSVideoSize disp_size;
int tmp;
JBParameters jbp;
const int socket_buf_size=2000000;
if (cam==NULL){
cam=ms_web_cam_manager_get_default_cam (
ms_web_cam_manager_get());
}
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("videostream.c: undefined payload type.");
return -1;
}
if ((cam != NULL) && (cam->desc->encode_to_mime_type != NULL) && (cam->desc->encode_to_mime_type(cam, pt->mime_type) == TRUE)) {
stream->source_performs_encoding = TRUE;
}
rtp_session_set_profile(rtps,profile);
if (rem_rtp_port>0) rtp_session_set_remote_addr_full(rtps,rem_rtp_ip,rem_rtp_port,rem_rtcp_ip,rem_rtcp_port);
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
rtp_session_signal_connect(stream->ms.session,"payload_type_changed",
(RtpCallback)mediastream_payload_type_changed,(unsigned long)&stream->ms);
rtp_session_get_jitter_buffer_params(stream->ms.session,&jbp);
jbp.max_packets=1000;//needed for high resolution video
rtp_session_set_jitter_buffer_params(stream->ms.session,&jbp);
rtp_session_set_rtp_socket_recv_buffer_size(stream->ms.session,socket_buf_size);
rtp_session_set_rtp_socket_send_buffer_size(stream->ms.session,socket_buf_size);
if (stream->dir==VideoStreamSendRecv || stream->dir==VideoStreamSendOnly){
MSConnectionHelper ch;
/*plumb the outgoing stream */
if (rem_rtp_port>0) ms_filter_call_method(stream->ms.rtpsend,MS_RTP_SEND_SET_SESSION,stream->ms.session);
if (stream->source_performs_encoding == FALSE) {
stream->ms.encoder=ms_filter_create_encoder(pt->mime_type);
if ((stream->ms.encoder==NULL) ){
/* big problem: we don't have a registered codec for this payload...*/
ms_error("videostream.c: No encoder available for payload %i:%s.",payload,pt->mime_type);
return -1;
}
}
/* creates the filters */
stream->cam=cam;
stream->source = ms_web_cam_create_reader(cam);
stream->tee = ms_filter_new(MS_TEE_ID);
if (stream->source_performs_encoding == TRUE) {
stream->ms.encoder = stream->source; /* Consider the encoder is the source */
}
if (pt->normal_bitrate>0){
MSVideoConfiguration *vconf_list = NULL;
ms_message("Limiting bitrate of video encoder to %i bits/s",pt->normal_bitrate);
ms_filter_call_method(stream->ms.encoder, MS_VIDEO_ENCODER_GET_CONFIGURATION_LIST, &vconf_list);
if (vconf_list != NULL) {
MSVideoConfiguration vconf = ms_video_find_best_configuration_for_bitrate(vconf_list, pt->normal_bitrate);
ms_filter_call_method(stream->ms.encoder, MS_VIDEO_ENCODER_SET_CONFIGURATION, &vconf);
} else {
ms_filter_call_method(stream->ms.encoder, MS_FILTER_SET_BITRATE, &pt->normal_bitrate);
}
}
if (pt->send_fmtp){
ms_filter_call_method(stream->ms.encoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
}
if (stream->use_preview_window){
if (stream->rendercb==NULL){
stream->output2=ms_filter_new_from_name (stream->display_name);
}
}
configure_video_source (stream);
/* and then connect all */
ms_connection_helper_start(&ch);
ms_connection_helper_link(&ch, stream->source, -1, 0);
if (stream->pixconv) {
ms_connection_helper_link(&ch, stream->pixconv, 0, 0);
}
if (stream->sizeconv) {
ms_connection_helper_link(&ch, stream->sizeconv, 0, 0);
}
ms_connection_helper_link(&ch, stream->tee, 0, 0);
if (stream->source_performs_encoding == FALSE) {
ms_connection_helper_link(&ch, stream->ms.encoder, 0, 0);
}
ms_connection_helper_link(&ch, stream->ms.rtpsend, 0, -1);
if (stream->output2){
if (stream->preview_window_id!=0){
ms_filter_call_method(stream->output2, MS_VIDEO_DISPLAY_SET_NATIVE_WINDOW_ID,&stream->preview_window_id);
}
ms_filter_link(stream->tee,1,stream->output2,0);
}
}
if (stream->dir==VideoStreamSendRecv || stream->dir==VideoStreamRecvOnly){
MSConnectionHelper ch;
MSVideoDisplayDecodingSupport decoding_support;
if (stream->rendercb!=NULL){
stream->output=ms_filter_new(MS_EXT_DISPLAY_ID);
ms_filter_set_notify_callback(stream->output,ext_display_cb,stream);
}else{
stream->output=ms_filter_new_from_name (stream->display_name);
}
/* Don't allow null output */
if(stream->output == NULL) {
ms_fatal("No video display filter could be instantiated. Please check build-time configuration");
}
/* Check if the output filter can perform the decoding process */
decoding_support.mime_type = pt->mime_type;
decoding_support.supported = FALSE;
ms_filter_call_method(stream->output, MS_VIDEO_DISPLAY_SUPPORT_DECODING, &decoding_support);
stream->output_performs_decoding = decoding_support.supported;
/*plumb the incoming stream */
if (stream->output_performs_decoding == TRUE) {
stream->ms.decoder = stream->output; /* Consider the decoder is the output */
} else {
stream->ms.decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->ms.decoder==NULL) ){
/* big problem: we don't have a registered decoderfor this payload...*/
ms_error("videostream.c: No decoder available for payload %i:%s.",payload,pt->mime_type);
ms_filter_destroy(stream->output);
return -1;
}
}
ms_filter_set_notify_callback(stream->ms.decoder, event_cb, stream);
stream->ms.rtprecv = ms_filter_new (MS_RTP_RECV_ID);
ms_filter_call_method(stream->ms.rtprecv,MS_RTP_RECV_SET_SESSION,stream->ms.session);
if (stream->output_performs_decoding == FALSE) {
stream->jpegwriter=ms_filter_new(MS_JPEG_WRITER_ID);
if (stream->jpegwriter)
stream->tee2=ms_filter_new(MS_TEE_ID);
}
/* set parameters to the decoder*/
if (pt->send_fmtp){
ms_filter_call_method(stream->ms.decoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
}
if (pt->recv_fmtp!=NULL)
ms_filter_call_method(stream->ms.decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/*force the decoder to output YUV420P */
format=MS_YUV420P;
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_PIX_FMT,&format);
/*configure the display window */
if(stream->output != NULL) {
disp_size.width=MS_VIDEO_SIZE_CIF_W;
disp_size.height=MS_VIDEO_SIZE_CIF_H;
tmp=1;
ms_filter_call_method(stream->output,MS_FILTER_SET_VIDEO_SIZE,&disp_size);
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_ENABLE_AUTOFIT,&tmp);
ms_filter_call_method(stream->output,MS_FILTER_SET_PIX_FMT,&format);
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_SET_LOCAL_VIEW_MODE,&stream->corner);
if (stream->window_id!=0){
ms_filter_call_method(stream->output, MS_VIDEO_DISPLAY_SET_NATIVE_WINDOW_ID,&stream->window_id);
}
if (stream->display_filter_auto_rotate_enabled) {
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_SET_DEVICE_ORIENTATION,&stream->device_orientation);
}
}
/* and connect the filters */
ms_connection_helper_start (&ch);
ms_connection_helper_link (&ch,stream->ms.rtprecv,-1,0);
if (stream->output_performs_decoding == FALSE) {
ms_connection_helper_link (&ch,stream->ms.decoder,0,0);
}
if (stream->tee2){
ms_connection_helper_link (&ch,stream->tee2,0,0);
ms_filter_link(stream->tee2,1,stream->jpegwriter,0);
}
if (stream->output!=NULL)
ms_connection_helper_link (&ch,stream->output,0,-1);
/* the video source must be send for preview , if it exists*/
if (stream->tee!=NULL && stream->output!=NULL && stream->output2==NULL)
ms_filter_link(stream->tee,1,stream->output,1);
}
if (stream->dir == VideoStreamSendOnly) {
stream->ms.rtprecv = ms_filter_new (MS_RTP_RECV_ID);
ms_filter_call_method(stream->ms.rtprecv, MS_RTP_RECV_SET_SESSION, stream->ms.session);
stream->ms.voidsink = ms_filter_new(MS_VOID_SINK_ID);
ms_filter_link(stream->ms.rtprecv, 0, stream->ms.voidsink, 0);
}
/* create the ticker */
if (stream->ms.ticker==NULL) start_ticker(&stream->ms);
stream->ms.start_time=ms_time(NULL);
stream->ms.is_beginning=TRUE;
/* attach the graphs */
if (stream->source)
ms_ticker_attach (stream->ms.ticker, stream->source);
if (stream->ms.rtprecv)
ms_ticker_attach (stream->ms.ticker, stream->ms.rtprecv);
return 0;
}
int main(int argc, char *argv[])
{
RtpSession *session[STREAMS_COUNT];
gint i;
gint filefd[STREAMS_COUNT];
gint port;
guint32 user_ts=0;
gint channels;
SessionSet *set;
gchar *filename;
if (argc<4){
printf(help);
return -1;
}
channels=atoi(argv[3]);
if (channels==0){
printf(help);
return -1;
}
ortp_init();
ortp_scheduler_init();
ortp_set_debug_file("oRTP",NULL);
/* set the telephony event payload type to 96 in the av profile.*/
rtp_profile_set_payload(&av_profile,96,&payload_type_telephone_event);
port=atoi(argv[2]);
p_channel_id = (int *)g_malloc(channels*sizeof(int));
for (i=0;i<channels;i++){
session[i]=rtp_session_new(RTP_SESSION_RECVONLY);
rtp_session_set_scheduling_mode(session[i],1);
rtp_session_set_blocking_mode(session[i],0);
rtp_session_set_local_addr(session[i],"0.0.0.0",port);
rtp_session_set_recv_payload_type(session[i],0);
rtp_session_set_recv_buf_size(session[i],256);
p_channel_id[i] = i;
/* register for telephony events */
rtp_session_signal_connect(session[i],"telephone-event",(RtpCallback)recv_tev_cb,&p_channel_id[i]);
port+=2;
}
filename=g_malloc(strlen(argv[1])+8);
for (i=0;i<channels;i++){
sprintf(filename,"%s%4.4d.dat",argv[1],i);
#ifndef _WIN32
filefd[i]=open(filename,O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
#else
filefd[i]=open(filename,_O_BINARY | O_WRONLY | O_CREAT | O_TRUNC);
#endif
if (filefd[i]<0) g_error("Could not open %s for writing: %s",filename,strerror(errno));
}
signal(SIGINT,stophandler);
/* create a set */
set=session_set_new();
while(runcond)
{
int k;
for (k=0;k<channels;k++){
/* add the session to the set */
session_set_set(set,session[k]);
}
/* and then suspend the process by selecting() */
session_set_select(set,NULL,NULL);
for (k=0;k<channels;k++){
if (session_set_is_set(set,session[k])){
rtp2disk(session[k],user_ts,filefd[k]);
}
}
user_ts+=160;
}
for (i=0;i<channels;i++){
close(filefd[i]);
rtp_session_destroy(session[i]);
}
session_set_destroy(set);
g_free(p_channel_id);
g_free(filename);
ortp_exit();
ortp_global_stats_display();
return 0;
}
int video_stream_start (VideoStream *stream, RtpProfile *profile, const char *remip, int remport,
int rem_rtcp_port, int payload, int jitt_comp, MSWebCam *cam)
{
PayloadType *pt;
RtpSession *rtps=stream->session;
MSPixFmt format;
MSVideoSize vsize;
float fps=15;
vsize.height=MS_VIDEO_SIZE_CIF_H;
vsize.width=MS_VIDEO_SIZE_CIF_W;
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("videostream.c: undefined payload type.");
return -1;
}
stream->encoder=ms_filter_create_encoder(pt->mime_type);
stream->decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->encoder==NULL) || (stream->decoder==NULL)){
/* big problem: we have not a registered codec for this payload...*/
ms_error("videostream.c: No codecs available for payload %i:%s.",payload,pt->mime_type);
return -1;
}
rtp_session_set_profile(rtps,profile);
if (remport>0) rtp_session_set_remote_addr_full(rtps,remip,remport,rem_rtcp_port);
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
rtp_session_signal_connect(stream->session,"payload_type_changed",
(RtpCallback)payload_type_changed,(unsigned long)stream);
rtp_session_set_recv_buf_size(stream->session,MAX_RTP_SIZE);
/* creates two rtp filters to recv send streams (remote part) */
if (remport>0) ms_filter_call_method(stream->rtpsend,MS_RTP_SEND_SET_SESSION,stream->session);
stream->rtprecv = ms_filter_new (MS_RTP_RECV_ID);
ms_filter_call_method(stream->rtprecv,MS_RTP_RECV_SET_SESSION,stream->session);
/* creates the filters */
stream->source = ms_web_cam_create_reader(cam);
stream->tee = ms_filter_new(MS_TEE_ID);
stream->output=ms_filter_new(MS_VIDEO_OUT_ID);
stream->sizeconv=ms_filter_new(MS_SIZE_CONV_ID);
if (pt->normal_bitrate>0){
ms_message("Limiting bitrate of video encoder to %i bits/s",pt->normal_bitrate);
ms_filter_call_method(stream->encoder,MS_FILTER_SET_BITRATE,&pt->normal_bitrate);
}
/* set parameters to the encoder and decoder*/
if (pt->send_fmtp){
ms_filter_call_method(stream->encoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
}
ms_filter_call_method(stream->encoder,MS_FILTER_GET_VIDEO_SIZE,&vsize);
ms_filter_call_method(stream->encoder,MS_FILTER_GET_FPS,&fps);
ms_message("Setting vsize=%ix%i, fps=%f",vsize.width,vsize.height,fps);
/* configure the filters */
ms_filter_call_method(stream->source,MS_FILTER_SET_FPS,&fps);
ms_filter_call_method(stream->source,MS_FILTER_SET_VIDEO_SIZE,&vsize);
/* get the output format for webcam reader */
ms_filter_call_method(stream->source,MS_FILTER_GET_PIX_FMT,&format);
if (format==MS_MJPEG){
stream->pixconv=ms_filter_new(MS_MJPEG_DEC_ID);
}else{
stream->pixconv = ms_filter_new(MS_PIX_CONV_ID);
/*set it to the pixconv */
ms_filter_call_method(stream->pixconv,MS_FILTER_SET_PIX_FMT,&format);
ms_filter_call_method(stream->source,MS_FILTER_GET_VIDEO_SIZE,&vsize);
ms_filter_call_method(stream->pixconv,MS_FILTER_SET_VIDEO_SIZE,&vsize);
}
ms_filter_call_method(stream->encoder,MS_FILTER_GET_VIDEO_SIZE,&vsize);
ms_filter_call_method(stream->sizeconv,MS_FILTER_SET_VIDEO_SIZE,&vsize);
/*force the decoder to output YUV420P */
format=MS_YUV420P;
ms_filter_call_method(stream->decoder,MS_FILTER_SET_PIX_FMT,&format);
/*ask the video display to always output CIF */
vsize.height=MS_VIDEO_SIZE_CIF_H;
vsize.width=MS_VIDEO_SIZE_CIF_W;
ms_filter_call_method(stream->output,MS_FILTER_SET_VIDEO_SIZE,&vsize);
ms_filter_call_method(stream->output,MS_FILTER_SET_PIX_FMT,&format);
if (pt->recv_fmtp!=NULL)
ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/* and then connect all */
ms_filter_link (stream->source, 0, stream->pixconv, 0);
ms_filter_link (stream->pixconv, 0, stream->sizeconv, 0);
ms_filter_link (stream->sizeconv, 0, stream->tee, 0);
ms_filter_link (stream->tee, 0 ,stream->encoder, 0 );
ms_filter_link (stream->encoder,0, stream->rtpsend,0);
ms_filter_link (stream->rtprecv, 0, stream->decoder, 0);
ms_filter_link (stream->decoder,0 , stream->output, 0);
/* the source video must be send for preview */
ms_filter_link(stream->tee,1,stream->output,1);
/* create the ticker */
stream->ticker = ms_ticker_new();
/* attach it the graph */
ms_ticker_attach (stream->ticker, stream->source);
return 0;
}
int main(int argc, char*argv[])
{
RtpSession *session;
unsigned char buffer[32];
int err;
uint32_t ts=0;
int stream_received=0;
FILE *outfile;
int local_port;
int have_more;
int i;
int format=0;
int soundcard=0;
int sound_fd=0;
int jittcomp=40;
bool_t adapt=TRUE;
/* init the lib */
if (argc<3){
printf("%s",help);
return -1;
}
local_port=atoi(argv[2]);
if (local_port<=0) {
printf("%s",help);
return -1;
}
for (i=3;i<argc;i++)
{
if (strcmp(argv[i],"--noadapt")==0) adapt=FALSE;
if (strcmp(argv[i],"--format")==0){
i++;
if (i<argc){
if (strcmp(argv[i],"mulaw")==0){
format=MULAW;
}else
if (strcmp(argv[i],"alaw")==0){
format=ALAW;
}else{
printf("Unsupported format %s\n",argv[i]);
return -1;
}
}
}
else if (strcmp(argv[i],"--soundcard")==0){
soundcard=1;
}
else if (strcmp(argv[i],"--with-jitter")==0){
i++;
if (i<argc){
jittcomp=atoi(argv[i]);
printf("Using a jitter buffer of %i milliseconds.\n",jittcomp);
}
}
}
outfile=fopen(argv[1],"wb");
if (outfile==NULL) {
perror("Cannot open file for writing");
return -1;
}
if (soundcard){
sound_fd=sound_init(format);
}
ortp_init();
ortp_scheduler_init();
ortp_set_log_level_mask(ORTP_DEBUG|ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR);
signal(SIGINT,stop_handler);
session=rtp_session_new(RTP_SESSION_RECVONLY);
rtp_session_set_scheduling_mode(session,1);
rtp_session_set_blocking_mode(session,1);
rtp_session_set_local_addr(session,"0.0.0.0",atoi(argv[2]));
rtp_session_set_connected_mode(session,TRUE);
rtp_session_set_symmetric_rtp(session,TRUE);
rtp_session_enable_adaptive_jitter_compensation(session,adapt);
rtp_session_set_jitter_compensation(session,jittcomp);
rtp_session_set_payload_type(session,0);
rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)ssrc_cb,0);
rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)rtp_session_reset,0);
fwrite("#!AMR\n",1,6,outfile);
// write(sound_fd,"#!AMR\n",err);
while(cond)
{
have_more=1;
while (have_more){
err=rtp_session_recv_with_ts(session,buffer,32,ts,&have_more);
if (err>0) stream_received=1;
/* this is to avoid to write to disk some silence before the first RTP packet is returned*/
if ((stream_received) && (err>0)) {
size_t ret = fwrite(buffer,1,err,outfile);
int ii;
for(ii =0 ; ii < 32 ; ii ++)
printf("%x " ,buffer[ii]);
printf("\n");
// while(1);
if (sound_fd>0){
ret = write(sound_fd,buffer,err);
if (ret==-1){
fprintf(stderr,"write to sound card failed (%s)",strerror(errno));
}
}
}
}
ts+=160;
//ortp_message("Receiving packet.");
}
rtp_session_destroy(session);
ortp_exit();
ortp_global_stats_display();
return 0;
}
int audio_stream_start_full(AudioStream *stream, RtpProfile *profile, const char *remip,int remport,
int rem_rtcp_port, int payload,int jitt_comp, const char *infile, const char *outfile,
MSSndCard *playcard, MSSndCard *captcard, bool_t use_ec)
{
RtpSession *rtps=stream->session;
PayloadType *pt;
int tmp;
MSConnectionHelper h;
rtp_session_set_profile(rtps,profile);
if (remport>0) rtp_session_set_remote_addr_full(rtps,remip,remport,rem_rtcp_port);
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
if (remport>0)
ms_filter_call_method(stream->rtpsend,MS_RTP_SEND_SET_SESSION,rtps);
stream->rtprecv=ms_filter_new(MS_RTP_RECV_ID);
ms_filter_call_method(stream->rtprecv,MS_RTP_RECV_SET_SESSION,rtps);
stream->session=rtps;
stream->dtmfgen=ms_filter_new(MS_DTMF_GEN_ID);
rtp_session_signal_connect(rtps,"telephone-event",(RtpCallback)on_dtmf_received,(unsigned long)stream);
rtp_session_signal_connect(rtps,"payload_type_changed",(RtpCallback)payload_type_changed,(unsigned long)stream);
/* creates the local part */
if (captcard!=NULL) stream->soundread=ms_snd_card_create_reader(captcard);
else {
stream->soundread=ms_filter_new(MS_FILE_PLAYER_ID);
stream->read_resampler=ms_filter_new(MS_RESAMPLE_ID);
if (infile!=NULL) audio_stream_play(stream,infile);
}
if (playcard!=NULL) stream->soundwrite=ms_snd_card_create_writer(playcard);
else {
stream->soundwrite=ms_filter_new(MS_FILE_REC_ID);
if (outfile!=NULL) audio_stream_record(stream,outfile);
}
/* creates the couple of encoder/decoder */
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("audiostream.c: undefined payload type.");
return -1;
}
stream->encoder=ms_filter_create_encoder(pt->mime_type);
stream->decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->encoder==NULL) || (stream->decoder==NULL)){
/* big problem: we have not a registered codec for this payload...*/
ms_error("mediastream.c: No decoder available for payload %i.",payload);
return -1;
}
if (stream->el_type!=ELInactive || stream->use_gc || stream->use_ng){
stream->volsend=ms_filter_new(MS_VOLUME_ID);
stream->volrecv=ms_filter_new(MS_VOLUME_ID);
if (stream->el_type!=ELInactive){
if (stream->el_type==ELControlFull) {
/* also reduce speaker gain when no signal - same parameters as std. noise gate */
int tmp=1;
ms_filter_call_method(stream->volrecv,MS_VOLUME_ENABLE_NOISE_GATE,&tmp);
}
ms_filter_call_method(stream->volsend,MS_VOLUME_SET_PEER,stream->volrecv);
}
if (stream->use_ng){
int tmp=1;
ms_filter_call_method(stream->volsend,MS_VOLUME_ENABLE_NOISE_GATE,&tmp);
}
}
if (stream->use_agc || stream->use_nr){
int tmp=1;
if (stream->volsend==NULL)
stream->volsend=ms_filter_new(MS_VOLUME_ID);
if(stream->use_agc) ms_filter_call_method(stream->volsend,MS_VOLUME_ENABLE_AGC,&tmp);
/*Noise Reduction*/
if(stream->use_nr) ms_filter_call_method(stream->volsend,MS_VOLUME_ENABLE_NR,&tmp);
}
/* give the sound filters some properties */
if (ms_filter_call_method(stream->soundread,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate) != 0) {
/* need to add resampler*/
if (stream->read_resampler == NULL) stream->read_resampler=ms_filter_new(MS_RESAMPLE_ID);
}
if (ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate) != 0) {
/* need to add resampler*/
if (stream->write_resampler == NULL) stream->write_resampler=ms_filter_new(MS_RESAMPLE_ID);
}
tmp=1;
ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_NCHANNELS, &tmp);
if(stream->record_enabled)
{
stream->filewriter = ms_filter_new(MS_FILE_REC_ID);
stream->recordmixer= ms_filter_new(MS_AUDIO_MIXER_ID);
stream->mic_tee = ms_filter_new(MS_TEE_ID);
stream->spk_tee = ms_filter_new(MS_TEE_ID);
ms_filter_call_method(stream->filewriter,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
ms_filter_call_method(stream->recordmixer,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
tmp=1;
ms_filter_call_method(stream->recordmixer,MS_FILTER_SET_NCHANNELS,&tmp);
}
/*configure the echo canceller if required */
if (use_ec) {
stream->ec=ms_filter_new(MS_SPEEX_EC_ID);
ms_filter_call_method(stream->ec,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
if (stream->ec_tail_len!=0)
ms_filter_call_method(stream->ec,MS_ECHO_CANCELLER_SET_TAIL_LENGTH,&stream->ec_tail_len);
if (stream->ec_delay!=0){
ms_filter_call_method(stream->ec,MS_ECHO_CANCELLER_SET_DELAY,&stream->ec_delay);
}else{
/*configure from latency of sound card in case it is availlable */
int latency=0;
ms_filter_call_method(stream->soundread,MS_FILTER_GET_LATENCY,&latency);
latency-=30; /*keep 30 milliseconds security margin*/
if (latency<0) latency=0;
ms_filter_call_method(stream->ec,MS_ECHO_CANCELLER_SET_DELAY,&latency);
}
if (stream->ec_framesize!=0)
ms_filter_call_method(stream->ec,MS_ECHO_CANCELLER_SET_FRAMESIZE,&stream->ec_framesize);
}
/* give the encoder/decoder some parameters*/
ms_filter_call_method(stream->encoder,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
ms_message("Payload's bitrate is %i",pt->normal_bitrate);
if (pt->normal_bitrate>0){
ms_message("Setting audio encoder network bitrate to %i",pt->normal_bitrate);
ms_filter_call_method(stream->encoder,MS_FILTER_SET_BITRATE,&pt->normal_bitrate);
}
ms_filter_call_method(stream->decoder,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
if (pt->send_fmtp!=NULL) ms_filter_call_method(stream->encoder,MS_FILTER_ADD_FMTP, (void*)pt->send_fmtp);
if (pt->recv_fmtp!=NULL) ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/*create the equalizer*/
stream->equalizer=ms_filter_new(MS_EQUALIZER_ID);
tmp=stream->eq_active;
ms_filter_call_method(stream->equalizer,MS_EQUALIZER_SET_ACTIVE,&tmp);
/*configure resampler if needed*/
if (stream->read_resampler){
audio_stream_configure_resampler(stream->read_resampler,stream->soundread,stream->rtpsend);
}
if (stream->write_resampler){
audio_stream_configure_resampler(stream->write_resampler,stream->rtprecv,stream->soundwrite);
}
/* and then connect all */
/* tip: draw yourself the picture if you don't understand */
/*sending graph*/
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,stream->soundread,-1,0);
if (stream->read_resampler)
ms_connection_helper_link(&h,stream->read_resampler,0,0);
if (stream->ec)
ms_connection_helper_link(&h,stream->ec,1,1);
if (stream->volsend)
ms_connection_helper_link(&h,stream->volsend,0,0);
if(stream->mic_tee)
ms_connection_helper_link(&h,stream->mic_tee,0,0);
if(stream->mic_tee && stream->recordmixer)
ms_filter_link(stream->mic_tee,1,stream->recordmixer,0);
ms_connection_helper_link(&h,stream->encoder,0,0);
ms_connection_helper_link(&h,stream->rtpsend,0,-1);
/*receiving graph*/
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,stream->rtprecv,-1,0);
ms_connection_helper_link(&h,stream->decoder,0,0);
ms_connection_helper_link(&h,stream->dtmfgen,0,0);
if (stream->equalizer)
ms_connection_helper_link(&h,stream->equalizer,0,0);
if (stream->volrecv)
ms_connection_helper_link(&h,stream->volrecv,0,0);
if (stream->ec)
ms_connection_helper_link(&h,stream->ec,0,0);
if (stream->write_resampler)
ms_connection_helper_link(&h,stream->write_resampler,0,0);
if(stream->spk_tee)
ms_connection_helper_link(&h,stream->spk_tee,0,0);
if(stream->mic_tee && stream->recordmixer)
ms_filter_link(stream->spk_tee,1,stream->recordmixer,1);
ms_connection_helper_link(&h,stream->soundwrite,0,-1);
if (stream->filewriter && stream->spk_tee && stream->mic_tee && stream->recordmixer){
ms_filter_link(stream->recordmixer,0,stream->filewriter,0);
}
/* create ticker */
stream->ticker=ms_ticker_new();
ms_ticker_set_name(stream->ticker,"Audio MSTicker");
ms_ticker_attach(stream->ticker,stream->soundread);
ms_ticker_attach(stream->ticker,stream->rtprecv);
return 0;
}
int audio_stream_start_full(AudioStream *stream, RtpProfile *profile, const char *remip,int remport,
int rem_rtcp_port, int payload,int jitt_comp, const char *infile, const char *outfile,
MSSndCard *playcard, MSSndCard *captcard, bool_t use_ec)
{
RtpSession *rtps=stream->session;
PayloadType *pt;
int tmp;
rtp_session_set_profile(rtps,profile);
if (remport>0) rtp_session_set_remote_addr_full(rtps,remip,remport,rem_rtcp_port);
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
if (remport>0)
ms_filter_call_method(stream->rtpsend,MS_RTP_SEND_SET_SESSION,rtps);
stream->rtprecv=ms_filter_new(MS_RTP_RECV_ID);
ms_filter_call_method(stream->rtprecv,MS_RTP_RECV_SET_SESSION,rtps);
stream->session=rtps;
stream->dtmfgen=ms_filter_new(MS_DTMF_GEN_ID);
rtp_session_signal_connect(rtps,"telephone-event",(RtpCallback)on_dtmf_received,(unsigned long)stream);
rtp_session_signal_connect(rtps,"payload_type_changed",(RtpCallback)payload_type_changed,(unsigned long)stream);
/* creates the local part */
if (captcard!=NULL) stream->soundread=ms_snd_card_create_reader(captcard);
else {
stream->soundread=ms_filter_new(MS_FILE_PLAYER_ID);
if (infile!=NULL) audio_stream_play(stream,infile);
}
if (playcard!=NULL) stream->soundwrite=ms_snd_card_create_writer(playcard);
else {
stream->soundwrite=ms_filter_new(MS_FILE_REC_ID);
if (outfile!=NULL) audio_stream_record(stream,outfile);
}
/* creates the couple of encoder/decoder */
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("audiostream.c: undefined payload type.");
return -1;
}
stream->encoder=ms_filter_create_encoder(pt->mime_type);
stream->decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->encoder==NULL) || (stream->decoder==NULL)){
/* big problem: we have not a registered codec for this payload...*/
ms_error("mediastream.c: No decoder available for payload %i.",payload);
return -1;
}
if (use_ec) {
stream->ec=ms_filter_new(MS_SPEEX_EC_ID);
ms_filter_call_method(stream->ec,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
}
/* give the sound filters some properties */
ms_filter_call_method(stream->soundread,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
tmp=1;
ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_NCHANNELS, &tmp);
/* give the encoder/decoder some parameters*/
ms_filter_call_method(stream->encoder,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
ms_message("Payload's bitrate is %i",pt->normal_bitrate);
if (pt->normal_bitrate>0){
ms_message("Setting audio encoder network bitrate to %i",pt->normal_bitrate);
ms_filter_call_method(stream->encoder,MS_FILTER_SET_BITRATE,&pt->normal_bitrate);
}
ms_filter_call_method(stream->decoder,MS_FILTER_SET_SAMPLE_RATE,&pt->clock_rate);
if (pt->send_fmtp!=NULL) ms_filter_call_method(stream->encoder,MS_FILTER_ADD_FMTP, (void*)pt->send_fmtp);
if (pt->recv_fmtp!=NULL) ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/* and then connect all */
/* tip: draw yourself the picture if you don't understand */
if (stream->ec){
ms_filter_link(stream->soundread,0,stream->ec,1);
ms_filter_link(stream->ec,1,stream->encoder,0);
ms_filter_link(stream->dtmfgen,0,stream->ec,0);
ms_filter_link(stream->ec,0,stream->soundwrite,0);
}else{
ms_filter_link(stream->soundread,0,stream->encoder,0);
ms_filter_link(stream->dtmfgen,0,stream->soundwrite,0);
}
ms_filter_link(stream->encoder,0,stream->rtpsend,0);
ms_filter_link(stream->rtprecv,0,stream->decoder,0);
ms_filter_link(stream->decoder,0,stream->dtmfgen,0);
/* create ticker */
stream->ticker=ms_ticker_new();
ms_ticker_set_name(stream->ticker,"Audio MSTicker");
ms_ticker_attach(stream->ticker,stream->soundread);
ms_ticker_attach(stream->ticker,stream->rtprecv);
return 0;
}
int video_stream_start (VideoStream *stream, RtpProfile *profile, const char *remip, int remport,
int rem_rtcp_port, int payload, int jitt_comp, MSWebCam *cam){
PayloadType *pt;
RtpSession *rtps=stream->session;
MSPixFmt format;
MSVideoSize disp_size;
int tmp;
JBParameters jbp;
const int socket_buf_size=2000000;
if (cam==NULL){
cam=ms_web_cam_manager_get_default_cam (
ms_web_cam_manager_get());
}
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("videostream.c: undefined payload type.");
return -1;
}
rtp_session_set_profile(rtps,profile);
if (remport>0) rtp_session_set_remote_addr_full(rtps,remip,remport,rem_rtcp_port);
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
rtp_session_signal_connect(stream->session,"payload_type_changed",
(RtpCallback)payload_type_changed,(unsigned long)stream);
rtp_session_set_recv_buf_size(stream->session,MAX_RTP_SIZE);
rtp_session_get_jitter_buffer_params(stream->session,&jbp);
jbp.max_packets=1000;//needed for high resolution video
rtp_session_set_jitter_buffer_params(stream->session,&jbp);
rtp_session_set_rtp_socket_recv_buffer_size(stream->session,socket_buf_size);
rtp_session_set_rtp_socket_send_buffer_size(stream->session,socket_buf_size);
if (stream->dir==VideoStreamSendRecv || stream->dir==VideoStreamSendOnly){
/*plumb the outgoing stream */
if (remport>0) ms_filter_call_method(stream->rtpsend,MS_RTP_SEND_SET_SESSION,stream->session);
stream->encoder=ms_filter_create_encoder(pt->mime_type);
if ((stream->encoder==NULL) ){
/* big problem: we don't have a registered codec for this payload...*/
ms_error("videostream.c: No encoder available for payload %i:%s.",payload,pt->mime_type);
return -1;
}
/* creates the filters */
stream->source = ms_web_cam_create_reader(cam);
stream->tee = ms_filter_new(MS_TEE_ID);
if (pt->normal_bitrate>0){
ms_message("Limiting bitrate of video encoder to %i bits/s",pt->normal_bitrate);
ms_filter_call_method(stream->encoder,MS_FILTER_SET_BITRATE,&pt->normal_bitrate);
}
if (pt->send_fmtp){
ms_filter_call_method(stream->encoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
}
if (stream->use_preview_window){
if (stream->rendercb==NULL){
stream->output2=ms_filter_new_from_name (stream->display_name);
}
}
configure_video_source (stream);
/* and then connect all */
ms_filter_link (stream->source, 0, stream->pixconv, 0);
ms_filter_link (stream->pixconv, 0, stream->sizeconv, 0);
ms_filter_link (stream->sizeconv, 0, stream->tee, 0);
ms_filter_link (stream->tee, 0 ,stream->encoder, 0 );
ms_filter_link (stream->encoder,0, stream->rtpsend,0);
if (stream->output2){
if (stream->window_id!=0){
ms_filter_call_method(stream->output2, MS_VIDEO_DISPLAY_SET_NATIVE_WINDOW_ID,&stream->preview_window_id);
}
ms_filter_link(stream->tee,1,stream->output2,0);
}
}
if (stream->dir==VideoStreamSendRecv || stream->dir==VideoStreamRecvOnly){
MSConnectionHelper ch;
/*plumb the incoming stream */
stream->decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->decoder==NULL) ){
/* big problem: we don't have a registered decoderfor this payload...*/
ms_error("videostream.c: No decoder available for payload %i:%s.",payload,pt->mime_type);
return -1;
}
stream->rtprecv = ms_filter_new (MS_RTP_RECV_ID);
ms_filter_call_method(stream->rtprecv,MS_RTP_RECV_SET_SESSION,stream->session);
if(stream->conf_mode==FALSE)
{
stream->tee2=ms_filter_new(MS_TEE_ID);
stream->jpegwriter=ms_filter_new(MS_JPEG_WRITER_ID);
}
if (stream->rendercb!=NULL){
stream->output=ms_filter_new(MS_EXT_DISPLAY_ID);
ms_filter_set_notify_callback (stream->output,ext_display_cb,stream);
}else{
if(stream->conf_mode)
stream->output=ms_filter_new(MS_VOID_SINK_ID);
else
stream->output=ms_filter_new_from_name (stream->display_name);
}
/* set parameters to the decoder*/
if (pt->send_fmtp){
ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
}
if (pt->recv_fmtp!=NULL)
ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/*force the decoder to output YUV420P */
format=MS_YUV420P;
ms_filter_call_method(stream->decoder,MS_FILTER_SET_PIX_FMT,&format);
/*configure the display window */
disp_size.width=MS_VIDEO_SIZE_CIF_W;
disp_size.height=MS_VIDEO_SIZE_CIF_H;
tmp=1;
ms_filter_call_method(stream->output,MS_FILTER_SET_VIDEO_SIZE,&disp_size);
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_ENABLE_AUTOFIT,&tmp);
ms_filter_call_method(stream->output,MS_FILTER_SET_PIX_FMT,&format);
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_SET_LOCAL_VIEW_MODE,&stream->corner);
if (stream->window_id!=0){
ms_filter_call_method(stream->output, MS_VIDEO_DISPLAY_SET_NATIVE_WINDOW_ID,&stream->window_id);
}
/* and connect the filters */
ms_connection_helper_start (&ch);
ms_connection_helper_link (&ch,stream->rtprecv,-1,0);
ms_connection_helper_link (&ch,stream->decoder,0,0);
if (stream->tee2){
ms_connection_helper_link (&ch,stream->tee2,0,0);
ms_filter_link(stream->tee2,1,stream->jpegwriter,0);
//Êä³öÊÓƵ¼ÖÆÖ¡.
if(stream->video_record)
ms_filter_link(stream->tee2,2,stream->video_record,0);
}
ms_connection_helper_link (&ch,stream->output,0,-1);
/* the video source must be send for preview , if it exists*/
if (stream->tee!=NULL && stream->output2==NULL)
ms_filter_link(stream->tee,1,stream->output,1);
}
/* create the ticker */
stream->ticker = ms_ticker_new();
ms_ticker_set_name(stream->ticker,"Video MSTicker");
//¼æÈÝPVX Ðëµ÷Õû±àÂë¼ä¸ô
//stream->ticker->interval = 3;
#ifdef ENABLE_UDT
if(stream->enable_udt){
stream->udt = ms_filter_new(MS_UDT_TRANSPORT_ID);
ms_filter_call_method(stream->udt,MS_UDT_SET_RTP_SESSION,stream->session);
}
#endif //ENABLE_UDT
/* attach the graphs */
if (stream->source)
ms_ticker_attach (stream->ticker, stream->source);
if (stream->rtprecv)
ms_ticker_attach (stream->ticker, stream->rtprecv);
#ifdef ENABLE_UDT //×îºóÔËÐУ¬±ÜÃâ×èÈûUI
if (stream->udt) ms_ticker_attach (stream->ticker, stream->udt);
#endif // ENABLE_UDT
return 0;
}
int audio_stream_start_full(AudioStream *stream, RtpProfile *profile, const char *rem_rtp_ip,int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload,int jitt_comp, const char *infile, const char *outfile,
MSSndCard *playcard, MSSndCard *captcard, bool_t use_ec)
{
RtpSession *rtps=stream->ms.session;
PayloadType *pt,*tel_ev;
int tmp;
MSConnectionHelper h;
int sample_rate;
MSRtpPayloadPickerContext picker_context;
bool_t has_builtin_ec=FALSE;
rtp_session_set_profile(rtps,profile);
if (rem_rtp_port>0) rtp_session_set_remote_addr_full(rtps,rem_rtp_ip,rem_rtp_port,rem_rtcp_ip,rem_rtcp_port);
if (rem_rtcp_port<=0){
rtp_session_enable_rtcp(rtps,FALSE);
}
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
if (rem_rtp_port>0)
ms_filter_call_method(stream->ms.rtpsend,MS_RTP_SEND_SET_SESSION,rtps);
stream->ms.rtprecv=ms_filter_new(MS_RTP_RECV_ID);
ms_filter_call_method(stream->ms.rtprecv,MS_RTP_RECV_SET_SESSION,rtps);
stream->ms.session=rtps;
if((stream->features & AUDIO_STREAM_FEATURE_DTMF) != 0)
stream->dtmfgen=ms_filter_new(MS_DTMF_GEN_ID);
else
stream->dtmfgen=NULL;
rtp_session_signal_connect(rtps,"telephone-event",(RtpCallback)on_dtmf_received,(unsigned long)stream);
rtp_session_signal_connect(rtps,"payload_type_changed",(RtpCallback)mediastream_payload_type_changed,(unsigned long)&stream->ms);
/* creates the local part */
if (captcard!=NULL){
if (stream->soundread==NULL)
stream->soundread=ms_snd_card_create_reader(captcard);
has_builtin_ec=!!(ms_snd_card_get_capabilities(captcard) & MS_SND_CARD_CAP_BUILTIN_ECHO_CANCELLER);
}else {
stream->soundread=ms_filter_new(MS_FILE_PLAYER_ID);
stream->read_resampler=ms_filter_new(MS_RESAMPLE_ID);
if (infile!=NULL) audio_stream_play(stream,infile);
}
if (playcard!=NULL) {
if (stream->soundwrite==NULL)
stream->soundwrite=ms_snd_card_create_writer(playcard);
}else {
stream->soundwrite=ms_filter_new(MS_FILE_REC_ID);
if (outfile!=NULL) audio_stream_record(stream,outfile);
}
/* creates the couple of encoder/decoder */
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("audiostream.c: undefined payload type.");
return -1;
}
tel_ev=rtp_profile_get_payload_from_mime (profile,"telephone-event");
if ((stream->features & AUDIO_STREAM_FEATURE_DTMF_ECHO) != 0 && (tel_ev==NULL || ( (tel_ev->flags & PAYLOAD_TYPE_FLAG_CAN_RECV) && !(tel_ev->flags & PAYLOAD_TYPE_FLAG_CAN_SEND)))
&& ( strcasecmp(pt->mime_type,"pcmu")==0 || strcasecmp(pt->mime_type,"pcma")==0)){
/*if no telephone-event payload is usable and pcma or pcmu is used, we will generate
inband dtmf*/
stream->dtmfgen_rtp=ms_filter_new (MS_DTMF_GEN_ID);
} else {
stream->dtmfgen_rtp=NULL;
}
if (ms_filter_call_method(stream->ms.rtpsend,MS_FILTER_GET_SAMPLE_RATE,&sample_rate)!=0){
ms_error("Sample rate is unknown for RTP side !");
return -1;
}
stream->ms.encoder=ms_filter_create_encoder(pt->mime_type);
stream->ms.decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->ms.encoder==NULL) || (stream->ms.decoder==NULL)){
/* big problem: we have not a registered codec for this payload...*/
ms_error("audio_stream_start_full: No decoder or encoder available for payload %s.",pt->mime_type);
return -1;
}
if (ms_filter_has_method(stream->ms.decoder, MS_FILTER_SET_RTP_PAYLOAD_PICKER)) {
ms_message(" decoder has FEC capabilities");
picker_context.filter_graph_manager=stream;
picker_context.picker=&audio_stream_payload_picker;
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_RTP_PAYLOAD_PICKER, &picker_context);
}
if((stream->features & AUDIO_STREAM_FEATURE_VOL_SND) != 0)
stream->volsend=ms_filter_new(MS_VOLUME_ID);
else
stream->volsend=NULL;
if((stream->features & AUDIO_STREAM_FEATURE_VOL_RCV) != 0)
stream->volrecv=ms_filter_new(MS_VOLUME_ID);
else
stream->volrecv=NULL;
audio_stream_enable_echo_limiter(stream,stream->el_type);
audio_stream_enable_noise_gate(stream,stream->use_ng);
if (stream->use_agc){
int tmp=1;
if (stream->volsend==NULL)
stream->volsend=ms_filter_new(MS_VOLUME_ID);
ms_filter_call_method(stream->volsend,MS_VOLUME_ENABLE_AGC,&tmp);
}
if (stream->dtmfgen) {
ms_filter_call_method(stream->dtmfgen,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->dtmfgen,MS_FILTER_SET_NCHANNELS,&pt->channels);
}
if (stream->dtmfgen_rtp) {
ms_filter_call_method(stream->dtmfgen_rtp,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->dtmfgen_rtp,MS_FILTER_SET_NCHANNELS,&pt->channels);
}
/* give the sound filters some properties */
if (ms_filter_call_method(stream->soundread,MS_FILTER_SET_SAMPLE_RATE,&sample_rate) != 0) {
/* need to add resampler*/
if (stream->read_resampler == NULL) stream->read_resampler=ms_filter_new(MS_RESAMPLE_ID);
}
ms_filter_call_method(stream->soundread,MS_FILTER_SET_NCHANNELS,&pt->channels);
if (ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_SAMPLE_RATE,&sample_rate) != 0) {
/* need to add resampler*/
if (stream->write_resampler == NULL) stream->write_resampler=ms_filter_new(MS_RESAMPLE_ID);
}
ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_NCHANNELS,&pt->channels);
// Override feature
if ( ((stream->features & AUDIO_STREAM_FEATURE_EC) && !use_ec) || has_builtin_ec )
stream->features &=~AUDIO_STREAM_FEATURE_EC;
/*configure the echo canceller if required */
if ((stream->features & AUDIO_STREAM_FEATURE_EC) == 0 && stream->ec != NULL) {
ms_filter_destroy(stream->ec);
stream->ec=NULL;
}
if (stream->ec){
if (!stream->is_ec_delay_set){
int delay_ms=ms_snd_card_get_minimal_latency(captcard);
if (delay_ms!=0){
ms_message("Setting echo canceller delay with value provided by soundcard: %i ms",delay_ms);
ms_filter_call_method(stream->ec,MS_ECHO_CANCELLER_SET_DELAY,&delay_ms);
}
}
ms_filter_call_method(stream->ec,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
}
if (stream->features & AUDIO_STREAM_FEATURE_MIXED_RECORDING){
int val=0;
int pin=1;
stream->recorder=ms_filter_new(MS_FILE_REC_ID);
stream->recorder_mixer=ms_filter_new(MS_AUDIO_MIXER_ID);
stream->recv_tee=ms_filter_new(MS_TEE_ID);
stream->send_tee=ms_filter_new(MS_TEE_ID);
ms_filter_call_method(stream->recorder_mixer,MS_AUDIO_MIXER_ENABLE_CONFERENCE_MODE,&val);
ms_filter_call_method(stream->recorder_mixer,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->recorder_mixer,MS_FILTER_SET_NCHANNELS,&pt->channels);
ms_filter_call_method(stream->recv_tee,MS_TEE_MUTE,&pin);
ms_filter_call_method(stream->send_tee,MS_TEE_MUTE,&pin);
ms_filter_call_method(stream->recorder,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->recorder,MS_FILTER_SET_NCHANNELS,&pt->channels);
}
/* give the encoder/decoder some parameters*/
ms_filter_call_method(stream->ms.encoder,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_message("Payload's bitrate is %i",pt->normal_bitrate);
if (pt->normal_bitrate>0){
ms_message("Setting audio encoder network bitrate to %i",pt->normal_bitrate);
ms_filter_call_method(stream->ms.encoder,MS_FILTER_SET_BITRATE,&pt->normal_bitrate);
}
ms_filter_call_method(stream->ms.encoder,MS_FILTER_SET_NCHANNELS,&pt->channels);
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_NCHANNELS,&pt->channels);
if (pt->send_fmtp!=NULL) {
char value[16]={0};
int ptime;
if (ms_filter_has_method(stream->ms.encoder,MS_AUDIO_ENCODER_SET_PTIME)){
if (fmtp_get_value(pt->send_fmtp,"ptime",value,sizeof(value)-1)){
ptime=atoi(value);
ms_filter_call_method(stream->ms.encoder,MS_AUDIO_ENCODER_SET_PTIME,&ptime);
}
}
ms_filter_call_method(stream->ms.encoder,MS_FILTER_ADD_FMTP, (void*)pt->send_fmtp);
}
if (pt->recv_fmtp!=NULL) ms_filter_call_method(stream->ms.decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/*create the equalizer*/
if ((stream->features & AUDIO_STREAM_FEATURE_EQUALIZER) != 0){
stream->equalizer=ms_filter_new(MS_EQUALIZER_ID);
if(stream->equalizer) {
tmp=stream->eq_active;
ms_filter_call_method(stream->equalizer,MS_EQUALIZER_SET_ACTIVE,&tmp);
}
}else
stream->equalizer=NULL;
/*configure resampler if needed*/
ms_filter_call_method(stream->ms.rtpsend, MS_FILTER_SET_NCHANNELS, &pt->channels);
ms_filter_call_method(stream->ms.rtprecv, MS_FILTER_SET_NCHANNELS, &pt->channels);
if (stream->read_resampler){
audio_stream_configure_resampler(stream->read_resampler,stream->soundread,stream->ms.rtpsend);
}
if (stream->write_resampler){
audio_stream_configure_resampler(stream->write_resampler,stream->ms.rtprecv,stream->soundwrite);
}
if (stream->ms.use_rc){
stream->ms.rc=ms_audio_bitrate_controller_new(stream->ms.session,stream->ms.encoder,0);
}
/* Create PLC */
if ((stream->features & AUDIO_STREAM_FEATURE_PLC) != 0) {
int decoder_have_plc = 0;
if (ms_filter_has_method(stream->ms.decoder, MS_AUDIO_DECODER_HAVE_PLC)) {
if (ms_filter_call_method(stream->ms.decoder, MS_AUDIO_DECODER_HAVE_PLC, &decoder_have_plc) != 0) {
ms_warning("MS_AUDIO_DECODER_HAVE_PLC function error: enable default plc");
}
} else {
ms_warning("MS_DECODER_HAVE_PLC function not implemented by the decoder: enable default plc");
}
if (decoder_have_plc == 0) {
stream->plc = ms_filter_new(MS_GENERIC_PLC_ID);
}
if (stream->plc) {
ms_filter_call_method(stream->plc, MS_FILTER_SET_NCHANNELS, &pt->channels);
ms_filter_call_method(stream->plc, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
}
} else {
stream->plc = NULL;
}
/* create ticker */
if (stream->ms.ticker==NULL) start_ticker(&stream->ms);
else{
/*we were using the dummy preload graph, destroy it*/
if (stream->dummy) stop_preload_graph(stream);
}
/* and then connect all */
/* tip: draw yourself the picture if you don't understand */
/*sending graph*/
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,stream->soundread,-1,0);
if (stream->read_resampler)
ms_connection_helper_link(&h,stream->read_resampler,0,0);
if (stream->ec)
ms_connection_helper_link(&h,stream->ec,1,1);
if (stream->volsend)
ms_connection_helper_link(&h,stream->volsend,0,0);
if (stream->dtmfgen_rtp)
ms_connection_helper_link(&h,stream->dtmfgen_rtp,0,0);
if (stream->send_tee)
ms_connection_helper_link(&h,stream->send_tee,0,0);
ms_connection_helper_link(&h,stream->ms.encoder,0,0);
ms_connection_helper_link(&h,stream->ms.rtpsend,0,-1);
/*receiving graph*/
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,stream->ms.rtprecv,-1,0);
ms_connection_helper_link(&h,stream->ms.decoder,0,0);
if (stream->plc)
ms_connection_helper_link(&h,stream->plc,0,0);
if (stream->dtmfgen)
ms_connection_helper_link(&h,stream->dtmfgen,0,0);
if (stream->volrecv)
ms_connection_helper_link(&h,stream->volrecv,0,0);
if (stream->recv_tee)
ms_connection_helper_link(&h,stream->recv_tee,0,0);
if (stream->equalizer)
ms_connection_helper_link(&h,stream->equalizer,0,0);
if (stream->ec)
ms_connection_helper_link(&h,stream->ec,0,0);
if (stream->write_resampler)
ms_connection_helper_link(&h,stream->write_resampler,0,0);
ms_connection_helper_link(&h,stream->soundwrite,0,-1);
/*call recording part, attached to both outgoing and incoming graphs*/
if (stream->recorder){
ms_filter_link(stream->send_tee,1,stream->recorder_mixer,0);
ms_filter_link(stream->recv_tee,1,stream->recorder_mixer,1);
ms_filter_link(stream->recorder_mixer,0,stream->recorder,0);
}
/*to make sure all preprocess are done before befre processing audio*/
ms_ticker_attach_multiple(stream->ms.ticker
,stream->soundread
,stream->ms.rtprecv
,NULL);
stream->ms.start_time=ms_time(NULL);
stream->ms.is_beginning=TRUE;
return 0;
}
int main(int argc, char*argv[])
{
RtpSession *session;
#ifndef SBUS
unsigned char buffer[160];
#else
unsigned char buffer[SBUS_FRAME_SIZE];
#endif
int err;
uint32_t ts=0;
int stream_received=0;
FILE *outfile;
int local_port;
int have_more;
int i;
int format=0;
int soundcard=0;
int sound_fd=0;
int jittcomp=40;
bool_t adapt=TRUE;
#ifdef SBUS
RtpProfile prof;
#endif
/* init the lib */
if (argc<3){
printf("%s",help);
return -1;
}
local_port=atoi(argv[2]);
if (local_port<=0) {
printf("%s",help);
return -1;
}
for (i=3;i<argc;i++)
{
if (strcmp(argv[i],"--noadapt")==0) adapt=FALSE;
if (strcmp(argv[i],"--format")==0){
i++;
if (i<argc){
if (strcmp(argv[i],"mulaw")==0){
format=MULAW;
}else
if (strcmp(argv[i],"alaw")==0){
format=ALAW;
}else{
printf("Unsupported format %s\n",argv[i]);
return -1;
}
}
}
else if (strcmp(argv[i],"--soundcard")==0){
soundcard=1;
}
else if (strcmp(argv[i],"--with-jitter")==0){
i++;
if (i<argc){
jittcomp=atoi(argv[i]);
printf("Using a jitter buffer of %i milliseconds.\n",jittcomp);
}
}
}
outfile=fopen(argv[1],"wb");
if (outfile==NULL) {
perror("Cannot open file for writing");
return -1;
}
#ifdef SBUS
setvbuf(outfile, NULL, _IONBF, 0);
#endif
if (soundcard){
sound_fd=sound_init(format);
}
ortp_init();
ortp_scheduler_init();
ortp_set_log_level_mask(ORTP_DEBUG|ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR);
signal(SIGINT,stop_handler);
session=rtp_session_new(RTP_SESSION_RECVONLY);
rtp_session_set_scheduling_mode(session,1);
rtp_session_set_blocking_mode(session,1);
rtp_session_set_local_addr(session,"0.0.0.0",atoi(argv[2]),-1);
rtp_session_set_connected_mode(session,TRUE);
rtp_session_set_symmetric_rtp(session,TRUE);
rtp_session_enable_adaptive_jitter_compensation(session,adapt);
rtp_session_set_jitter_compensation(session,jittcomp);
#ifndef SBUS
rtp_session_set_payload_type(session,0);
#else
rtp_profile_clear_all(&prof);
//rtp_profile_set_name(&prof, "SBUS");
rtp_profile_set_payload(&prof, 71, &payload_type_sbus);
rtp_session_set_profile(session, &prof);
rtp_session_set_payload_type(session, 71);
#endif
rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)ssrc_cb,0);
rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)rtp_session_reset,0);
while(cond)
{
have_more=1;
while (have_more){
#ifndef SBUS
err=rtp_session_recv_with_ts(session,buffer,160,ts,&have_more);
#else
err=rtp_session_recv_with_ts(session,buffer,SBUS_FRAME_SIZE,ts,&have_more);
#endif
if (err>0) stream_received=1;
/* this is to avoid to write to disk some silence before the first RTP packet is returned*/
if ((stream_received) && (err>0)) {
#ifdef SBUS
clock_gettime(CLOCK_REALTIME, &tsnew);
printf("%09ld\n", tsnew.tv_nsec);
#endif
size_t ret = fwrite(buffer,1,err,outfile);
if (sound_fd>0){
ret = write(sound_fd,buffer,err);
if (ret==-1){
fprintf(stderr,"write to sound card failed (%s)",strerror(errno));
}
}
}
}
#ifndef SBUS
ts+=160;
#else
ts+=70;
#endif
//ortp_message("Receiving packet.");
}
rtp_session_destroy(session);
ortp_exit();
ortp_global_stats_display();
return 0;
}
int ph_media_start(phcall_t *ca, int port, void (*dtmfCallback)(phcall_t *ca, int event), const char * deviceId)
{
int format = WAVE_FORMAT_PCM;
phmstream_t *stream;
#if USE_CODECS
phcodec_t *codec;
#endif /* !USE_CODECS */
#if DO_ECHO_CAN
int taps=256;
#endif /* !DO_ECHO_CAN */
#if USE_CODECS
codec = ph_media_lookup_codec(ca->payload);
if (!codec)
return 0;
#endif /* !USE_CODECS */
stream = open_sndcard(format, codec, deviceId);
if (!stream)
return -1;
stream->payload = ca->payload;
stream->rtp_session = rtp_session_new(RTP_SESSION_SENDRECV);
rtp_session_set_scheduling_mode(stream->rtp_session, 0); /* yes */
rtp_session_set_blocking_mode(stream->rtp_session, 0);
rtp_session_set_profile(stream->rtp_session, &av_profile);
rtp_session_set_jitter_compensation(stream->rtp_session, 60);
rtp_session_set_local_addr(stream->rtp_session, "0.0.0.0", port);
rtp_session_set_remote_addr(stream->rtp_session,
ca->remote_sdp_audio_ip,
ca->remote_sdp_audio_port);
rtp_session_set_payload_type(stream->rtp_session, stream->payload);
rtp_session_signal_connect(stream->rtp_session, "telephone-event",
(RtpCallback)ph_telephone_event, ca);
ca->hasaudio = 1;
stream->running = 1;
ca->phstream = stream;
stream->dtmfCallback = dtmfCallback;
# if DO_ECHO_CAN
# if AEC_BIS
create_AEC();
# else /* !AEC_BIS */
stream->ec = echo_can_create(taps, 0);
if(stream->ec == 0){
fprintf(stderr, "Echo CAN creating failed\n");
}
if(stream->ec)
{
# endif /* !AEC_BIS */
stream->echocancel = taps;
stream->pcm_rd = stream->pcm_wr = 0;
stream->pcm_sent = malloc(PCM_TRACE_LEN);
stream->sent_cnt = stream->recv_cnt = 0;
if(stream->pcm_sent == 0)
fprintf(stderr, "No memory for EC %d\n", stream->pcm_sent);
#if !AEC_BIS
}
#endif /* AEC_BIS */
stream->aec_mutex = g_mutex_new();
stream->synclock = g_mutex_new();
stream->sync_cond = g_cond_new();
stream->pcm_need_resync = 1;
stream->bytes_to_throw = 0;
# endif /* !DO_ECHO_CAN */
stream->dtmfg_lock = g_mutex_new();
stream->dtmfq_cnt = 0;
stream->dtmfg_phase = DTMF_IDLE;
stream->audio_in_thread = osip_thread_create(20000,
ph_audio_in_thread, stream);
stream->audio_out_thread = osip_thread_create(20000,
ph_audio_out_thread, stream);
return 0;
}
int os_sound_start(jcall_t *ca, int port)
{
int p,cond;
int bits = 16;
int stereo = 0; /* 0 is mono */
int rate = 8000;
int blocksize = 512;
if (port == 0)
return -1;
fd=open(AUDIO_DEVICE, O_RDWR|O_NONBLOCK);
if (fd<0) return -EWOULDBLOCK;
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)&~O_NONBLOCK);
ioctl(fd, SNDCTL_DSP_RESET, 0);
p = bits; /* 16 bits */
ioctl(fd, SNDCTL_DSP_SAMPLESIZE, &p);
p = stereo; /* number of channels */
ioctl(fd, SNDCTL_DSP_CHANNELS, &p);
#ifdef USE_PCM
p = AFMT_S16_NE; /* choose LE or BE (endian) */
ioctl(fd, SNDCTL_DSP_SETFMT, &p);
#else
if (ca->payload==0)
p = AFMT_MU_LAW;
else if (ca->payload==8)
p = AFMT_A_LAW;
else if (ca->payload==110||ca->payload==111)
p = AFMT_S16_NE; /* choose LE or BE (endian) */
ioctl(fd, SNDCTL_DSP_SETFMT, &p);
#endif
p = rate; /* rate in khz*/
ioctl(fd, SNDCTL_DSP_SPEED, &p);
ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &min_size);
if (min_size>blocksize)
{
cond=1;
p=min_size/blocksize;
while(cond)
{
int i=ioctl(fd, SNDCTL_DSP_SUBDIVIDE, &p);
/* printf("SUB_DIVIDE said error=%i,errno=%i\n",i,errno); */
if ((i==0) || (p==1)) cond=0;
else p=p/2;
}
}
ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &min_size);
if (min_size>blocksize)
{
printf("dsp block size set to %i.",min_size);
exit(0);
}else{
/* no need to access the card with less latency than needed*/
min_size=blocksize;
}
printf("blocksize = %i\n", min_size);
#ifdef SPEEX_SUPPORT
{
float vbr_qual;
int value;
int quality;
ca->speex_enc = speex_encoder_init(&speex_nb_mode); /* 8kHz */
/* 16kHz speex_enc = speex_encoder_init(&speex_wb_mode); */
/* 32kHz speex_enc = speex_encoder_init(&speex_uwb_mode); */
ca->speex_dec = speex_decoder_init(&speex_nb_mode);
value = 1;
speex_decoder_ctl(ca->speex_dec, SPEEX_SET_ENH, &value);
quality = 8; /* 15kb */
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_QUALITY, &quality);
/* ou bien le bit rate:
value = 15000; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_BITRATE, &value);
*/
/* silence suppression (VAD)
value = 1; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VAD, &value);
Discontinuous transmission (DTX)
value = 1; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_DTX, &value);
Variable Bit Rate (VBR)
value = 1; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VBR, &value);
vbr_qual = 5,0; // between 0 and 10
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VBR_QUALITY, &vbr_qual);
Average bit rate: (ABR)
value = 15000; // 15kb
speex_encoder_ctl(ca->speex_enc, SPEEX_SET_ABR, &value);
*/
speex_encoder_ctl(ca->speex_enc, SPEEX_GET_FRAME_SIZE,
&ca->speex_fsize);
ca->speex_nb_packet = 1;
speex_bits_init(&(ca->speex_bits));
speex_bits_init(&(ca->dec_speex_bits));
}
#endif
ca->rtp_session = rtp_session_new(RTP_SESSION_SENDRECV);
rtp_session_set_scheduling_mode(ca->rtp_session, 1); /* yes */
rtp_session_set_blocking_mode(ca->rtp_session, 1);
rtp_session_set_profile(ca->rtp_session, &av_profile);
rtp_session_set_jitter_compensation(ca->rtp_session, 60);
rtp_session_set_local_addr(ca->rtp_session, _localip, port);
rtp_session_set_remote_addr(ca->rtp_session,
ca->remote_sdp_audio_ip,
ca->remote_sdp_audio_port);
rtp_session_set_payload_type(ca->rtp_session, ca->payload);
rtp_session_signal_connect(ca->rtp_session, "telephone-event",
(RtpCallback)rcv_telephone_event, ca);
/* enter a loop (thread?) to send AUDIO data with
rtp_session_send_with_ts(ca->rtp_session, data, data_length, timestamp);
*/
ca->audio_thread = osip_thread_create(20000,
os_sound_start_thread, ca);
ca->out_audio_thread = osip_thread_create(20000,
os_sound_start_out_thread, ca);
return 0;
}