rtpsession.c 81.7 KB
Newer Older
aymeric's avatar
aymeric committed
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * The oRTP library is an RTP (Realtime Transport Protocol - rfc3550) implementation with additional features.
 * Copyright (C) 2017 Belledonne Communications SARL
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
aymeric's avatar
aymeric committed
19 20


21
#ifdef HAVE_CONFIG_H
aymeric's avatar
aymeric committed
22 23 24 25 26 27 28 29 30 31
#include "ortp-config.h"
#endif

#include "ortp/ortp.h"
#include "ortp/telephonyevents.h"
#include "ortp/rtcp.h"
#include "jitterctl.h"
#include "scheduler.h"
#include "utils.h"
#include "rtpsession_priv.h"
32
#include "congestiondetector.h"
aymeric's avatar
aymeric committed
33

34 35 36
#if (_WIN32_WINNT >= 0x0600)
#include <delayimp.h>
#undef ExternC /* avoid redefinition... */
37
#ifdef ORTP_WINDOWS_DESKTOP
38
#include <QOS2.h>
39
#include <VersionHelpers.h>
40
#endif
Ghislain MARY's avatar
Ghislain MARY committed
41
#endif
42

43
/**
44 45
 * #_RtpTransport object which can handle multiples security protocols. You can for instance use this object
 * to use both sRTP and tunnel transporter. mblk_t messages received and sent from the endpoint
46 47
 * will pass through the list of modifiers given. First modifier in list will be first to modify the message
 * in send mode and last in receive mode.
48 49 50
 * @param[in] endpoint #_RtpTransport object in charge of sending/receiving packets. If NULL, it will use standards sendto and recvfrom functions.
 * @param[in] modifiers_count number of #_RtpTransport object given in the variadic list. Must be 0 if none are given.
 * @returns #_RtpTransport object that will be generated or NULL.
51
**/
52 53 54
RtpTransport* meta_rtp_transport_new(RtpTransport *endpoint, unsigned modifiers_count, ...);
RtpTransport* meta_rtcp_transport_new(RtpTransport *endpoint, unsigned modifiers_count, ...);
void meta_rtp_transport_link(RtpTransport *rtp, RtpTransport *rtcp);
aymeric's avatar
aymeric committed
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

/* this function initialize all session parameter's that depend on the payload type */
static void payload_type_changed(RtpSession *session, PayloadType *pt){
	jitter_control_set_payload(&session->rtp.jittctl,pt);
	rtp_session_set_time_jump_limit(session,session->rtp.time_jump);
	if (pt->type==PAYLOAD_VIDEO){
		session->permissive=TRUE;
		ortp_message("Using permissive algorithm");
	}
	else session->permissive=FALSE;
}

void wait_point_init(WaitPoint *wp){
	ortp_mutex_init(&wp->lock,NULL);
	ortp_cond_init(&wp->cond,NULL);
	wp->time=0;
	wp->wakeup=FALSE;
}
void wait_point_uninit(WaitPoint *wp){
	ortp_cond_destroy(&wp->cond);
	ortp_mutex_destroy(&wp->lock);
}

#define wait_point_lock(wp) ortp_mutex_lock(&(wp)->lock)
#define wait_point_unlock(wp) ortp_mutex_unlock(&(wp)->lock)

void wait_point_wakeup_at(WaitPoint *wp, uint32_t t, bool_t dosleep){
	wp->time=t;
	wp->wakeup=TRUE;
	if (dosleep) ortp_cond_wait(&wp->cond,&wp->lock);
}


bool_t wait_point_check(WaitPoint *wp, uint32_t t){
	bool_t ok=FALSE;
90

aymeric's avatar
aymeric committed
91 92 93 94
	if (wp->wakeup){
		if (TIME_IS_NEWER_THAN(t,wp->time)){
			wp->wakeup=FALSE;
			ok=TRUE;
95

aymeric's avatar
aymeric committed
96 97 98 99 100 101 102 103 104 105
		}
	}
	return ok;
}
#define wait_point_wakeup(wp) ortp_cond_signal(&(wp)->cond);

extern void rtp_parse(RtpSession *session, mblk_t *mp, uint32_t local_str_ts,
		struct sockaddr *addr, socklen_t addrlen);


106
static uint32_t uint32_t_random(void){
107
	return ortp_random();
aymeric's avatar
aymeric committed
108 109 110
}


111 112 113
/* put an rtp packet in queue. It is called by rtp_parse()
   A return value of -1 means the packet was a duplicate, 0 means the packet was ok */
int rtp_putq(queue_t *q, mblk_t *mp)
aymeric's avatar
aymeric committed
114 115 116 117 118 119
{
	mblk_t *tmp;
	rtp_header_t *rtp=(rtp_header_t*)mp->b_rptr,*tmprtp;
	/* insert message block by increasing time stamp order : the last (at the bottom)
		message of the queue is the newest*/
	ortp_debug("rtp_putq(): Enqueuing packet with ts=%i and seq=%i",rtp->timestamp,rtp->seq_number);
120

aymeric's avatar
aymeric committed
121 122
	if (qempty(q)) {
		putq(q,mp);
123
		return 0;
aymeric's avatar
aymeric committed
124 125 126 127 128 129 130 131
	}
	tmp=qlast(q);
	/* we look at the queue from bottom to top, because enqueued packets have a better chance
	to be enqueued at the bottom, since there are surely newer */
	while (!qend(q,tmp))
	{
		tmprtp=(rtp_header_t*)tmp->b_rptr;
		ortp_debug("rtp_putq(): Seeing packet with seq=%i",tmprtp->seq_number);
132

133 134 135 136 137 138
		if (rtp->seq_number == tmprtp->seq_number)
		{
			/* this is a duplicated packet. Don't queue it */
			ortp_debug("rtp_putq: duplicated message.");
			freemsg(mp);
			return -1;
139
		}else if (RTP_SEQ_IS_STRICTLY_GREATER_THAN(rtp->seq_number,tmprtp->seq_number)){
140

aymeric's avatar
aymeric committed
141
			insq(q,tmp->b_next,mp);
142 143
			return 0;
		}
aymeric's avatar
aymeric committed
144 145
		tmp=tmp->b_prev;
	}
146
	/* this packet is the oldest, it has to be
aymeric's avatar
aymeric committed
147 148
	placed on top of the queue */
	insq(q,qfirst(q),mp);
149
	return 0;
aymeric's avatar
aymeric committed
150 151 152 153 154 155 156 157
}


mblk_t *rtp_getq(queue_t *q,uint32_t timestamp, int *rejected)
{
	mblk_t *tmp,*ret=NULL,*old=NULL;
	rtp_header_t *tmprtp;
	uint32_t ts_found=0;
158

aymeric's avatar
aymeric committed
159 160 161 162 163 164 165 166 167 168 169 170 171
	*rejected=0;
	ortp_debug("rtp_getq(): Timestamp %i wanted.",timestamp);
	if (qempty(q))
	{
		/*ortp_debug("rtp_getq: q is empty.");*/
		return NULL;
	}
	/* return the packet with ts just equal or older than the asked timestamp */
	/* packets with older timestamps are discarded */
	while ((tmp=qfirst(q))!=NULL)
	{
		tmprtp=(rtp_header_t*)tmp->b_rptr;
		ortp_debug("rtp_getq: Seeing packet with ts=%i",tmprtp->timestamp);
172

aymeric's avatar
aymeric committed
173 174 175 176 177 178 179
		if ( RTP_TIMESTAMP_IS_NEWER_THAN(timestamp,tmprtp->timestamp) )
		{
			if (ret!=NULL && tmprtp->timestamp==ts_found) {
				/* we've found two packets with same timestamp. return the first one */
				break;
			}
			if (old!=NULL) {
180
				ortp_debug("rtp_getq: discarding too old packet with ts=%u",ts_found);
aymeric's avatar
aymeric committed
181 182 183 184 185
				(*rejected)++;
				freemsg(old);
			}
			ret=getq(q); /* dequeue the packet, since it has an interesting timestamp*/
			ts_found=tmprtp->timestamp;
186
			ortp_debug("rtp_getq: Found packet with ts=%u",tmprtp->timestamp);
187

aymeric's avatar
aymeric committed
188 189 190 191 192 193 194 195 196 197 198 199 200 201
			old=ret;
		}
		else
		{
			break;
		}
	}
	return ret;
}

mblk_t *rtp_getq_permissive(queue_t *q,uint32_t timestamp, int *rejected)
{
	mblk_t *tmp,*ret=NULL;
	rtp_header_t *tmprtp;
202

aymeric's avatar
aymeric committed
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
	*rejected=0;
	ortp_debug("rtp_getq_permissive(): Timestamp %i wanted.",timestamp);

	if (qempty(q))
	{
		/*ortp_debug("rtp_getq: q is empty.");*/
		return NULL;
	}
	/* return the packet with the older timestamp (provided that it is older than
	the asked timestamp) */
	tmp=qfirst(q);
	tmprtp=(rtp_header_t*)tmp->b_rptr;
	ortp_debug("rtp_getq_permissive: Seeing packet with ts=%i",tmprtp->timestamp);
	if ( RTP_TIMESTAMP_IS_NEWER_THAN(timestamp,tmprtp->timestamp) )
	{
		ret=getq(q); /* dequeue the packet, since it has an interesting timestamp*/
		ortp_debug("rtp_getq_permissive: Found packet with ts=%i",tmprtp->timestamp);
	}
	return ret;
}


