1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
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
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
/* $Id$ */
/*
* Copyright (C) 2003-2006 Benny Prijono <benny@prijono.org>
*
* 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
*/
#include <pjmedia/rtp.h>
#include <pj/log.h>
#include <pj/os.h> /* pj_gettimeofday() */
#include <pj/sock.h> /* pj_htonx, pj_htonx */
#include <string.h> /* memset() */
#define THIS_FILE "rtp.c"
#define RTP_VERSION 2
#define RTP_SEQ_MOD (1 << 16)
#define MAX_DROPOUT ((pj_int16_t)3000)
#define MAX_MISORDER ((pj_int16_t)100)
#define MIN_SEQUENTIAL ((pj_int16_t)2)
PJ_DEF(pj_status_t) pj_rtp_session_init( pj_rtp_session *ses,
int default_pt, pj_uint32_t sender_ssrc )
{
PJ_LOG(4, (THIS_FILE, "pj_rtp_session_init: ses=%p, default_pt=%d, ssrc=0x%x",
ses, default_pt, sender_ssrc));
/* Check RTP header packing. */
if (sizeof(struct pj_rtp_hdr) != 12) {
pj_assert(!"Wrong RTP header packing!");
return PJ_RTP_ERR_RTP_PACKING;
}
/* If sender_ssrc is not specified, create from time value. */
if (sender_ssrc == 0 || sender_ssrc == (pj_uint32_t)-1) {
pj_time_val tv;
pj_gettimeofday(&tv);
sender_ssrc = (pj_uint32_t) pj_htonl(tv.sec);
} else {
sender_ssrc = pj_htonl(sender_ssrc);
}
/* Initialize session. */
ses->out_extseq = 0;
ses->peer_ssrc = 0;
/* Sequence number will be initialized when the first RTP packet is receieved. */
/* Build default header for outgoing RTP packet. */
memset(ses, 0, sizeof(*ses));
ses->out_hdr.v = RTP_VERSION;
ses->out_hdr.p = 0;
ses->out_hdr.x = 0;
ses->out_hdr.cc = 0;
ses->out_hdr.m = 0;
ses->out_hdr.pt = (pj_uint8_t) default_pt;
ses->out_hdr.seq = (pj_uint16_t) pj_htons( (pj_uint16_t)ses->out_extseq );
ses->out_hdr.ts = 0;
ses->out_hdr.ssrc = sender_ssrc;
/* Keep some arguments as session defaults. */
ses->out_pt = (pj_uint16_t) default_pt;
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_rtp_encode_rtp( pj_rtp_session *ses, int pt, int m,
int payload_len, int ts_len,
const void **rtphdr, int *hdrlen )
{
PJ_UNUSED_ARG(payload_len)
PJ_LOG(6, (THIS_FILE,
"pj_rtp_encode_rtp: ses=%p, pt=%d, m=%d, pt_len=%d, ts_len=%d",
ses, pt, m, payload_len, ts_len));
/* Update session. */
ses->out_extseq++;
ses->out_hdr.ts = pj_htonl(pj_ntohl(ses->out_hdr.ts)+ts_len);
/* Create outgoing header. */
ses->out_hdr.pt = (pj_uint8_t) ((pt == -1) ? ses->out_pt : pt);
ses->out_hdr.m = (pj_uint16_t) m;
ses->out_hdr.seq = pj_htons( (pj_uint16_t) ses->out_extseq);
/* Return values */
*rtphdr = &ses->out_hdr;
*hdrlen = sizeof(pj_rtp_hdr);
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_rtp_decode_rtp( pj_rtp_session *ses,
const void *pkt, int pkt_len,
const pj_rtp_hdr **hdr,
const void **payload,
unsigned *payloadlen)
{
int offset;
PJ_UNUSED_ARG(ses)
PJ_LOG(6, (THIS_FILE,
"pj_rtp_decode_rtp: ses=%p, pkt=%p, pkt_len=%d",
ses, pkt, pkt_len));
/* Assume RTP header at the start of packet. We'll verify this later. */
*hdr = (pj_rtp_hdr*)pkt;
/* Check RTP header sanity. */
if ((*hdr)->v != RTP_VERSION) {
PJ_LOG(4, (THIS_FILE, " invalid RTP version!"));
return PJ_RTP_ERR_INVALID_VERSION;
}
/* Payload is located right after header plus CSRC */
offset = sizeof(pj_rtp_hdr) + ((*hdr)->cc * sizeof(pj_uint32_t));
/* Adjust offset if RTP extension is used. */
if ((*hdr)->x) {
pj_rtp_ext_hdr *ext = (pj_rtp_ext_hdr*) (((pj_uint8_t*)pkt) + offset);
offset += (pj_ntohs(ext->length) * sizeof(pj_uint32_t));
}
/* Check that offset is less than packet size */
if (offset >= pkt_len)
return PJ_RTP_ERR_INVALID_PACKET;
/* Find and set payload. */
*payload = ((pj_uint8_t*)pkt) + offset;
*payloadlen = pkt_len - offset;
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_rtp_session_update( pj_rtp_session *ses, const pj_rtp_hdr *hdr)
{
int status;
/* Check SSRC. */
if (ses->peer_ssrc == 0) ses->peer_ssrc = pj_ntohl(hdr->ssrc);
/*
if (pj_ntohl(ses->peer_ssrc) != hdr->ssrc) {
PJ_LOG(4, (THIS_FILE, "pj_rtp_session_update: ses=%p, invalid ssrc 0x%p (!=0x%p)",
ses, pj_ntohl(hdr->ssrc), ses->peer_ssrc));
return PJ_RTP_ERR_INVALID_SSRC;
}
*/
/* Check payload type. */
if (hdr->pt != ses->out_pt) {
PJ_LOG(4, (THIS_FILE, "pj_rtp_session_update: ses=%p, invalid payload type %d (!=%d)",
ses, hdr->pt, ses->out_pt));
return PJ_RTP_ERR_INVALID_PT;
}
/* Initialize sequence number on first packet received. */
if (ses->received == 0)
pj_rtp_seq_init( &ses->seq_ctrl, pj_ntohs(hdr->seq) );
/* Check sequence number to see if remote session has been restarted. */
status = pj_rtp_seq_update( &ses->seq_ctrl, pj_ntohs(hdr->seq));
if (status == PJ_RTP_ERR_SESSION_RESTARTED) {
pj_rtp_seq_restart( &ses->seq_ctrl, pj_ntohs(hdr->seq));
++ses->received;
} else if (status == 0 || status == PJ_RTP_ERR_SESSION_PROBATION) {
++ses->received;
}
return status;
}
void pj_rtp_seq_restart(pj_rtp_seq_session *sctrl, pj_uint16_t seq)
{
sctrl->base_seq = seq;
sctrl->max_seq = seq;
sctrl->bad_seq = RTP_SEQ_MOD + 1;
sctrl->cycles = 0;
}
void pj_rtp_seq_init(pj_rtp_seq_session *sctrl, pj_uint16_t seq)
{
pj_rtp_seq_restart(sctrl, seq);
sctrl->max_seq = (pj_uint16_t) (seq - 1);
sctrl->probation = MIN_SEQUENTIAL;
}
int pj_rtp_seq_update(pj_rtp_seq_session *sctrl, pj_uint16_t seq)
{
pj_uint16_t udelta = (pj_uint16_t) (seq - sctrl->max_seq);
/*
* Source is not valid until MIN_SEQUENTIAL packets with
* sequential sequence numbers have been received.
*/
if (sctrl->probation) {
/* packet is in sequence */
if (seq == sctrl->max_seq+ 1) {
sctrl->probation--;
sctrl->max_seq = seq;
if (sctrl->probation == 0) {
return PJ_RTP_ERR_SESSION_RESTARTED;
}
} else {
sctrl->probation = MIN_SEQUENTIAL - 1;
sctrl->max_seq = seq;
}
return PJ_RTP_ERR_SESSION_PROBATION;
} else if (udelta < MAX_DROPOUT) {
/* in order, with permissible gap */
if (seq < sctrl->max_seq) {
/* Sequence number wrapped - count another 64K cycle. */
sctrl->cycles += RTP_SEQ_MOD;
}
sctrl->max_seq = seq;
} else if (udelta <= (RTP_SEQ_MOD - MAX_MISORDER)) {
/* the sequence number made a very large jump */
if (seq == sctrl->bad_seq) {
/*
* Two sequential packets -- assume that the other side
* restarted without telling us so just re-sync
* (i.e., pretend this was the first packet).
*/
return PJ_RTP_ERR_SESSION_RESTARTED;
}
else {
sctrl->bad_seq = (seq + 1) & (RTP_SEQ_MOD-1);
return PJ_RTP_ERR_BAD_SEQUENCE;
}
} else {
/* duplicate or reordered packet */
}
return 0;
}
|