void
rtp_session_init (RtpSession * session, int mode)
{
228
	JBParameters jbp;
229
	if (session == NULL)
230
	{
231 232
		ortp_debug("rtp_session_init: Invalid paramter (session=NULL)");
		return;
233
	}
aymeric's avatar
aymeric committed
234 235 236 237 238 239
	memset (session, 0, sizeof (RtpSession));
	session->mode = (RtpSessionMode) mode;
	if ((mode == RTP_SESSION_RECVONLY) || (mode == RTP_SESSION_SENDRECV))
	{
		rtp_session_set_flag (session, RTP_SESSION_RECV_SYNC);
		rtp_session_set_flag (session, RTP_SESSION_RECV_NOT_STARTED);
240

aymeric's avatar
aymeric committed
241 242 243 244 245 246 247
	}
	if ((mode == RTP_SESSION_SENDONLY) || (mode == RTP_SESSION_SENDRECV))
	{
		rtp_session_set_flag (session, RTP_SESSION_SEND_NOT_STARTED);
		session->snd.ssrc=uint32_t_random();
		/* set default source description */
		rtp_session_set_source_description(session,"unknown@unknown",NULL,NULL,
248
				NULL,NULL,"oRTP-" ORTP_VERSION,NULL);
aymeric's avatar
aymeric committed
249 250
	}
	rtp_session_set_profile (session, &av_profile); /*the default profile to work with */
251 252
	session->rtp.gs.socket=-1;
	session->rtcp.gs.socket=-1;
253
#ifndef _WIN32
aymeric's avatar
aymeric committed
254 255 256 257 258
	session->rtp.snd_socket_size=0;	/*use OS default value unless on windows where they are definitely too short*/
	session->rtp.rcv_socket_size=0;
#else
	session->rtp.snd_socket_size=session->rtp.rcv_socket_size=65536;
#endif
259
	session->rtp.ssrc_changed_thres=50;
aymeric's avatar
aymeric committed
260 261 262 263 264 265 266
	session->dscp=RTP_DEFAULT_DSCP;
	session->multicast_ttl=RTP_DEFAULT_MULTICAST_TTL;
	session->multicast_loopback=RTP_DEFAULT_MULTICAST_LOOPBACK;
	qinit(&session->rtp.rq);
	qinit(&session->rtp.tev_rq);
	qinit(&session->contributing_sources);
	session->eventqs=NULL;
267 268

	/* Initialize RTCP send algorithm */
269
	session->target_upload_bandwidth = 80000; /* 80kbits/s to have 4kbits/s dedicated to RTCP if rtp_session_set_target_upload_bandwidth() is not called. */
270
	session->rtcp.send_algo.initial = TRUE;
271
	session->rtcp.send_algo.allow_early = TRUE;
272

aymeric's avatar
aymeric committed
273 274 275 276 277 278 279 280 281 282 283 284 285 286
	/* init signal tables */
	rtp_signal_table_init (&session->on_ssrc_changed, session,"ssrc_changed");
	rtp_signal_table_init (&session->on_payload_type_changed, session,"payload_type_changed");
	rtp_signal_table_init (&session->on_telephone_event, session,"telephone-event");
	rtp_signal_table_init (&session->on_telephone_event_packet, session,"telephone-event_packet");
	rtp_signal_table_init (&session->on_timestamp_jump,session,"timestamp_jump");
	rtp_signal_table_init (&session->on_network_error,session,"network_error");
	rtp_signal_table_init (&session->on_rtcp_bye,session,"rtcp_bye");
	wait_point_init(&session->snd.wp);
	wait_point_init(&session->rcv.wp);
	/*defaults send payload type to 0 (pcmu)*/
	rtp_session_set_send_payload_type(session,0);
	/*sets supposed recv payload type to undefined */
	rtp_session_set_recv_payload_type(session,-1);
287

aymeric's avatar
aymeric committed
288
	rtp_session_enable_jitter_buffer(session,TRUE);
289
	jb_parameters_init(&jbp);
aymeric's avatar
aymeric committed
290 291 292
	rtp_session_set_jitter_buffer_params(session,&jbp);
	rtp_session_set_time_jump_limit(session,5000);
	rtp_session_enable_rtcp(session,TRUE);
293
	rtp_session_set_rtcp_report_interval(session,RTCP_DEFAULT_REPORT_INTERVAL);
aymeric's avatar
aymeric committed
294 295 296
	session->recv_buf_size = UDP_MAX_SIZE;
	session->symmetric_rtp = FALSE;
	session->permissive=FALSE;
297
	session->reuseaddr=TRUE;
298 299
	msgb_allocator_init(&session->rtp.gs.allocator);
	msgb_allocator_init(&session->rtcp.gs.allocator);
300
	/*set default rtptransport*/
301

302 303 304 305 306 307
	{
		RtpTransport *rtp_tr = meta_rtp_transport_new(NULL, 0);
		RtpTransport *rtcp_tr = meta_rtcp_transport_new(NULL, 0);
		meta_rtp_transport_link(rtp_tr, rtcp_tr);
		rtp_session_set_transports(session, rtp_tr, rtcp_tr);
	}
308
	session->tev_send_pt = -1; /*check in rtp profile when needed*/
aymeric's avatar
aymeric committed
309 310
}

311 312
void rtp_session_enable_congestion_detection(RtpSession *session, bool_t enabled){
	if (enabled){
Simon Morlat's avatar
Simon Morlat committed
313 314 315 316
		if (session->rtp.jittctl.params.buffer_algorithm != OrtpJitterBufferRecursiveLeastSquare){
			ortp_error("rtp_session_enable_congestion_detection(): cannot use congestion control without RLS jitter buffer algorithm");
			return;
		}
317 318
		if (!session->rtp.congdetect){
			session->rtp.congdetect = ortp_congestion_detector_new(session);
319 320
		}else{
			if (!session->congestion_detector_enabled) ortp_congestion_detector_reset(session->rtp.congdetect); 
321 322
		}
	}
323
	session->congestion_detector_enabled = enabled;
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
}

void jb_parameters_init(JBParameters *jbp) {
	/* configure jitter buffer with working default parameters */
	jbp->min_size=RTP_DEFAULT_JITTER_TIME;
	jbp->nom_size=RTP_DEFAULT_JITTER_TIME;
	jbp->max_size=500;
	jbp->max_packets= 200;/* maximum number of packet allowed to be queued */
	jbp->adaptive=TRUE;
	jbp->enabled=TRUE;
	jbp->buffer_algorithm = OrtpJitterBufferRecursiveLeastSquare;
	jbp->refresh_ms=5000;
	jbp->ramp_threshold=70;
	jbp->ramp_step_ms=20;
	jbp->ramp_refresh_ms=5000;
}
aymeric's avatar
aymeric committed
340 341 342 343

/**
 * Creates a new rtp session.
 * If the session is able to send data (RTP_SESSION_SENDONLY or
344
 * RTP_SESSION_SENDRECV), then a random SSRC number is choosed for
aymeric's avatar
aymeric committed
345
 * the outgoing stream.
346
 * @param mode One of the RtpSessionMode flags.
aymeric's avatar
aymeric committed
347 348 349 350 351 352 353 354
 *
 * @return the newly created rtp session.
**/
RtpSession *
rtp_session_new (int mode)
{
	RtpSession *session;
	session = (RtpSession *) ortp_malloc (sizeof (RtpSession));
355 356
	if (session == NULL)
	{
357 358
		ortp_error("rtp_session_new: Memory allocation failed");
		return NULL;
359
	}
360
	rtp_session_init (session, mode);
aymeric's avatar
aymeric committed
361 362 363 364
	return session;
}

/**
365
 * Sets the scheduling mode of the rtp session. If \a yesno is TRUE, the rtp session is in
aymeric's avatar
aymeric committed
366 367 368 369
 *	the scheduled mode, that means that you can use session_set_select() to block until it's time
 *	to receive or send on this session according to the timestamp passed to the respective functions.
 *  You can also use blocking mode (see rtp_session_set_blocking_mode() ), to simply block within
 *	the receive and send functions.
370
 *	If \a yesno is FALSE, the ortp scheduler will not manage those sessions, meaning that blocking mode
aymeric's avatar
aymeric committed
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
 *  and the use of session_set_select() for this session are disabled.
 *@param session a rtp session.
 *@param yesno 	a boolean to indicate the scheduling mode.
 *
 *
**/
void
rtp_session_set_scheduling_mode (RtpSession * session, int yesno)
{
	if (yesno)
	{
		RtpScheduler *sched;
		sched = ortp_get_scheduler ();
		if (sched != NULL)
		{
			rtp_session_set_flag (session, RTP_SESSION_SCHEDULED);
			session->sched = sched;
			rtp_scheduler_add_session (sched, session);
		}
		else
			ortp_warning
				("rtp_session_set_scheduling_mode: Cannot use scheduled mode because the "
				 "scheduler is not started. Use ortp_scheduler_init() before.");
	}
	else
		rtp_session_unset_flag (session, RTP_SESSION_SCHEDULED);
}


/**
 *	This function implicitely enables the scheduling mode if yesno is TRUE.
402
 *	rtp_session_set_blocking_mode() defines the behaviour of the rtp_session_recv_with_ts() and
403
 *	rtp_session_send_with_ts() functions. If \a yesno is TRUE, rtp_session_recv_with_ts()
aymeric's avatar
aymeric committed
404 405 406
 *	will block until it is time for the packet to be received, according to the timestamp
 *	passed to the function. After this time, the function returns.
 *	For rtp_session_send_with_ts(), it will block until it is time for the packet to be sent.
407
 *	If \a yesno is FALSE, then the two functions will return immediately.
aymeric's avatar
aymeric committed
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
 *
 *  @param session a rtp session
 *  @param yesno a boolean
**/
void
rtp_session_set_blocking_mode (RtpSession * session, int yesno)
{
	if (yesno){
		rtp_session_set_scheduling_mode(session,TRUE);
		rtp_session_set_flag (session, RTP_SESSION_BLOCKING_MODE);
	}else
		rtp_session_unset_flag (session, RTP_SESSION_BLOCKING_MODE);
}

/**
 *	Set the RTP profile to be used for the session. By default, all session are created by
 *	rtp_session_new() are initialized with the AV profile, as defined in RFC 3551. The application
 *	can set any other profile instead using that function.
 *
 * @param session a rtp session
 * @param profile a rtp profile
**/

void
rtp_session_set_profile (RtpSession * session, RtpProfile * profile)
{
	session->snd.profile = profile;
	session->rcv.profile = profile;
	rtp_session_telephone_events_supported(session);
}

/**
 *	By default oRTP automatically sends RTCP SR or RR packets. If
 *	yesno is set to FALSE, the RTCP sending of packet is disabled.
442
 *	This functionality might be needed for some equipments that do not
aymeric's avatar
aymeric committed
443
 *	support RTCP, leading to a traffic of ICMP errors on the network.
444
 *	It can also be used to save bandwidth despite the RTCP bandwidth is
aymeric's avatar
aymeric committed
445 446 447 448 449 450
 *	actually and usually very very low.
**/
void rtp_session_enable_rtcp(RtpSession *session, bool_t yesno){
	session->rtcp.enabled=yesno;
}

451 452 453 454
bool_t rtp_session_rtcp_enabled(const RtpSession *session) {
	return  session->rtcp.enabled;
}

455 456 457 458
/**
 * Sets the default interval in milliseconds for RTCP reports emitted by the session
 *
**/
459
void rtp_session_set_rtcp_report_interval(RtpSession *session, int value_ms) {
460 461
	if (value_ms <= 0) session->rtcp.send_algo.T_rr_interval = 0;
	else session->rtcp.send_algo.T_rr_interval = (uint32_t)value_ms;
462 463
}

464 465 466
void rtp_session_set_target_upload_bandwidth(RtpSession *session, int target_bandwidth) {
	session->target_upload_bandwidth = target_bandwidth;
}
467 468 469
int rtp_session_get_target_upload_bandwidth(RtpSession *session) {
	return session->target_upload_bandwidth;
}
470

aymeric's avatar
aymeric committed
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
/**
 *	Set the RTP profile to be used for the sending by this session. By default, all session are created by
 *	rtp_session_new() are initialized with the AV profile, as defined in RFC 3551. The application
 *	can set any other profile instead using that function.
 * @param session a rtp session
 * @param profile a rtp profile
 *
**/

void
rtp_session_set_send_profile (RtpSession * session, RtpProfile * profile)
{
	session->snd.profile = profile;
	rtp_session_send_telephone_events_supported(session);
}



/**
 *	Set the RTP profile to be used for the receiveing by this session. By default, all session are created by
 *	rtp_session_new() are initialized with the AV profile, as defined in RFC 3551. The application
 *	can set any other profile instead using that function.
 *
 * @param session a rtp session
 * @param profile a rtp profile
**/

void
rtp_session_set_recv_profile (RtpSession * session, RtpProfile * profile)
{
	session->rcv.profile = profile;
	rtp_session_recv_telephone_events_supported(session);
}

/**
 *@param session a rtp session
 *
 *	DEPRECATED! Returns current send profile.
 *	Use rtp_session_get_send_profile() or rtp_session_get_recv_profile()
 *
**/
RtpProfile *rtp_session_get_profile(RtpSession *session){
	return session->snd.profile;
}


/**
 *@param session a rtp session
 *
 *	Returns current send profile.
 *
**/
RtpProfile *rtp_session_get_send_profile(RtpSession *session){
	return session->snd.profile;
}

/**
 *@param session a rtp session
 *
 *	Returns current receive profile.
 *
**/
RtpProfile *rtp_session_get_recv_profile(RtpSession *session){
	return session->rcv.profile;
}

Simon Morlat's avatar
Simon Morlat committed
537
void rtp_session_set_send_ts_offset(RtpSession *s, uint32_t offset){
538 539 540 541 542 543 544
	s->send_ts_offset = offset;
}

uint32_t rtp_session_get_send_ts_offset(RtpSession *s){
	return s->send_ts_offset;
}

aymeric's avatar
aymeric committed
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
/**
 *	The default value is UDP_MAX_SIZE bytes, a value which is working for mostly everyone.
 *	However if your application can make assumption on the sizes of received packet,
 *	it can be interesting to set it to a lower value in order to save memory.
 *
 * @param session a rtp session
 * @param bufsize max size in bytes for receiving packets
**/
void rtp_session_set_recv_buf_size(RtpSession *session, int bufsize){
	session->recv_buf_size=bufsize;
}

/**
 *	Set kernel send maximum buffer size for the rtp socket.
 *	A value of zero defaults to the operating system default.
**/
void rtp_session_set_rtp_socket_send_buffer_size(RtpSession * session, unsigned int size){
	session->rtp.snd_socket_size=size;
563
	_rtp_session_apply_socket_sizes(session);
aymeric's avatar
aymeric committed
564 565 566 567 568 569 570 571
}

/**
 *	Set kernel recv maximum buffer size for the rtp socket.
 *	A value of zero defaults to the operating system default.
**/
void rtp_session_set_rtp_socket_recv_buffer_size(RtpSession * session, unsigned int size){
	session->rtp.rcv_socket_size=size;
572
	_rtp_session_apply_socket_sizes(session);
aymeric's avatar
aymeric committed
573 574 575 576
}

/**
 *	This function provides the way for an application to be informed of various events that
577
 *	may occur during a rtp session. \a signal_name is a string identifying the event, and \a cb is
aymeric's avatar
aymeric committed
578
 *	a user supplied function in charge of processing it. The application can register
579
 *	several callbacks for the same signal, in the limit of \a RTP_CALLBACK_TABLE_MAX_ENTRIES.
aymeric's avatar
aymeric committed
580 581
 *	Here are name and meaning of supported signals types:
 *
582
 *	"ssrc_changed": the SSRC of the incoming stream has changed.
aymeric's avatar
aymeric committed
583
 *
584
 *	"payload_type_changed": the payload type of the incoming stream has changed.
aymeric's avatar
aymeric committed
585
 *
586
 *	"telephone-event_packet": a telephone-event rtp packet (RFC2833) is received.
aymeric's avatar
aymeric committed
587
 *
588
 *	"telephone-event": a telephone event has occurred. This is a high-level shortcut for "telephone-event_packet".
aymeric's avatar
aymeric committed
589
 *
590
 *	"network_error": a network error happened on a socket. Arguments of the callback functions are
aymeric's avatar
aymeric committed
591 592
 *						a const char * explaining the error, an int errno error code and the user_data as usual.
 *
593
 *	"timestamp_jump": we have received a packet with timestamp in far future compared to last timestamp received.
aymeric's avatar
aymeric committed
594 595 596 597
 *						The farness of far future is set by rtp_sesssion_set_time_jump_limit()
 *  "rtcp_bye": we have received a RTCP bye packet. Arguments of the callback
 *              functions are a const char * containing the leaving reason and
 *              the user_data.
598 599
 *	"congestion_state_changed": congestion detector object changed its internal state. Arguments of
 *								the callback function are previous and new states.
aymeric's avatar
aymeric committed
600 601 602 603 604 605 606 607 608 609 610
 *	Returns: 0 on success, -EOPNOTSUPP if the signal does not exists, -1 if no more callbacks
 *	can be assigned to the signal type.
 *
 * @param session 	a rtp session
 * @param signal_name	the name of a signal
 * @param cb		a RtpCallback
 * @param user_data	a pointer to any data to be passed when invoking the callback.
 *
**/
int
rtp_session_signal_connect (RtpSession * session, const char *signal_name,
611
				RtpCallback cb, void *user_data)
aymeric's avatar
aymeric committed
612
{
613
	bctbx_list_t *elem;
aymeric's avatar
aymeric committed
614 615 616 617 618 619
	for (elem=session->signal_tables;elem!=NULL;elem=o_list_next(elem)){
		RtpSignalTable *s=(RtpSignalTable*) elem->data;
		if (strcmp(signal_name,s->signal_name)==0){
			return rtp_signal_table_add(s,cb,user_data);
		}
	}
620
	ortp_warning ("rtp_session_signal_connect: inexistent signal %s",signal_name);
aymeric's avatar
aymeric committed
621 622 623 624 625
	return -1;
}


/**
626
 *	Removes callback function \a cb to the list of callbacks for signal \a signal.
aymeric's avatar
aymeric committed
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
 *
 * @param session a rtp session
 * @param signal_name	a signal name
 * @param cb	a callback function.
 * @return: 0 on success, a negative value if the callback was not found.
**/
int
rtp_session_signal_disconnect_by_callback (RtpSession * session, const char *signal_name,
					   RtpCallback cb)
{
	OList *elem;
	for (elem=session->signal_tables;elem!=NULL;elem=o_list_next(elem)){
		RtpSignalTable *s=(RtpSignalTable*) elem->data;
		if (strcmp(signal_name,s->signal_name)==0){
			return rtp_signal_table_remove_by_callback(s,cb);
		}
	}
	ortp_warning ("rtp_session_signal_connect: inexistant signal %s",signal_name);
	return -1;
}


/**
650
 * Set the initial sequence number for outgoing stream..
aymeric's avatar
aymeric committed
651
 * @param session		a rtp session freshly created.
652
 * @param seq			a 16 bit unsigned number.
aymeric's avatar
aymeric committed
653 654 655 656 657 658
 *
**/
void rtp_session_set_seq_number(RtpSession *session, uint16_t seq){
	session->rtp.snd_seq=seq;
}

659 660 661 662
void rtp_session_set_duplication_ratio(RtpSession *session, float ratio){
	session->duplication_ratio=ratio;
}

aymeric's avatar
aymeric committed
663

664

665 666 667
/**
 * Get the current sequence number for outgoing stream.
**/
aymeric's avatar
aymeric committed
668 669 670 671
uint16_t rtp_session_get_seq_number(RtpSession *session){
	return session->rtp.snd_seq;
}

672 673 674 675 676 677 678
/**
 * Returns the highest extended sequence number received.
**/
uint32_t rtp_session_get_rcv_ext_seq_number(RtpSession *session){
	return session->rtp.hwrcv_extseq;
}

679 680 681 682 683 684
/**
 * Returns the latest cumulative loss value computed
 **/
int rtp_session_get_cum_loss(RtpSession *session){
	return session->cum_loss;
}
aymeric's avatar
aymeric committed
685 686 687 688 689 690 691 692 693 694 695 696 697 698

/**
 *	Sets the SSRC for the outgoing stream.
 *  If not done, a random ssrc is used.
 *
 * @param session a rtp session.
 * @param ssrc an unsigned 32bit integer representing the synchronisation source identifier (SSRC).
**/
void
rtp_session_set_ssrc (RtpSession * session, uint32_t ssrc)
{
	session->snd.ssrc = ssrc;
}

699 700 701 702 703
/**
 *	Get the SSRC for the outgoing stream.
 *
 * @param session a rtp session.
**/
704 705 706 707 708 709
uint32_t
rtp_session_get_send_ssrc (RtpSession* session)
{
	return session->snd.ssrc;
}

710 711
/**
 * Get the SSRC for the incoming stream.
712
 *
713 714 715 716 717 718
 * If no packets have been received yet, 0 is returned.
**/
uint32_t rtp_session_get_recv_ssrc(RtpSession *session){
	return session->rcv.ssrc;
}

719

aymeric's avatar
aymeric committed
720 721 722 723
void rtp_session_update_payload_type(RtpSession *session, int paytype){
	/* check if we support this payload type */
	PayloadType *pt=rtp_profile_get_payload(session->rcv.profile,paytype);
	if (pt!=0){
smorlat's avatar
smorlat committed
724
		session->hw_recv_pt=paytype;
aymeric's avatar
aymeric committed
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
		ortp_message ("payload type changed to %i(%s) !",
				 paytype,pt->mime_type);
		payload_type_changed(session,pt);
	}else{
		ortp_warning("Receiving packet with unknown payload type %i.",paytype);
	}
}
/**
 *	Sets the payload type of the rtp session. It decides of the payload types written in the
 *	of the rtp header for the outgoing stream, if the session is SENDRECV or SENDONLY.
 *	For payload type in incoming packets, the application can be informed by registering
 *	for the "payload_type_changed" signal, so that it can make the necessary changes
 *	on the downstream decoder that deals with the payload of the packets.
 *
 * @param session a rtp session
 * @param paytype the payload type number
 * @return 0 on success, -1 if the payload is not defined.
**/

int
rtp_session_set_send_payload_type (RtpSession * session, int paytype)
{
	session->snd.pt=paytype;
	return 0;
}

/**
 *@param session a rtp session
 *
 *@return the payload type currently used in outgoing rtp packets
**/
int rtp_session_get_send_payload_type(const RtpSession *session){
	return session->snd.pt;
}

760 761 762 763 764 765 766 767 768 769 770 771 772 773
/**
 * Assign the payload type number for sending telephone-event.
 * It is required that a "telephone-event" PayloadType is assigned in the RtpProfile set for the RtpSession.
 * This function is in most of cases useless, unless there is an ambiguity where several PayloadType for "telephone-event" are present in the RtpProfile.
 * This might happen during SIP offeranswer scenarios. This function allows to remove any ambiguity by letting the application choose the one to be used.
 * @param session the RtpSession
 * @param paytype the payload type number
 * @returns 0, -1 on error.
**/
int rtp_session_set_send_telephone_event_payload_type(RtpSession *session, int paytype){
	session->tev_send_pt = paytype;
	return 0;
}

aymeric's avatar
aymeric committed
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
/**
 *
 *	Sets the expected payload type for incoming packets.
 *	If the actual payload type in incoming packets is different that this expected payload type, thus
 *	the "payload_type_changed" signal is emitted.
 *
 *@param session a rtp session
 *@param paytype the payload type number
 *@return 0 on success, -1 if the payload is not defined.
**/

int
rtp_session_set_recv_payload_type (RtpSession * session, int paytype)
{
	PayloadType *pt;
	session->rcv.pt=paytype;
	session->hw_recv_pt=paytype;
	pt=rtp_profile_get_payload(session->rcv.profile,paytype);
	if (pt!=NULL){
		payload_type_changed(session,pt);
	}
	return 0;
}

/**
 *@param session a rtp session
 *
 * @return the payload type currently used in incoming rtp packets
**/
int rtp_session_get_recv_payload_type(const RtpSession *session){
	return session->rcv.pt;
}

/**
 *	Sets the expected payload type for incoming packets and payload type to be used for outgoing packets.
 *	If the actual payload type in incoming packets is different that this expected payload type, thus
 *	the "payload_type_changed" signal is emitted.
 *
 * @param session a rtp session
813
 * @param pt the payload type number
aymeric's avatar
aymeric committed
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
 * @return 0 on success, -1 if the payload is not defined.
**/
int rtp_session_set_payload_type(RtpSession *session, int pt){
	if (rtp_session_set_send_payload_type(session,pt)<0) return -1;
	if (rtp_session_set_recv_payload_type(session,pt)<0) return -1;
	return 0;
}


static void rtp_header_init_from_session(rtp_header_t *rtp, RtpSession *session){
	rtp->version = 2;
	rtp->padbit = 0;
	rtp->extbit = 0;
	rtp->markbit= 0;
	rtp->cc = 0;
	rtp->paytype = session->snd.pt;
	rtp->ssrc = session->snd.ssrc;
	rtp->timestamp = 0;	/* set later, when packet is sended */
	/* set a seq number */
	rtp->seq_number=session->rtp.snd_seq;
}

/**
 *	Allocates a new rtp packet. In the header, ssrc and payload_type according to the session's
smorlat's avatar
smorlat committed
838 839
 *	context. Timestamp is not set, it will be set when the packet is going to be
 *	sent with rtp_session_sendm_with_ts(). Sequence number is initalized to previous sequence number sent + 1
aymeric's avatar
aymeric committed
840 841 842 843 844 845 846 847
 *	If payload_size is zero, thus an empty packet (just a RTP header) is returned.
 *
 *@param session a rtp session.
 *@param header_size the rtp header size. For standart size (without extensions), it is RTP_FIXED_HEADER_SIZE
 *@param payload data to be copied into the rtp packet.
 *@param payload_size size of data carried by the rtp packet.
 *@return a rtp packet in a mblk_t (message block) structure.
**/
848
mblk_t * rtp_session_create_packet(RtpSession *session,size_t header_size, const uint8_t *payload, size_t payload_size)
aymeric's avatar
aymeric committed
849 850
{
	mblk_t *mp;
851
	size_t msglen=header_size+payload_size;
aymeric's avatar
aymeric committed
852
	rtp_header_t *rtp;
853

aymeric's avatar
aymeric committed
854 855 856 857 858 859 860 861 862 863 864 865
	mp=allocb(msglen,BPRI_MED);
	rtp=(rtp_header_t*)mp->b_rptr;
	rtp_header_init_from_session(rtp,session);
	/*copy the payload, if any */
	mp->b_wptr+=header_size;
	if (payload_size){
		memcpy(mp->b_wptr,payload,payload_size);
		mp->b_wptr+=payload_size;
	}
	return mp;
}

866 867 868 869

/**
 * Create a packet already including headers
 */
870
mblk_t * rtp_session_create_packet_raw(const uint8_t *packet, size_t packet_size) {
871 872 873 874 875 876 877 878 879 880
	mblk_t *mp;

	mp=allocb(packet_size,BPRI_MED);
	if (packet_size){
		memcpy(mp->b_wptr,packet,packet_size);
		mp->b_wptr+=packet_size;
	}
	return mp;
}

aymeric's avatar
aymeric committed
881 882 883 884 885 886 887
/**
 *	Creates a new rtp packet using the given payload buffer (no copy). The header will be allocated separetely.
 *  In the header, ssrc and payload_type according to the session's
 *	context. Timestamp and seq number are not set, there will be set when the packet is going to be
 *	sent with rtp_session_sendm_with_ts().
 *	oRTP will send this packet using libc's sendmsg() (if this function is availlable!) so that there will be no
 *	packet concatenation involving copies to be done in user-space.
888
 *  \a freefn can be NULL, in that case payload will be kept untouched.
aymeric's avatar
aymeric committed
889 890 891 892 893 894 895 896
 *
 * @param session a rtp session.
 * @param payload the data to be sent with this packet
 * @param payload_size size of data
 * @param freefn a function that will be called when the payload buffer is no more needed.
 * @return: a rtp packet in a mblk_t (message block) structure.
**/

897
mblk_t * rtp_session_create_packet_with_data(RtpSession *session, uint8_t *payload, size_t payload_size, void (*freefn)(void*))
aymeric's avatar
aymeric committed
898 899 900 901
{
	mblk_t *mp,*mpayload;
	int header_size=RTP_FIXED_HEADER_SIZE; /* revisit when support for csrc is done */
	rtp_header_t *rtp;
902

aymeric's avatar
aymeric committed
903 904 905 906 907 908 909 910 911 912 913 914 915 916
	mp=allocb(header_size,BPRI_MED);
	rtp=(rtp_header_t*)mp->b_rptr;
	rtp_header_init_from_session(rtp,session);
	mp->b_wptr+=header_size;
	/* create a mblk_t around the user supplied payload buffer */
	mpayload=esballoc(payload,payload_size,BPRI_MED,freefn);
	mpayload->b_wptr+=payload_size;
	/* link it with the header */
	mp->b_cont=mpayload;
	return mp;
}


/**
917
 * Creates a new rtp packet using the buffer given in arguments (no copy).
aymeric's avatar
aymeric committed
918 919 920
 * In the header, ssrc and payload_type according to the session's
 *context. Timestamp and seq number are not set, there will be set when the packet is going to be
 *	sent with rtp_session_sendm_with_ts().
921
 * \a freefn can be NULL, in that case payload will be kept untouched.
aymeric's avatar
aymeric committed
922 923 924 925 926 927 928
 *
 * @param session a rtp session.
 * @param buffer a buffer that contains first just enough place to write a RTP header, then the data to send.
 * @param size the size of the buffer
 * @param freefn a function that will be called once the buffer is no more needed (the data has been sent).
 * @return a rtp packet in a mblk_t (message block) structure.
**/
929
mblk_t * rtp_session_create_packet_in_place(RtpSession *session,uint8_t *buffer, size_t size, void (*freefn)(void*) )
aymeric's avatar
aymeric committed
930 931 932
{
	mblk_t *mp;
	rtp_header_t *rtp;
933

aymeric's avatar
aymeric committed
934 935 936 937 938 939 940 941
	mp=esballoc(buffer,size,BPRI_MED,freefn);

	rtp=(rtp_header_t*)mp->b_rptr;
	rtp_header_init_from_session(rtp,session);
	return mp;
}


Ghislain MARY's avatar
Ghislain MARY committed
942
ORTP_PUBLIC int __rtp_session_sendm_with_ts (RtpSession * session, mblk_t *mp, uint32_t packet_ts, uint32_t send_ts)
aymeric's avatar
aymeric committed
943 944 945 946
{
	rtp_header_t *rtp;
	uint32_t packet_time;
	int error = 0;
947
	size_t packsize;
aymeric's avatar
aymeric committed
948 949 950 951 952 953 954 955
	RtpScheduler *sched=session->sched;
	RtpStream *stream=&session->rtp;

	if (session->flags & RTP_SESSION_SEND_NOT_STARTED)
	{
		session->rtp.snd_ts_offset = send_ts;
		/* Set initial last_rcv_time to first send time. */
		if ((session->flags & RTP_SESSION_RECV_NOT_STARTED)
956 957
		|| session->mode == RTP_SESSION_SENDONLY) {
			ortp_gettimeofday(&session->last_recv_time, NULL);
aymeric's avatar
aymeric committed
958
		}
959
		if (session->flags & RTP_SESSION_SCHEDULED) {
aymeric's avatar
aymeric committed
960 961 962 963 964 965 966 967 968 969
			session->rtp.snd_time_offset = sched->time_;
		}
		rtp_session_unset_flag (session,RTP_SESSION_SEND_NOT_STARTED);
	}
	/* if we are in blocking mode, then suspend the process until the scheduler it's time to send  the
	 * next packet */
	/* if the timestamp of the packet queued is older than current time, then you we must
	 * not block */
	if (session->flags & RTP_SESSION_SCHEDULED)
	{
970
		wait_point_lock(&session->snd.wp);
aymeric's avatar
aymeric committed
971 972
		packet_time =
			rtp_session_ts_to_time (session,
973 974
					 send_ts -
					 session->rtp.snd_ts_offset) +
aymeric's avatar
aymeric committed
975 976 977 978
					session->rtp.snd_time_offset;
		/*ortp_message("rtp_session_send_with_ts: packet_time=%i time=%i",packet_time,sched->time_);*/
		if (TIME_IS_STRICTLY_NEWER_THAN (packet_time, sched->time_))
		{
979
			wait_point_wakeup_at(&session->snd.wp,packet_time,(session->flags & RTP_SESSION_BLOCKING_MODE)!=0);
aymeric's avatar
aymeric committed
980 981 982 983 984
			session_set_clr(&sched->w_sessions,session);	/* the session has written */
		}
		else session_set_set(&sched->w_sessions,session);	/*to indicate select to return immediately */
		wait_point_unlock(&session->snd.wp);
	}
985

aymeric's avatar
aymeric committed
986 987 988 989 990 991 992 993
	if(mp==NULL) {/*for people who just want to be blocked but
		 do not want to send anything.*/
		session->rtp.snd_last_ts = packet_ts;
		return 0;
	}

	rtp=(rtp_header_t*)mp->b_rptr;

994 995
	packsize = msgdsize(mp) ;
	session->duplication_left += session->duplication_ratio;
996 997 998 999
	if (rtp->version == 0) {
		/* We are probably trying to send a STUN packet so don't change its content. */
	} else {
		rtp->timestamp=packet_ts;
1000
		if (rtp_profile_is_telephone_event(session->snd.profile, rtp->paytype)){
1001 1002 1003 1004
			rtp->seq_number = session->rtp.snd_seq;
			session->rtp.snd_seq++;
		}
		else
1005
		{
1006
			session->rtp.snd_seq=rtp->seq_number+1;
1007
		}
1008
		session->rtp.snd_last_ts = packet_ts;
aymeric's avatar
aymeric committed
1009

1010
		stream->sent_payload_bytes+=(uint32_t)(packsize-RTP_FIXED_HEADER_SIZE);
1011

1012
		ortp_global_stats.sent += (1+(int)session->duplication_left) * packsize;
1013
		session->stats.sent += (1+(int)session->duplication_left) * packsize;
1014

1015
		ortp_global_stats.packet_sent++;
1016
		session->stats.packet_sent++;
1017

1018
		session->stats.packet_dup_sent+=(int)session->duplication_left;
1019
		ortp_global_stats.packet_sent+=(int)session->duplication_left;;
1020
	}
aymeric's avatar
aymeric committed
1021

1022
	while (session->duplication_left>=1.f) {
1023
		error = rtp_session_rtp_send (session, copymsg(mp));
1024
		session->duplication_left -= 1.f;
1025
	}
aymeric's avatar
aymeric committed
1026
	error = rtp_session_rtp_send (session, mp);
1027

aymeric's avatar
aymeric committed
1028
	/*send RTCP packet if needed */
1029
	rtp_session_run_rtcp_send_scheduler(session);
aymeric's avatar
aymeric committed
1030 1031 1032 1033 1034 1035 1036
	/* receives rtcp packet if session is send-only*/
	/*otherwise it is done in rtp_session_recvm_with_ts */
	if (session->mode==RTP_SESSION_SENDONLY) rtp_session_rtcp_recv(session);
	return error;
}

/**
1037 1038
 *	Send the rtp datagram \a packet to the destination set by rtp_session_set_remote_addr()
 *	with timestamp \a timestamp. For audio data, the timestamp is the number
aymeric's avatar
aymeric committed
1039
 *	of the first sample resulting of the data transmitted. See rfc1889 for details.
1040
 *  The packet (\a packet) is freed once it is sent.
aymeric's avatar
aymeric committed
1041 1042
 *
 *@param session a rtp session.
1043
 *@param packet a rtp packet presented as a mblk_t.
aymeric's avatar
aymeric committed
1044 1045 1046 1047 1048
 *@param timestamp the timestamp of the data to be sent.
 * @return the number of bytes sent over the network.
**/

int rtp_session_sendm_with_ts(RtpSession *session, mblk_t *packet, uint32_t timestamp){
1049
	return __rtp_session_sendm_with_ts(session,packet,timestamp+session->send_ts_offset,timestamp+session->send_ts_offset);
aymeric's avatar
aymeric committed
1050 1051 1052 1053 1054 1055 1056
}




/**
 *	Send a rtp datagram to the destination set by rtp_session_set_remote_addr() containing
1057
 *	the data from \a buffer with timestamp \a userts. This is a high level function that uses
aymeric's avatar
aymeric committed
1058 1059 1060 1061 1062 1063
 *	rtp_session_create_packet() and rtp_session_sendm_with_ts() to send the data.
 *
 *@param session a rtp session.
 *@param buffer a buffer containing the data to be sent in a rtp packet.
 *@param len the length of the data buffer, in bytes.
 *@param userts	the timestamp of the data to be sent. Refer to the rfc to know what it is.
1064
 *@return the number of bytes sent over the network.
aymeric's avatar
aymeric committed
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
**/
int
rtp_session_send_with_ts (RtpSession * session, const uint8_t * buffer, int len,
			  uint32_t userts)
{
	mblk_t *m;
	int err;
#ifdef USE_SENDMSG
	m=rtp_session_create_packet_with_data(session,(uint8_t*)buffer,len,NULL);
#else
	m = rtp_session_create_packet(session,RTP_FIXED_HEADER_SIZE,(uint8_t*)buffer,len);
#endif
	err=rtp_session_sendm_with_ts(session,m,userts);
	return err;
}


static void payload_type_changed_notify(RtpSession *session, int paytype){
smorlat's avatar
smorlat committed
1083 1084 1085 1086 1087
	PayloadType *pt = rtp_profile_get_payload(session->rcv.profile,paytype);
	if (pt) {
		session->rcv.pt = paytype;
		rtp_signal_table_emit (&session->on_payload_type_changed);
	}
aymeric's avatar
aymeric committed
1088
}
jehan's avatar
jehan committed
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
/**
 *	Try to get an rtp packet presented as a mblk_t structure from the rtp session at a given sequence number.
 *	This function is very usefull for codec with Forward error correction capabilities
 *
 *	This function returns the entire packet (with header).
 *
 *	 *
 * @param session a rtp session.
 * @param sequence_number a sequence number.
 *
 * @return a rtp packet presented as a mblk_t, or NULL if not found.
 **/

mblk_t *
rtp_session_pick_with_cseq (RtpSession * session, const uint16_t sequence_number) {
	queue_t* q= &session->rtp.rq;
	mblk_t* mb;
	for (mb=qbegin(q); !qend(q,mb); mb=qnext(q,mb)){
		if (rtp_get_seqnumber(mb)==sequence_number) {
			return mb;
		}
	}
	return NULL;
}
aymeric's avatar
aymeric committed
1113

1114 1115 1116
static void check_for_seq_number_gap(RtpSession *session, rtp_header_t *rtp) {
	uint16_t pid;
	uint16_t i;
1117 1118
	/*don't check anything before first packet delivered*/
	if (session->flags & RTP_SESSION_FIRST_PACKET_DELIVERED && RTP_SEQ_IS_STRICTLY_GREATER_THAN(rtp->seq_number, session->rtp.rcv_last_seq + 1)) {
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
		uint16_t first_missed_seq = session->rtp.rcv_last_seq + 1;
		uint16_t diff = rtp->seq_number - first_missed_seq;
		pid = first_missed_seq;
		for (i = 0; i <= (diff / 16); i++) {
			uint16_t seq;
			uint16_t blp = 0;
			for (seq = pid + 1; (seq < rtp->seq_number) && ((seq - pid) < 16); seq++) {
				blp |= (1 << (seq - pid - 1));
			}
			rtp_session_send_rtcp_fb_generic_nack(session, pid, blp);
			pid = seq;
		}
	}
}

aymeric's avatar
aymeric committed
1134 1135
/**
 *	Try to get a rtp packet presented as a mblk_t structure from the rtp session.
1136
 *	The \a user_ts parameter is relative to the first timestamp of the incoming stream. In other
aymeric's avatar
aymeric committed
1137
 *	words, the application does not have to know the first timestamp of the stream, it can
1138
 *	simply call for the first time this function with \a user_ts=0, and then incrementing it
aymeric's avatar
aymeric committed
1139 1140 1141 1142 1143
 *	as it want. The RtpSession takes care of synchronisation between the stream timestamp
 *	and the user timestamp given here.
 *
 *	This function returns the entire packet (with header).
 *
1144
 *	The behaviour of this function has changed since version 0.15.0. Previously the payload data could be
aymeric's avatar
aymeric committed
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
 *	accessed using  mblk_t::b_cont::b_rptr field of the returned mblk_t.
 *	This is no more the case.
 *	The convenient way of accessing the payload data is to use rtp_get_payload() :
 *	@code
 *	unsigned char *payload;
 *	int payload_size;
 *	payload_size=rtp_get_payload(mp,&payload);
 *	@endcode
 *	OR simply skip the header this way, the data is then comprised between mp->b_rptr and mp->b_wptr:
 *	@code
 *	rtp_get_payload(mp,&mp->b_rptr);
 *	@endcode
 *
 *
 * @param session a rtp session.
 * @param user_ts a timestamp.
 *
 * @return a rtp packet presented as a mblk_t.
**/

mblk_t *
rtp_session_recvm_with_ts (RtpSession * session, uint32_t user_ts)
{
	mblk_t *mp = NULL;
1169
	rtp_header_t *rtp = NULL;
aymeric's avatar
aymeric committed
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
	uint32_t ts;
	uint32_t packet_time;
	RtpScheduler *sched=session->sched;
	int rejected=0;
	bool_t read_socket=TRUE;

	/* if we are scheduled, remember the scheduler time at which the application has
	 * asked for its first timestamp */

	if (session->flags & RTP_SESSION_RECV_NOT_STARTED)
	{
		session->rtp.rcv_query_ts_offset = user_ts;
		/* Set initial last_rcv_time to first recv time. */
		if ((session->flags & RTP_SESSION_SEND_NOT_STARTED)
1184
		|| session->mode == RTP_SESSION_RECVONLY) {
1185
			ortp_gettimeofday(&session->last_recv_time, NULL);
aymeric's avatar
aymeric committed
1186
		}
1187
		if (session->flags & RTP_SESSION_SCHEDULED) {
aymeric's avatar
aymeric committed
1188 1189 1190 1191 1192
			session->rtp.rcv_time_offset = sched->time_;
			//ortp_message("setting snd_time_offset=%i",session->rtp.snd_time_offset);
		}
		rtp_session_unset_flag (session,RTP_SESSION_RECV_NOT_STARTED);
	}else{
1193
		/*prevent reading from the sockets when two
aymeric's avatar
aymeric committed
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
		consecutives calls for a same timestamp*/
		if (user_ts==session->rtp.rcv_last_app_ts)
			read_socket=FALSE;
	}
	session->rtp.rcv_last_app_ts = user_ts;
	if (read_socket){
		rtp_session_rtp_recv (session, user_ts);
		rtp_session_rtcp_recv(session);
	}
	/* check for telephone event first */
	mp=getq(&session->rtp.tev_rq);
	if (mp!=NULL){
1206
		size_t msgsize=msgdsize(mp);
aymeric's avatar
aymeric committed
1207
		ortp_global_stats.recv += msgsize;
1208
		session->stats.recv += msgsize;
1209
		rtp_signal_table_emit2(&session->on_telephone_event_packet,mp);
aymeric's avatar
aymeric committed
1210 1211 1212 1213
		rtp_session_check_telephone_events(session,mp);
		freemsg(mp);
		mp=NULL;
	}
1214

aymeric's avatar
aymeric committed
1215 1216 1217
	/* then now try to return a media packet, if possible */
	/* first condition: if the session is starting, don't return anything
	 * until the queue size reaches jitt_comp */
1218

aymeric's avatar
aymeric committed
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
	if (session->flags & RTP_SESSION_RECV_SYNC)
	{
		queue_t *q = &session->rtp.rq;
		if (qempty(q))
		{
			ortp_debug ("Queue is empty.");
			goto end;
		}
		rtp = (rtp_header_t *) qfirst(q)->b_rptr;
		session->rtp.rcv_ts_offset = rtp->timestamp;
		session->rtp.rcv_last_ret_ts = user_ts;	/* just to have an init value */
		session->rcv.ssrc = rtp->ssrc;
		/* delete the recv synchronisation flag */
		rtp_session_unset_flag (session, RTP_SESSION_RECV_SYNC);
	}

	/*calculate the stream timestamp from the user timestamp */
	ts = jitter_control_get_compensated_timestamp(&session->rtp.jittctl,user_ts);
1237
	if (session->rtp.jittctl.params.enabled==TRUE){
aymeric's avatar
aymeric committed
1238 1239 1240 1241 1242 1243
		if (session->permissive)
			mp = rtp_getq_permissive(&session->rtp.rq, ts,&rejected);
		else{
			mp = rtp_getq(&session->rtp.rq, ts,&rejected);
		}
	}else mp=getq(&session->rtp.rq);/*no jitter buffer at all*/
1244

1245
	session->stats.outoftime+=rejected;
aymeric's avatar
aymeric committed
1246
	ortp_global_stats.outoftime+=rejected;
1247
	session->rtcp_xr_stats.discarded_count += rejected;
aymeric's avatar
aymeric committed
1248

1249
	end:
aymeric's avatar
aymeric committed
1250 1251
	if (mp != NULL)
	{
1252
		size_t msgsize = msgdsize(mp);	/* evaluate how much bytes (including header) is received by app */
aymeric's avatar
aymeric committed
1253 1254
		uint32_t packet_ts;
		ortp_global_stats.recv += msgsize;
1255
		session->stats.recv += msgsize;
aymeric's avatar
aymeric committed
1256 1257
		rtp = (rtp_header_t *) mp->b_rptr;
		packet_ts=rtp->timestamp;
1258
		ortp_debug("Returning mp with ts=%i", packet_ts);
aymeric's avatar
aymeric committed
1259 1260 1261 1262 1263
		/* check for payload type changes */
		if (session->rcv.pt != rtp->paytype)
		{
			payload_type_changed_notify(session, rtp->paytype);
		}
1264
		check_for_seq_number_gap(session, rtp);
1265
		/* update the packet's timestamp so that it corrected by the
aymeric's avatar
aymeric committed
1266
		adaptive jitter buffer mechanism */
1267
		if (session->rtp.jittctl.params.adaptive){
aymeric's avatar
aymeric committed
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
			uint32_t changed_ts;
			/* only update correction offset between packets of different
			timestamps*/
			if (packet_ts!=session->rtp.rcv_last_ts)
				jitter_control_update_corrective_slide(&session->rtp.jittctl);
			changed_ts=packet_ts+session->rtp.jittctl.corrective_slide;
			rtp->timestamp=changed_ts;
			/*ortp_debug("Returned packet has timestamp %u, with clock slide compensated it is %u",packet_ts,rtp->timestamp);*/
		}
		session->rtp.rcv_last_ts = packet_ts;
1278
		session->rtp.rcv_last_seq = rtp->seq_number;
aymeric's avatar
aymeric committed
1279 1280 1281 1282 1283 1284 1285 1286 1287
		if (!(session->flags & RTP_SESSION_FIRST_PACKET_DELIVERED)){
			rtp_session_set_flag(session,RTP_SESSION_FIRST_PACKET_DELIVERED);
		}
	}
	else
	{
		ortp_debug ("No mp for timestamp queried");
	}
	rtp_session_rtcp_process_recv(session);
1288

aymeric's avatar
aymeric committed
1289 1290 1291 1292 1293 1294
	if (session->flags & RTP_SESSION_SCHEDULED)
	{
		/* if we are in blocking mode, then suspend the calling process until timestamp
		 * wanted expires */
		/* but we must not block the process if the timestamp wanted by the application is older
		 * than current time */
1295
		wait_point_lock(&session->rcv.wp);
aymeric's avatar
aymeric committed
1296 1297
		packet_time =
			rtp_session_ts_to_time (session,
1298 1299
					 user_ts -
					 session->rtp.rcv_query_ts_offset) +
aymeric's avatar
aymeric committed
1300 1301
			session->rtp.rcv_time_offset;
		ortp_debug ("rtp_session_recvm_with_ts: packet_time=%i, time=%i",packet_time, sched->time_);
1302

aymeric's avatar
aymeric committed
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
		if (TIME_IS_STRICTLY_NEWER_THAN (packet_time, sched->time_))
		{
			wait_point_wakeup_at(&session->rcv.wp,packet_time, (session->flags & RTP_SESSION_BLOCKING_MODE)!=0);
			session_set_clr(&sched->r_sessions,session);
		}
		else session_set_set(&sched->r_sessions,session);	/*to unblock _select() immediately */
		wait_point_unlock(&session->rcv.wp);
	}
	return mp;
}


/**
 *	NOTE: use of this function is discouraged when sending payloads other than
 *	pcm/pcmu/pcma/adpcm types.
 *	rtp_session_recvm_with_ts() does better job.
 *
1320
 *	Tries to read the bytes of the incoming rtp stream related to timestamp ts. In case
1321
 *	where the user supplied buffer \a buffer is not large enough to get all the data
aymeric's avatar
aymeric committed
1322 1323
 *	related to timestamp ts, then *( have_more) is set to 1 to indicate that the application
 *	should recall the function with the same timestamp to get more data.
1324 1325
 *
 *  When the rtp session is scheduled (see rtp_session_set_scheduling_mode() ), and the
aymeric's avatar
aymeric committed
1326
 *	blocking mode is on (see rtp_session_set_blocking_mode() ), then the calling thread
1327
 *	is suspended until the timestamp given as argument expires, whatever a received packet
aymeric's avatar
aymeric committed
1328 1329 1330
 *	fits the query or not.
 *
 *	Important note: it is clear that the application cannot know the timestamp of the first
1331
 *	packet of the incoming stream, because it can be random. The \a ts timestamp given to the
aymeric's avatar
aymeric committed
1332 1333 1334 1335 1336
 *	function is used relatively to first timestamp of the stream. In simple words, 0 is a good
 *	value to start calling this function.
 *
 *	This function internally calls rtp_session_recvm_with_ts() to get a rtp packet. The content
 *	of this packet is then copied into the user supplied buffer in an intelligent manner:
1337
 *	the function takes care of the size of the supplied buffer and the timestamp given in
aymeric's avatar
aymeric committed
1338 1339 1340 1341
 *	argument. Using this function it is possible to read continous audio data (e.g. pcma,pcmu...)
 *	with for example a standart buffer of size of 160 with timestamp incrementing by 160 while the incoming
 *	stream has a different packet size.
 *
1342
 *Returns: if a packet was availlable with the corresponding timestamp supplied in argument
aymeric's avatar
aymeric committed
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
 *	then the number of bytes written in the user supplied buffer is returned. If no packets
 *	are availlable, either because the sender has not started to send the stream, or either
 *	because silence packet are not transmitted, or either because the packet was lost during
 *	network transport, then the function returns zero.
 *@param session a rtp session.
 *@param buffer a user supplied buffer to write the data.
 *@param len the length in bytes of the user supplied buffer.
 *@param ts the timestamp wanted.
 *@param have_more the address of an integer to indicate if more data is availlable for the given timestamp.
 *
**/
int rtp_session_recv_with_ts (RtpSession * session, uint8_t * buffer,
1355
				   int len, uint32_t ts, int * have_more){
aymeric's avatar
aymeric committed
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
	mblk_t *mp=NULL;
	int plen,blen=0;
	*have_more=0;
	while(1){
		if (session->pending){
			mp=session->pending;
			session->pending=NULL;
		}else {
			mp=rtp_session_recvm_with_ts(session,ts);
			if (mp!=NULL) rtp_get_payload(mp,&mp->b_rptr);
		}
		if (mp){
1368
			plen=(int)(mp->b_wptr-mp->b_rptr);
aymeric's avatar
aymeric committed
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
			if (plen<=len){
				memcpy(buffer,mp->b_rptr,plen);
				buffer+=plen;
				blen+=plen;
				len-=plen;
				freemsg(mp);
				mp=NULL;
			}else{
				memcpy(buffer,mp->b_rptr,len);
				mp->b_rptr+=len;
				buffer+=len;
				blen+=len;
				len=0;
				session->pending=mp;
				*have_more=1;
				break;
			}
		}else break;
	}
	return blen;
}
/**
 *	When the rtp session is scheduled and has started to send packets, this function
1392
 *	computes the timestamp that matches to the present time. Using this function can be
aymeric's avatar
aymeric committed
1393 1394
 *	usefull when sending discontinuous streams. Some time can be elapsed between the end
 *	of a stream burst and the begin of a new stream burst, and the application may be not
1395
 *	not aware of this elapsed time. In order to get a valid (current) timestamp to pass to
aymeric's avatar
aymeric committed
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
 *	#rtp_session_send_with_ts() or #rtp_session_sendm_with_ts(), the application may
 *	use rtp_session_get_current_send_ts().
 *
 * @param session a rtp session.
 * @return the current send timestamp for the rtp session.
**/
uint32_t rtp_session_get_current_send_ts(RtpSession *session)
{
	uint32_t userts;
	uint32_t session_time;
	RtpScheduler *sched=session->sched;
	PayloadType *payload;
	payload=rtp_profile_get_payload(session->snd.profile,session->snd.pt);
	return_val_if_fail(payload!=NULL, 0);
	if ( (session->flags & RTP_SESSION_SCHEDULED)==0 ){
		ortp_warning("can't guess current timestamp because session is not scheduled.");
		return 0;
	}
	session_time=sched->time_-session->rtp.snd_time_offset;
	userts=  (uint32_t)( ( (double)(session_time) * (double) payload->clock_rate )/ 1000.0)
				+ session->rtp.snd_ts_offset;
	return userts;
}

/**
 * Same thing as rtp_session_get_current_send_ts() except that it's for an incoming stream.
 * Works only on scheduled mode.
 *
 * @param session a rtp session.
 * @return the theoritical that would have to be receive now.
 *
**/
uint32_t rtp_session_get_current_recv_ts(RtpSession *session){
	uint32_t userts;
	uint32_t session_time;
	RtpScheduler *sched=ortp_get_scheduler();
	PayloadType *payload;
	payload=rtp_profile_get_payload(session->rcv.profile,session->rcv.pt);
	return_val_if_fail(payload!=NULL, 0);
	if ( (session->flags & RTP_SESSION_SCHEDULED)==0 ){
		ortp_warning("can't guess current timestamp because session is not scheduled.");
		return 0;
	}
	session_time=sched->time_-session->rtp.rcv_time_offset;
	userts=  (uint32_t)( ( (double)(session_time) * (double) payload->clock_rate )/ 1000.0)
				+ session->rtp.rcv_ts_offset;
	return userts;
}

/**
1446 1447
 * oRTP has the possibility to inform the application through a callback registered
 * with rtp_session_signal_connect about crazy incoming RTP stream that jumps from
aymeric's avatar
aymeric committed
1448 1449 1450 1451
 * a timestamp N to N+some_crazy_value. This lets the opportunity for the application
 * to reset the session in order to resynchronize, or any other action like stopping the call
 * and reporting an error.
 * @param session the rtp session
1452
 * @param milisecs a time interval in miliseconds
aymeric's avatar
aymeric committed
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
 *
**/
void rtp_session_set_time_jump_limit(RtpSession *session, int milisecs){
	uint32_t ts;
	session->rtp.time_jump=milisecs;
	ts=rtp_session_time_to_ts(session,milisecs);
	if (ts==0) session->rtp.ts_jump=1<<31;	/* do not detect ts jump */
	else session->rtp.ts_jump=ts;
}

1463
void _rtp_session_release_sockets(RtpSession *session, bool_t release_transports){
1464

1465 1466 1467
	if (release_transports){
		if (session->rtp.gs.tr) {
			if (session->rtp.gs.tr->t_close)
1468
				session->rtp.gs.tr->t_close(session->rtp.gs.tr);
1469 1470 1471 1472 1473 1474 1475
			session->rtp.gs.tr->t_destroy(session->rtp.gs.tr);

		}
		session->rtp.gs.tr = 0;

		if (session->rtcp.gs.tr)  {
			if (session->rtcp.gs.tr->t_close)
1476
				session->rtcp.gs.tr->t_close(session->rtcp.gs.tr);
1477 1478 1479 1480
			session->rtcp.gs.tr->t_destroy(session->rtcp.gs.tr);
		}
		session->rtcp.gs.tr = 0;
	}
1481

1482 1483 1484 1485
	if (session->rtp.gs.socket!=(ortp_socket_t)-1) close_socket (session->rtp.gs.socket);
	if (session->rtcp.gs.socket!=(ortp_socket_t)-1) close_socket (session->rtcp.gs.socket);
	session->rtp.gs.socket=-1;
	session->rtcp.gs.socket=-1;
1486

aymeric's avatar
aymeric committed
1487
	/* don't discard remote addresses, then can be preserved for next use.
1488 1489
	session->rtp.gs.rem_addrlen=0;
	session->rtcp.gs.rem_addrlen=0;
aymeric's avatar
aymeric committed
1490 1491 1492
	*/
}

1493 1494 1495 1496 1497 1498 1499
/**
 * Closes the rtp and rtcp sockets, and associated RtpTransport.
**/
void rtp_session_release_sockets(RtpSession *session){
	_rtp_session_release_sockets(session, TRUE);
}

aymeric's avatar
aymeric committed
1500
ortp_socket_t rtp_session_get_rtp_socket(const RtpSession *session){
1501
	return rtp_session_using_transport(session, rtp) ? (session->rtp.gs.tr->t_getsocket)(session->rtp.gs.tr) : session->rtp.gs.socket;
aymeric's avatar
aymeric committed
1502 1503 1504
}

ortp_socket_t rtp_session_get_rtcp_socket(const RtpSession *session){
1505
	return rtp_session_using_transport(session, rtcp) ? (session->rtcp.gs.tr->t_getsocket)(session->rtcp.gs.tr) : session->rtcp.gs.socket;
aymeric's avatar
aymeric committed
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
}

/**
 * Register an event queue.
 * An application can use an event queue to get informed about various RTP events.
**/
void rtp_session_register_event_queue(RtpSession *session, OrtpEvQueue *q){
	session->eventqs=o_list_append(session->eventqs,q);
}

void rtp_session_unregister_event_queue(RtpSession *session, OrtpEvQueue *q){
	session->eventqs=o_list_remove(session->eventqs,q);
}

void rtp_session_dispatch_event(RtpSession *session, OrtpEvent *ev){
	OList *it;
	int i;
	for(i=0,it=session->eventqs;it!=NULL;it=it->next,++i){
		ortp_ev_queue_put((OrtpEvQueue*)it->data,ortp_event_dup(ev));
1525
	}
aymeric's avatar
aymeric committed
1526 1527 1528
	ortp_event_destroy(ev);
}

1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
void ortp_stream_clear_aux_addresses(OrtpStream *os){
	OList *elem;
	for (elem=os->aux_destinations;elem!=NULL;elem=elem->next){
		OrtpAddress *addr=(OrtpAddress*)elem->data;
		ortp_free(addr);
	}
	os->aux_destinations=o_list_free(os->aux_destinations);
}

static void ortp_stream_uninit(OrtpStream *os){
1539
	msgb_allocator_uninit(&os->allocator);
1540 1541
	ortp_stream_clear_aux_addresses(os);
}
aymeric's avatar
aymeric committed
1542 1543 1544

void rtp_session_uninit (RtpSession * session)
{
1545 1546
	RtpTransport *rtp_meta_transport = NULL;
	RtpTransport *rtcp_meta_transport = NULL;
aymeric's avatar
aymeric committed
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
	/* first of all remove the session from the scheduler */
	if (session->flags & RTP_SESSION_SCHEDULED)
	{
		rtp_scheduler_remove_session (session->sched,session);
	}
	/*flush all queues */
	flushq(&session->rtp.rq, FLUSHALL);
	flushq(&session->rtp.tev_rq, FLUSHALL);

	if (session->eventqs!=NULL) o_list_free(session->eventqs);
	/* close sockets */
	rtp_session_release_sockets(session);

	wait_point_uninit(&session->snd.wp);
	wait_point_uninit(&session->rcv.wp);
	if (session->current_tev!=NULL) freemsg(session->current_tev);
1563 1564
	ortp_stream_uninit(&session->rtp.gs);
	ortp_stream_uninit(&session->rtcp.gs);
1565 1566 1567 1568
	if (session->full_sdes != NULL)
		freemsg(session->full_sdes);
	if (session->minimal_sdes != NULL)
		freemsg(session->minimal_sdes);
1569
	bctbx_list_free_with_data(session->recv_addr_map, (bctbx_list_free_func)bctbx_free);
aymeric's avatar
aymeric committed
1570 1571

	session->signal_tables = o_list_free(session->signal_tables);
1572

1573 1574
	if (session->net_sim_ctx)
		ortp_network_simulator_destroy(session->net_sim_ctx);
1575 1576 1577 1578
	
	if (session->rtp.congdetect){
		ortp_congestion_detector_destroy(session->rtp.congdetect);
	}
1579

1580 1581 1582 1583 1584 1585
	rtp_session_get_transports(session,&rtp_meta_transport,&rtcp_meta_transport);
	if (rtp_meta_transport)
		meta_rtp_transport_destroy(rtp_meta_transport);
	if (rtcp_meta_transport)
		meta_rtp_transport_destroy(rtcp_meta_transport);

1586
#if (_WIN32_WINNT >= 0x0600) && defined(ORTP_WINDOWS_DESKTOP)
Simon Morlat's avatar
Simon Morlat committed
1587
	if (session->rtp.QoSFlowID != 0)
1588
	{
1589 1590
		ortp_message("check OS support for qwave.lib");
		if (IsWindowsVistaOrGreater()) {
1591
			BOOL QoSResult;
1592
			QoSResult = QOSRemoveSocketFromFlow(session->rtp.QoSHandle, 0, session->rtp.QoSFlowID, 0);
1593
			if (QoSResult != TRUE){
1594
				ortp_error("QOSRemoveSocketFromFlow failed to end a flow with error %d", GetLastError());
Simon Morlat's avatar
Simon Morlat committed
1595
			}
1596
			session->rtp.QoSFlowID = 0;
Simon Morlat's avatar
Simon Morlat committed
1597
		}
1598
	}
Simon Morlat's avatar
Simon Morlat committed
1599

1600 1601 1602
	if (session->rtp.QoSHandle != NULL)
	{
		QOSCloseHandle(session->rtp.QoSHandle);
Simon Morlat's avatar
Simon Morlat committed
1603
		session->rtp.QoSHandle=NULL;
1604
	}
1605
#endif
aymeric's avatar
aymeric committed
1606 1607
}

1608
/**
1609
 * Sets the number of packets containing a new SSRC that will trigger the
1610 1611 1612 1613 1614 1615
 * "ssrc_changed" callback.
**/
void rtp_session_set_ssrc_changed_threshold(RtpSession *session, int numpackets){
	session->rtp.ssrc_changed_thres=numpackets;
}

aymeric's avatar
aymeric committed
1616 1617
/**
 * Resynchronize to the incoming RTP streams.
1618
 * This can be useful to handle discontinuous timestamps.
aymeric's avatar
aymeric committed
1619 1620 1621 1622 1623 1624 1625
 * For example, call this function from the timestamp_jump signal handler.
 * @param session the rtp session
**/
void rtp_session_resync(RtpSession *session){
	flushq (&session->rtp.rq, FLUSHALL);
	rtp_session_set_flag(session, RTP_SESSION_RECV_SYNC);
	rtp_session_unset_flag(session,RTP_SESSION_FIRST_PACKET_DELIVERED);
1626 1627
	rtp_session_init_jitter_buffer(session);
	if (session->rtp.congdetect) ortp_congestion_detector_reset(session->rtp.congdetect);
1628

1629
	/* Since multiple streams might share the same session (fixed RTCP port for example),
1630 1631 1632
	RTCP values might be erroneous (number of packets received is computed
	over all streams, ...). There should be only one stream per RTP session*/
	session->rtp.hwrcv_extseq = 0;
1633 1634 1635
	session->rtp.hwrcv_since_last_SR = 0;
	session->rtp.hwrcv_seq_at_last_SR = 0;
	rtp_session_unset_flag(session, RTP_SESSION_RECV_SEQ_INIT);