Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtp.c @ 7e1720de

History | View | Annotate | Download (37.8 KB)

1 e309128f Fabrice Bellard
/*
2
 * RTP input/output format
3
 * Copyright (c) 2002 Fabrice Bellard.
4
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 e309128f Fabrice Bellard
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 e309128f Fabrice Bellard
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 e309128f Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 e309128f Fabrice Bellard
 */
21
#include "avformat.h"
22 8b1ab7bf Fabrice Bellard
#include "mpegts.h"
23 d1ccf0e0 Romain Degez
#include "bitstream.h"
24 e309128f Fabrice Bellard
25
#include <unistd.h>
26 42572ef5 Ramiro Polla
#include "network.h"
27 e309128f Fabrice Bellard
28 4934884a Ryan Martell
#include "rtp_internal.h"
29 1d1be919 Ryan Martell
#include "rtp_h264.h"
30 98561024 Luca Abeni
#include "rtp_mpv.h"
31 171dce48 Luca Abeni
#include "rtp_aac.h"
32 4934884a Ryan Martell
33 e309128f Fabrice Bellard
//#define DEBUG
34
35 0aa7a2e6 Luca Abeni
#define RTCP_SR_SIZE 28
36 e309128f Fabrice Bellard
37
/* TODO: - add RTCP statistics reporting (should be optional).
38

39
         - add support for h263/mpeg4 packetized output : IDEA: send a
40
         buffer to 'rtp_write_packet' contains all the packets for ONE
41
         frame. Each packet should have a four byte header containing
42
         the length in big endian format (same trick as
43 115329f1 Diego Biurrun
         'url_open_dyn_packet_buf')
44 e309128f Fabrice Bellard
*/
45
46 d1ccf0e0 Romain Degez
/* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
47
AVRtpPayloadType_t AVRtpPayloadTypes[]=
48
{
49
  {0, "PCMU",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_MULAW, 8000, 1},
50
  {1, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
51
  {2, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
52
  {3, "GSM",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
53
  {4, "G723",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
54
  {5, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
55
  {6, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 16000, 1},
56
  {7, "LPC",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
57
  {8, "PCMA",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_ALAW, 8000, 1},
58
  {9, "G722",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
59
  {10, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 2},
60
  {11, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 1},
61 6c496518 Benjamin Larsson
  {12, "QCELP",      CODEC_TYPE_AUDIO,   CODEC_ID_QCELP, 8000, 1},
62 d1ccf0e0 Romain Degez
  {13, "CN",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
63
  {14, "MPA",        CODEC_TYPE_AUDIO,   CODEC_ID_MP2, 90000, -1},
64
  {15, "G728",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
65
  {16, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 11025, 1},
66
  {17, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 22050, 1},
67
  {18, "G729",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
68
  {19, "reserved",   CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
69
  {20, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
70
  {21, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
71
  {22, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
72
  {23, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
73
  {24, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
74
  {25, "CelB",       CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
75
  {26, "JPEG",       CODEC_TYPE_VIDEO,   CODEC_ID_MJPEG, 90000, -1},
76
  {27, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
77
  {28, "nv",         CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
78
  {29, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
79
  {30, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
80
  {31, "H261",       CODEC_TYPE_VIDEO,   CODEC_ID_H261, 90000, -1},
81
  {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG1VIDEO, 90000, -1},
82 db628029 Luca Abeni
  {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG2VIDEO, 90000, -1},
83 d1ccf0e0 Romain Degez
  {33, "MP2T",       CODEC_TYPE_DATA,    CODEC_ID_MPEG2TS, 90000, -1},
84
  {34, "H263",       CODEC_TYPE_VIDEO,   CODEC_ID_H263, 90000, -1},
85
  {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
86
  {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
87
  {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
88
  {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
89
  {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
90
  {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
91
  {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
92
  {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
93
  {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
94
  {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
95
  {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
96
  {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
97
  {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
98
  {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
99
  {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
100
  {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
101
  {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
102
  {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
103
  {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
104
  {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
105
  {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
106
  {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
107
  {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
108
  {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
109
  {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
110
  {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
111
  {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
112
  {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
113
  {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
114
  {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
115
  {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
116
  {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
117
  {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
118
  {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
119
  {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
120
  {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
121
  {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
122
  {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
123
  {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
124
  {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
125
  {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
126
  {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
127
  {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
128
  {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
129
  {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
130
  {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
131
  {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
132
  {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
133
  {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
134
  {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
135
  {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
136
  {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
137
  {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
138
  {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
139
  {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
140
  {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
141
  {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
142
  {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
143
  {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
144
  {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
145
  {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
146
  {96, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
147
  {97, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
148
  {98, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
149
  {99, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
150
  {100, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
151
  {101, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
152
  {102, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
153
  {103, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
154
  {104, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
155
  {105, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
156
  {106, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
157
  {107, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
158
  {108, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
159
  {109, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
160
  {110, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
161
  {111, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
162
  {112, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
163
  {113, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
164
  {114, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
165
  {115, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
166
  {116, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
167
  {117, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
168
  {118, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
169
  {119, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
170
  {120, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
171
  {121, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
172
  {122, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
173
  {123, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
174
  {124, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
175
  {125, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
176
  {126, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
177
  {127, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
178
  {-1, "",           CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
179
};
180
181 4934884a Ryan Martell
/* statistics functions */
182
RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
183
184
static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
185 cbee7a69 Baptiste Coudurier
static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
186 4934884a Ryan Martell
187
static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
188 d1ccf0e0 Romain Degez
{
189 4934884a Ryan Martell
    handler->next= RTPFirstDynamicPayloadHandler;
190
    RTPFirstDynamicPayloadHandler= handler;
191
}
192 e309128f Fabrice Bellard
193 2b100ab2 Stefan Huehner
void av_register_rtp_dynamic_payload_handlers(void)
194 4934884a Ryan Martell
{
195
    register_dynamic_payload_handler(&mp4v_es_handler);
196
    register_dynamic_payload_handler(&mpeg4_generic_handler);
197
    register_dynamic_payload_handler(&ff_h264_dynamic_handler);
198
}
199 e309128f Fabrice Bellard
200
int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
201
{
202 7ed19d7f Luca Abeni
    int i = 0;
203
204
    for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
205
        if (AVRtpPayloadTypes[i].pt == payload_type) {
206
            if (AVRtpPayloadTypes[i].codec_id != CODEC_ID_NONE) {
207
                codec->codec_type = AVRtpPayloadTypes[i].codec_type;
208
                codec->codec_id = AVRtpPayloadTypes[i].codec_id;
209
                if (AVRtpPayloadTypes[i].audio_channels > 0)
210
                    codec->channels = AVRtpPayloadTypes[i].audio_channels;
211
                if (AVRtpPayloadTypes[i].clock_rate > 0)
212
                    codec->sample_rate = AVRtpPayloadTypes[i].clock_rate;
213
                return 0;
214
            }
215
        }
216 d1ccf0e0 Romain Degez
    return -1;
217 e309128f Fabrice Bellard
}
218
219
int rtp_get_payload_type(AVCodecContext *codec)
220
{
221 d1ccf0e0 Romain Degez
    int i, payload_type;
222 e309128f Fabrice Bellard
223
    /* compute the payload type */
224 d1ccf0e0 Romain Degez
    for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
225
        if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
226
            if (codec->codec_id == CODEC_ID_PCM_S16BE)
227
                if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
228
                    continue;
229
            payload_type = AVRtpPayloadTypes[i].pt;
230 e309128f Fabrice Bellard
        }
231
    return payload_type;
232
}
233
234 7ed19d7f Luca Abeni
const char *ff_rtp_enc_name(int payload_type)
235
{
236
    int i;
237
238
    for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
239
        if (AVRtpPayloadTypes[i].pt == payload_type) {
240
            return AVRtpPayloadTypes[i].enc_name;
241
        }
242
243
    return "";
244
}
245
246
enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type)
247
{
248
    int i;
249
250
    for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
251
        if (!strcmp(buf, AVRtpPayloadTypes[i].enc_name) && (codec_type == AVRtpPayloadTypes[i].codec_type)){
252
            return AVRtpPayloadTypes[i].codec_id;
253
        }
254
255
    return CODEC_ID_NONE;
256
}
257
258 8b1ab7bf Fabrice Bellard
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
259 e309128f Fabrice Bellard
{
260
    if (buf[1] != 200)
261
        return -1;
262 48961970 Ronald S. Bultje
    s->last_rtcp_ntp_time = AV_RB64(buf + 8);
263 e5526b2c Fabrice Bellard
    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
264
        s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
265 48961970 Ronald S. Bultje
    s->last_rtcp_timestamp = AV_RB32(buf + 16);
266 e309128f Fabrice Bellard
    return 0;
267
}
268
269 4a6cc061 Ryan Martell
#define RTP_SEQ_MOD (1<<16)
270
271
/**
272
* called on parse open packet
273
*/
274
static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
275
{
276
    memset(s, 0, sizeof(RTPStatistics));
277
    s->max_seq= base_sequence;
278
    s->probation= 1;
279
}
280
281
/**
282
* called whenever there is a large jump in sequence numbers, or when they get out of probation...
283
*/
284
static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
285
{
286
    s->max_seq= seq;
287
    s->cycles= 0;
288
    s->base_seq= seq -1;
289
    s->bad_seq= RTP_SEQ_MOD + 1;
290
    s->received= 0;
291
    s->expected_prior= 0;
292
    s->received_prior= 0;
293
    s->jitter= 0;
294
    s->transit= 0;
295
}
296
297
/**
298
* returns 1 if we should handle this packet.
299
*/
300
static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
301
{
302
    uint16_t udelta= seq - s->max_seq;
303
    const int MAX_DROPOUT= 3000;
304
    const int MAX_MISORDER = 100;
305
    const int MIN_SEQUENTIAL = 2;
306
307
    /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
308
    if(s->probation)
309
    {
310
        if(seq==s->max_seq + 1) {
311
            s->probation--;
312
            s->max_seq= seq;
313
            if(s->probation==0) {
314
                rtp_init_sequence(s, seq);
315
                s->received++;
316
                return 1;
317
            }
318
        } else {
319
            s->probation= MIN_SEQUENTIAL - 1;
320
            s->max_seq = seq;
321
        }
322
    } else if (udelta < MAX_DROPOUT) {
323
        // in order, with permissible gap
324
        if(seq < s->max_seq) {
325
            //sequence number wrapped; count antother 64k cycles
326
            s->cycles += RTP_SEQ_MOD;
327
        }
328
        s->max_seq= seq;
329
    } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
330
        // sequence made a large jump...
331
        if(seq==s->bad_seq) {
332
            // two sequential packets-- assume that the other side restarted without telling us; just resync.
333
            rtp_init_sequence(s, seq);
334
        } else {
335
            s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
336
            return 0;
337
        }
338
    } else {
339
        // duplicate or reordered packet...
340
    }
341
    s->received++;
342
    return 1;
343
}
344
345
#if 0
346
/**
347
* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
348
* difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
349
* never change.  I left this in in case someone else can see a way. (rdm)
350
*/
351
static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
352
{
353
    uint32_t transit= arrival_timestamp - sent_timestamp;
354
    int d;
355
    s->transit= transit;
356
    d= FFABS(transit - s->transit);
357
    s->jitter += d - ((s->jitter + 8)>>4);
358
}
359
#endif
360
361 dbf30963 Thijs
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
362
{
363 899681cd Björn Axelsson
    ByteIOContext *pb;
364 dbf30963 Thijs
    uint8_t *buf;
365
    int len;
366
    int rtcp_bytes;
367 4a6cc061 Ryan Martell
    RTPStatistics *stats= &s->statistics;
368
    uint32_t lost;
369
    uint32_t extended_max;
370
    uint32_t expected_interval;
371
    uint32_t received_interval;
372
    uint32_t lost_interval;
373
    uint32_t expected;
374
    uint32_t fraction;
375
    uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
376 dbf30963 Thijs
377
    if (!s->rtp_ctx || (count < 1))
378
        return -1;
379
380 4a6cc061 Ryan Martell
    /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
381 dbf30963 Thijs
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
382
    s->octet_count += count;
383
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
384
        RTCP_TX_RATIO_DEN;
385
    rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
386
    if (rtcp_bytes < 28)
387
        return -1;
388
    s->last_octet_count = s->octet_count;
389
390
    if (url_open_dyn_buf(&pb) < 0)
391
        return -1;
392
393
    // Receiver Report
394 899681cd Björn Axelsson
    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
395
    put_byte(pb, 201);
396
    put_be16(pb, 7); /* length in words - 1 */
397
    put_be32(pb, s->ssrc); // our own SSRC
398
    put_be32(pb, s->ssrc); // XXX: should be the server's here!
399 dbf30963 Thijs
    // some placeholders we should really fill...
400 4a6cc061 Ryan Martell
    // RFC 1889/p64
401
    extended_max= stats->cycles + stats->max_seq;
402
    expected= extended_max - stats->base_seq + 1;
403
    lost= expected - stats->received;
404
    lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
405
    expected_interval= expected - stats->expected_prior;
406
    stats->expected_prior= expected;
407
    received_interval= stats->received - stats->received_prior;
408
    stats->received_prior= stats->received;
409
    lost_interval= expected_interval - received_interval;
410
    if (expected_interval==0 || lost_interval<=0) fraction= 0;
411
    else fraction = (lost_interval<<8)/expected_interval;
412
413
    fraction= (fraction<<24) | lost;
414
415 899681cd Björn Axelsson
    put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
416
    put_be32(pb, extended_max); /* max sequence received */
417
    put_be32(pb, stats->jitter>>4); /* jitter */
418 4a6cc061 Ryan Martell
419
    if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
420
    {
421 899681cd Björn Axelsson
        put_be32(pb, 0); /* last SR timestamp */
422
        put_be32(pb, 0); /* delay since last SR */
423 4a6cc061 Ryan Martell
    } else {
424
        uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
425
        uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
426
427 899681cd Björn Axelsson
        put_be32(pb, middle_32_bits); /* last SR timestamp */
428
        put_be32(pb, delay_since_last); /* delay since last SR */
429 4a6cc061 Ryan Martell
    }
430 dbf30963 Thijs
431
    // CNAME
432 899681cd Björn Axelsson
    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
433
    put_byte(pb, 202);
434 dbf30963 Thijs
    len = strlen(s->hostname);
435 899681cd Björn Axelsson
    put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
436
    put_be32(pb, s->ssrc);
437
    put_byte(pb, 0x01);
438
    put_byte(pb, len);
439
    put_buffer(pb, s->hostname, len);
440 dbf30963 Thijs
    // padding
441
    for (len = (6 + len) % 4; len % 4; len++) {
442 899681cd Björn Axelsson
        put_byte(pb, 0);
443 dbf30963 Thijs
    }
444
445 899681cd Björn Axelsson
    put_flush_packet(pb);
446
    len = url_close_dyn_buf(pb, &buf);
447 dbf30963 Thijs
    if ((len > 0) && buf) {
448 4a6cc061 Ryan Martell
        int result;
449 dbf30963 Thijs
#if defined(DEBUG)
450
        printf("sending %d bytes of RR\n", len);
451
#endif
452 4a6cc061 Ryan Martell
        result= url_write(s->rtp_ctx, buf, len);
453
#if defined(DEBUG)
454
        printf("result from url_write: %d\n", result);
455
#endif
456 dbf30963 Thijs
        av_free(buf);
457
    }
458
    return 0;
459
}
460
461
/**
462 8b1ab7bf Fabrice Bellard
 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
463
 * MPEG2TS streams to indicate that they should be demuxed inside the
464 115329f1 Diego Biurrun
 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
465 d0deedcb Ryan Martell
 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
466 8b1ab7bf Fabrice Bellard
 */
467 dbf30963 Thijs
RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
468 8b1ab7bf Fabrice Bellard
{
469
    RTPDemuxContext *s;
470
471
    s = av_mallocz(sizeof(RTPDemuxContext));
472
    if (!s)
473
        return NULL;
474
    s->payload_type = payload_type;
475
    s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
476
    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
477
    s->ic = s1;
478
    s->st = st;
479 d1ccf0e0 Romain Degez
    s->rtp_payload_data = rtp_payload_data;
480 4a6cc061 Ryan Martell
    rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
481 7ed19d7f Luca Abeni
    if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
482 8b1ab7bf Fabrice Bellard
        s->ts = mpegts_parse_open(s->ic);
483
        if (s->ts == NULL) {
484
            av_free(s);
485
            return NULL;
486
        }
487 ccd39ae6 Fabrice Bellard
    } else {
488 01f4895c Michael Niedermayer
        switch(st->codec->codec_id) {
489 ccd39ae6 Fabrice Bellard
        case CODEC_ID_MPEG1VIDEO:
490
        case CODEC_ID_MPEG2VIDEO:
491
        case CODEC_ID_MP2:
492
        case CODEC_ID_MP3:
493
        case CODEC_ID_MPEG4:
494 4934884a Ryan Martell
        case CODEC_ID_H264:
495 57004ff1 Aurelien Jacobs
            st->need_parsing = AVSTREAM_PARSE_FULL;
496 ccd39ae6 Fabrice Bellard
            break;
497
        default:
498
            break;
499
        }
500 8b1ab7bf Fabrice Bellard
    }
501 dbf30963 Thijs
    // needed to send back RTCP RR in RTSP sessions
502
    s->rtp_ctx = rtpc;
503
    gethostname(s->hostname, sizeof(s->hostname));
504 8b1ab7bf Fabrice Bellard
    return s;
505
}
506
507 d1ccf0e0 Romain Degez
static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
508
{
509
    int au_headers_length, au_header_size, i;
510
    GetBitContext getbitcontext;
511
    rtp_payload_data_t *infos;
512
513
    infos = s->rtp_payload_data;
514
515
    if (infos == NULL)
516
        return -1;
517
518
    /* decode the first 2 bytes where are stored the AUHeader sections
519
       length in bits */
520 fead30d4 Alex Beregszaszi
    au_headers_length = AV_RB16(buf);
521 d1ccf0e0 Romain Degez
522
    if (au_headers_length > RTP_MAX_PACKET_LENGTH)
523
      return -1;
524
525
    infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
526
527
    /* skip AU headers length section (2 bytes) */
528
    buf += 2;
529
530
    init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
531
532
    /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
533
    au_header_size = infos->sizelength + infos->indexlength;
534
    if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
535
        return -1;
536
537
    infos->nb_au_headers = au_headers_length / au_header_size;
538
    infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
539
540
    /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
541 755bfeab Diego Biurrun
       In my test, the FAAD decoder does not behave correctly when sending each AU one by one
542 d1ccf0e0 Romain Degez
       but does when sending the whole as one big packet...  */
543
    infos->au_headers[0].size = 0;
544
    infos->au_headers[0].index = 0;
545
    for (i = 0; i < infos->nb_au_headers; ++i) {
546
        infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
547
        infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
548
    }
549
550
    infos->nb_au_headers = 1;
551
552
    return 0;
553
}
554
555 8b1ab7bf Fabrice Bellard
/**
556 d0deedcb Ryan Martell
 * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
557
 */
558
static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
559
{
560
    switch(s->st->codec->codec_id) {
561
        case CODEC_ID_MP2:
562
        case CODEC_ID_MPEG1VIDEO:
563 db628029 Luca Abeni
        case CODEC_ID_MPEG2VIDEO:
564 d0deedcb Ryan Martell
            if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
565
                int64_t addend;
566
567
                int delta_timestamp;
568
                /* XXX: is it really necessary to unify the timestamp base ? */
569
                /* compute pts from timestamp with received ntp_time */
570
                delta_timestamp = timestamp - s->last_rtcp_timestamp;
571
                /* convert to 90 kHz without overflow */
572
                addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
573
                addend = (addend * 5625) >> 14;
574
                pkt->pts = addend + delta_timestamp;
575
            }
576
            break;
577 cbee7a69 Baptiste Coudurier
        case CODEC_ID_AAC:
578 d0deedcb Ryan Martell
        case CODEC_ID_H264:
579
        case CODEC_ID_MPEG4:
580
            pkt->pts = timestamp;
581
            break;
582
        default:
583
            /* no timestamp info yet */
584
            break;
585
    }
586
    pkt->stream_index = s->st->index;
587
}
588
589
/**
590 115329f1 Diego Biurrun
 * Parse an RTP or RTCP packet directly sent as a buffer.
591 8b1ab7bf Fabrice Bellard
 * @param s RTP parse context.
592 e309128f Fabrice Bellard
 * @param pkt returned packet
593 8b1ab7bf Fabrice Bellard
 * @param buf input buffer or NULL to read the next packets
594 e309128f Fabrice Bellard
 * @param len buffer len
595 115329f1 Diego Biurrun
 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
596 8b1ab7bf Fabrice Bellard
 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
597 e309128f Fabrice Bellard
 */
598 115329f1 Diego Biurrun
int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
599 8b1ab7bf Fabrice Bellard
                     const uint8_t *buf, int len)
600 e309128f Fabrice Bellard
{
601
    unsigned int ssrc, h;
602 d0deedcb Ryan Martell
    int payload_type, seq, ret;
603 e309128f Fabrice Bellard
    AVStream *st;
604 0c1a9eda Zdenek Kabelac
    uint32_t timestamp;
605 d0deedcb Ryan Martell
    int rv= 0;
606 115329f1 Diego Biurrun
607 8b1ab7bf Fabrice Bellard
    if (!buf) {
608
        /* return the next packets, if any */
609 4934884a Ryan Martell
        if(s->st && s->parse_packet) {
610 d0deedcb Ryan Martell
            timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
611
            rv= s->parse_packet(s, pkt, &timestamp, NULL, 0);
612
            finalize_packet(s, pkt, timestamp);
613
            return rv;
614 4934884a Ryan Martell
        } else {
615 d0deedcb Ryan Martell
            // TODO: Move to a dynamic packet handler (like above)
616 ed787542 Ryan Martell
            if (s->read_buf_index >= s->read_buf_size)
617
                return -1;
618
            ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
619
                                      s->read_buf_size - s->read_buf_index);
620
            if (ret < 0)
621
                return -1;
622
            s->read_buf_index += ret;
623
            if (s->read_buf_index < s->read_buf_size)
624
                return 1;
625
            else
626
                return 0;
627 4934884a Ryan Martell
        }
628 8b1ab7bf Fabrice Bellard
    }
629
630 e309128f Fabrice Bellard
    if (len < 12)
631
        return -1;
632
633
    if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
634
        return -1;
635
    if (buf[1] >= 200 && buf[1] <= 204) {
636 8b1ab7bf Fabrice Bellard
        rtcp_parse_packet(s, buf, len);
637 e309128f Fabrice Bellard
        return -1;
638
    }
639
    payload_type = buf[1] & 0x7f;
640 80fb8234 Ronald S. Bultje
    seq  = AV_RB16(buf + 2);
641 48961970 Ronald S. Bultje
    timestamp = AV_RB32(buf + 4);
642
    ssrc = AV_RB32(buf + 8);
643 dbf30963 Thijs
    /* store the ssrc in the RTPDemuxContext */
644
    s->ssrc = ssrc;
645 115329f1 Diego Biurrun
646 e309128f Fabrice Bellard
    /* NOTE: we can handle only one payload type */
647
    if (s->payload_type != payload_type)
648
        return -1;
649 7581c5f5 François Revol
650
    st = s->st;
651 4a6cc061 Ryan Martell
    // only do something with this if all the rtp checks pass...
652
    if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
653
    {
654 7581c5f5 François Revol
        av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
655 e309128f Fabrice Bellard
               payload_type, seq, ((s->seq + 1) & 0xffff));
656 4a6cc061 Ryan Martell
        return -1;
657 e309128f Fabrice Bellard
    }
658 4a6cc061 Ryan Martell
659 d1ccf0e0 Romain Degez
    s->seq = seq;
660 e309128f Fabrice Bellard
    len -= 12;
661
    buf += 12;
662 8b1ab7bf Fabrice Bellard
663
    if (!st) {
664
        /* specific MPEG2TS demux support */
665
        ret = mpegts_parse_packet(s->ts, pkt, buf, len);
666
        if (ret < 0)
667 e309128f Fabrice Bellard
            return -1;
668 8b1ab7bf Fabrice Bellard
        if (ret < len) {
669
            s->read_buf_size = len - ret;
670
            memcpy(s->buf, buf + ret, s->read_buf_size);
671
            s->read_buf_index = 0;
672
            return 1;
673
        }
674
    } else {
675 4934884a Ryan Martell
        // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
676 01f4895c Michael Niedermayer
        switch(st->codec->codec_id) {
677 8b1ab7bf Fabrice Bellard
        case CODEC_ID_MP2:
678
            /* better than nothing: skip mpeg audio RTP header */
679
            if (len <= 4)
680
                return -1;
681 48961970 Ronald S. Bultje
            h = AV_RB32(buf);
682 8b1ab7bf Fabrice Bellard
            len -= 4;
683
            buf += 4;
684
            av_new_packet(pkt, len);
685
            memcpy(pkt->data, buf, len);
686
            break;
687
        case CODEC_ID_MPEG1VIDEO:
688 db628029 Luca Abeni
        case CODEC_ID_MPEG2VIDEO:
689 ccd39ae6 Fabrice Bellard
            /* better than nothing: skip mpeg video RTP header */
690 e309128f Fabrice Bellard
            if (len <= 4)
691
                return -1;
692 48961970 Ronald S. Bultje
            h = AV_RB32(buf);
693 e309128f Fabrice Bellard
            buf += 4;
694
            len -= 4;
695 8b1ab7bf Fabrice Bellard
            if (h & (1 << 26)) {
696
                /* mpeg2 */
697
                if (len <= 4)
698
                    return -1;
699
                buf += 4;
700
                len -= 4;
701
            }
702
            av_new_packet(pkt, len);
703
            memcpy(pkt->data, buf, len);
704
            break;
705 d8372330 Ryan Martell
            // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
706
            // timestamps.
707
            // TODO: Put this into a dynamic packet handler...
708 cbee7a69 Baptiste Coudurier
        case CODEC_ID_AAC:
709 d8372330 Ryan Martell
            if (rtp_parse_mp4_au(s, buf))
710
                return -1;
711
            {
712
                rtp_payload_data_t *infos = s->rtp_payload_data;
713
                if (infos == NULL)
714
                    return -1;
715
                buf += infos->au_headers_length_bytes + 2;
716
                len -= infos->au_headers_length_bytes + 2;
717
718
                /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
719
                    one au_header */
720
                av_new_packet(pkt, infos->au_headers[0].size);
721
                memcpy(pkt->data, buf, infos->au_headers[0].size);
722
                buf += infos->au_headers[0].size;
723
                len -= infos->au_headers[0].size;
724
            }
725
            s->read_buf_size = len;
726 d0deedcb Ryan Martell
            rv= 0;
727 d8372330 Ryan Martell
            break;
728 8b1ab7bf Fabrice Bellard
        default:
729 4934884a Ryan Martell
            if(s->parse_packet) {
730 d0deedcb Ryan Martell
                rv= s->parse_packet(s, pkt, &timestamp, buf, len);
731 4934884a Ryan Martell
            } else {
732 ed787542 Ryan Martell
                av_new_packet(pkt, len);
733
                memcpy(pkt->data, buf, len);
734 4934884a Ryan Martell
            }
735 8b1ab7bf Fabrice Bellard
            break;
736 e309128f Fabrice Bellard
        }
737 115329f1 Diego Biurrun
738 d0deedcb Ryan Martell
        // now perform timestamp things....
739
        finalize_packet(s, pkt, timestamp);
740 e309128f Fabrice Bellard
    }
741 d0deedcb Ryan Martell
    return rv;
742 e309128f Fabrice Bellard
}
743
744 8b1ab7bf Fabrice Bellard
void rtp_parse_close(RTPDemuxContext *s)
745 e309128f Fabrice Bellard
{
746 4934884a Ryan Martell
    // TODO: fold this into the protocol specific data fields.
747 7ed19d7f Luca Abeni
    if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
748 8b1ab7bf Fabrice Bellard
        mpegts_parse_close(s->ts);
749 e309128f Fabrice Bellard
    }
750 8b1ab7bf Fabrice Bellard
    av_free(s);
751 e309128f Fabrice Bellard
}
752
753
/* rtp output */
754
755
static int rtp_write_header(AVFormatContext *s1)
756
{
757 8b1ab7bf Fabrice Bellard
    RTPDemuxContext *s = s1->priv_data;
758
    int payload_type, max_packet_size, n;
759 e309128f Fabrice Bellard
    AVStream *st;
760
761
    if (s1->nb_streams != 1)
762
        return -1;
763
    st = s1->streams[0];
764
765 01f4895c Michael Niedermayer
    payload_type = rtp_get_payload_type(st->codec);
766 e309128f Fabrice Bellard
    if (payload_type < 0)
767 65e70450 Fabrice Bellard
        payload_type = RTP_PT_PRIVATE; /* private payload type */
768 e309128f Fabrice Bellard
    s->payload_type = payload_type;
769
770 d0b53d05 Diego Biurrun
// following 2 FIXMEs could be set based on the current time, there is normally no info leak, as RTP will likely be transmitted immediately
771 f8801993 D Richard Felker III
    s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
772 e309128f Fabrice Bellard
    s->timestamp = s->base_timestamp;
773 af74c95a Luca Abeni
    s->cur_timestamp = 0;
774 f8801993 D Richard Felker III
    s->ssrc = 0; /* FIXME: was random(), what should this be? */
775 e309128f Fabrice Bellard
    s->first_packet = 1;
776 1b31b02e Luca Abeni
    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
777 e309128f Fabrice Bellard
778 899681cd Björn Axelsson
    max_packet_size = url_fget_max_packet_size(s1->pb);
779 e309128f Fabrice Bellard
    if (max_packet_size <= 12)
780 6f3e0b21 Panagiotis Issaris
        return AVERROR(EIO);
781 e309128f Fabrice Bellard
    s->max_payload_size = max_packet_size - 12;
782
783 e0d21bfe Luca Abeni
    s->max_frames_per_packet = 0;
784
    if (s1->max_delay) {
785
        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
786
            if (st->codec->frame_size == 0) {
787
                av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
788
            } else {
789
                s->max_frames_per_packet = av_rescale_rnd(s1->max_delay, st->codec->sample_rate, AV_TIME_BASE * st->codec->frame_size, AV_ROUND_DOWN);
790
            }
791
        }
792
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
793
            /* FIXME: We should round down here... */
794
            s->max_frames_per_packet = av_rescale_q(s1->max_delay, AV_TIME_BASE_Q, st->codec->time_base);
795
        }
796
    }
797
798 af74c95a Luca Abeni
    av_set_pts_info(st, 32, 1, 90000);
799 01f4895c Michael Niedermayer
    switch(st->codec->codec_id) {
800 e309128f Fabrice Bellard
    case CODEC_ID_MP2:
801 80783dc2 Fabrice Bellard
    case CODEC_ID_MP3:
802 e309128f Fabrice Bellard
        s->buf_ptr = s->buf + 4;
803
        break;
804
    case CODEC_ID_MPEG1VIDEO:
805 db628029 Luca Abeni
    case CODEC_ID_MPEG2VIDEO:
806 e309128f Fabrice Bellard
        break;
807 8b1ab7bf Fabrice Bellard
    case CODEC_ID_MPEG2TS:
808
        n = s->max_payload_size / TS_PACKET_SIZE;
809
        if (n < 1)
810
            n = 1;
811
        s->max_payload_size = n * TS_PACKET_SIZE;
812
        s->buf_ptr = s->buf;
813
        break;
814 171dce48 Luca Abeni
    case CODEC_ID_AAC:
815
        s->read_buf_index = 0;
816 e309128f Fabrice Bellard
    default:
817 1b31b02e Luca Abeni
        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
818
            av_set_pts_info(st, 32, 1, st->codec->sample_rate);
819
        }
820 e309128f Fabrice Bellard
        s->buf_ptr = s->buf;
821
        break;
822
    }
823
824
    return 0;
825
}
826
827
/* send an rtcp sender report packet */
828 0c1a9eda Zdenek Kabelac
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
829 e309128f Fabrice Bellard
{
830 8b1ab7bf Fabrice Bellard
    RTPDemuxContext *s = s1->priv_data;
831 1b31b02e Luca Abeni
    uint32_t rtp_ts;
832
833 e309128f Fabrice Bellard
#if defined(DEBUG)
834 949b1a13 Steve L'Homme
    printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
835 e309128f Fabrice Bellard
#endif
836 1b31b02e Luca Abeni
837
    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
838 18c05a37 Luca Abeni
    s->last_rtcp_ntp_time = ntp_time;
839 1b31b02e Luca Abeni
    rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, AV_TIME_BASE_Q,
840
                          s1->streams[0]->time_base) + s->base_timestamp;
841 899681cd Björn Axelsson
    put_byte(s1->pb, (RTP_VERSION << 6));
842
    put_byte(s1->pb, 200);
843
    put_be16(s1->pb, 6); /* length in words - 1 */
844
    put_be32(s1->pb, s->ssrc);
845
    put_be32(s1->pb, ntp_time / 1000000);
846
    put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
847
    put_be32(s1->pb, rtp_ts);
848
    put_be32(s1->pb, s->packet_count);
849
    put_be32(s1->pb, s->octet_count);
850
    put_flush_packet(s1->pb);
851 e309128f Fabrice Bellard
}
852
853
/* send an rtp packet. sequence number is incremented, but the caller
854
   must update the timestamp itself */
855 98561024 Luca Abeni
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
856 e309128f Fabrice Bellard
{
857 8b1ab7bf Fabrice Bellard
    RTPDemuxContext *s = s1->priv_data;
858 e309128f Fabrice Bellard
859
#ifdef DEBUG
860
    printf("rtp_send_data size=%d\n", len);
861
#endif
862
863
    /* build the RTP header */
864 899681cd Björn Axelsson
    put_byte(s1->pb, (RTP_VERSION << 6));
865
    put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
866
    put_be16(s1->pb, s->seq);
867
    put_be32(s1->pb, s->timestamp);
868
    put_be32(s1->pb, s->ssrc);
869
870
    put_buffer(s1->pb, buf1, len);
871
    put_flush_packet(s1->pb);
872 115329f1 Diego Biurrun
873 e309128f Fabrice Bellard
    s->seq++;
874
    s->octet_count += len;
875
    s->packet_count++;
876
}
877
878
/* send an integer number of samples and compute time stamp and fill
879
   the rtp send buffer before sending. */
880
static void rtp_send_samples(AVFormatContext *s1,
881 49057904 Fabrice Bellard
                             const uint8_t *buf1, int size, int sample_size)
882 e309128f Fabrice Bellard
{
883 8b1ab7bf Fabrice Bellard
    RTPDemuxContext *s = s1->priv_data;
884 e309128f Fabrice Bellard
    int len, max_packet_size, n;
885
886
    max_packet_size = (s->max_payload_size / sample_size) * sample_size;
887
    /* not needed, but who nows */
888
    if ((size % sample_size) != 0)
889
        av_abort();
890 af74c95a Luca Abeni
    n = 0;
891 e309128f Fabrice Bellard
    while (size > 0) {
892 af74c95a Luca Abeni
        s->buf_ptr = s->buf;
893
        len = FFMIN(max_packet_size, size);
894 e309128f Fabrice Bellard
895
        /* copy data */
896
        memcpy(s->buf_ptr, buf1, len);
897
        s->buf_ptr += len;
898
        buf1 += len;
899
        size -= len;
900 af74c95a Luca Abeni
        s->timestamp = s->cur_timestamp + n / sample_size;
901
        ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
902
        n += (s->buf_ptr - s->buf);
903 e309128f Fabrice Bellard
    }
904 115329f1 Diego Biurrun
}
905 e309128f Fabrice Bellard
906
/* NOTE: we suppose that exactly one frame is given as argument here */
907
/* XXX: test it */
908
static void rtp_send_mpegaudio(AVFormatContext *s1,
909 49057904 Fabrice Bellard
                               const uint8_t *buf1, int size)
910 e309128f Fabrice Bellard
{
911 8b1ab7bf Fabrice Bellard
    RTPDemuxContext *s = s1->priv_data;
912 e309128f Fabrice Bellard
    int len, count, max_packet_size;
913
914
    max_packet_size = s->max_payload_size;
915
916
    /* test if we must flush because not enough space */
917
    len = (s->buf_ptr - s->buf);
918
    if ((len + size) > max_packet_size) {
919
        if (len > 4) {
920 98561024 Luca Abeni
            ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
921 e309128f Fabrice Bellard
            s->buf_ptr = s->buf + 4;
922
        }
923
    }
924 af74c95a Luca Abeni
    if (s->buf_ptr == s->buf + 4) {
925
        s->timestamp = s->cur_timestamp;
926
    }
927 e309128f Fabrice Bellard
928
    /* add the packet */
929
    if (size > max_packet_size) {
930
        /* big packet: fragment */
931
        count = 0;
932
        while (size > 0) {
933
            len = max_packet_size - 4;
934
            if (len > size)
935
                len = size;
936
            /* build fragmented packet */
937
            s->buf[0] = 0;
938
            s->buf[1] = 0;
939
            s->buf[2] = count >> 8;
940
            s->buf[3] = count;
941
            memcpy(s->buf + 4, buf1, len);
942 98561024 Luca Abeni
            ff_rtp_send_data(s1, s->buf, len + 4, 0);
943 e309128f Fabrice Bellard
            size -= len;
944
            buf1 += len;
945
            count += len;
946
        }
947
    } else {
948
        if (s->buf_ptr == s->buf + 4) {
949
            /* no fragmentation possible */
950
            s->buf[0] = 0;
951
            s->buf[1] = 0;
952
            s->buf[2] = 0;
953
            s->buf[3] = 0;
954
        }
955
        memcpy(s->buf_ptr, buf1, size);
956
        s->buf_ptr += size;
957
    }
958
}
959
960 65e70450 Fabrice Bellard
static void rtp_send_raw(AVFormatContext *s1,
961 49057904 Fabrice Bellard
                         const uint8_t *buf1, int size)
962 65e70450 Fabrice Bellard
{
963 8b1ab7bf Fabrice Bellard
    RTPDemuxContext *s = s1->priv_data;
964 65e70450 Fabrice Bellard
    int len, max_packet_size;
965
966
    max_packet_size = s->max_payload_size;
967
968
    while (size > 0) {
969
        len = max_packet_size;
970
        if (len > size)
971
            len = size;
972
973 af74c95a Luca Abeni
        s->timestamp = s->cur_timestamp;
974 98561024 Luca Abeni
        ff_rtp_send_data(s1, buf1, len, (len == size));
975 65e70450 Fabrice Bellard
976
        buf1 += len;
977
        size -= len;
978
    }
979
}
980
981 8b1ab7bf Fabrice Bellard
/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
982
static void rtp_send_mpegts_raw(AVFormatContext *s1,
983
                                const uint8_t *buf1, int size)
984
{
985
    RTPDemuxContext *s = s1->priv_data;
986
    int len, out_len;
987
988
    while (size >= TS_PACKET_SIZE) {
989
        len = s->max_payload_size - (s->buf_ptr - s->buf);
990
        if (len > size)
991
            len = size;
992
        memcpy(s->buf_ptr, buf1, len);
993
        buf1 += len;
994
        size -= len;
995
        s->buf_ptr += len;
996 115329f1 Diego Biurrun
997 8b1ab7bf Fabrice Bellard
        out_len = s->buf_ptr - s->buf;
998
        if (out_len >= s->max_payload_size) {
999 98561024 Luca Abeni
            ff_rtp_send_data(s1, s->buf, out_len, 0);
1000 8b1ab7bf Fabrice Bellard
            s->buf_ptr = s->buf;
1001
        }
1002
    }
1003
}
1004
1005 e309128f Fabrice Bellard
/* write an RTP packet. 'buf1' must contain a single specific frame. */
1006 e928649b Michael Niedermayer
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
1007 e309128f Fabrice Bellard
{
1008 8b1ab7bf Fabrice Bellard
    RTPDemuxContext *s = s1->priv_data;
1009 e309128f Fabrice Bellard
    AVStream *st = s1->streams[0];
1010
    int rtcp_bytes;
1011 e928649b Michael Niedermayer
    int size= pkt->size;
1012
    uint8_t *buf1= pkt->data;
1013 115329f1 Diego Biurrun
1014 e309128f Fabrice Bellard
#ifdef DEBUG
1015 e928649b Michael Niedermayer
    printf("%d: write len=%d\n", pkt->stream_index, size);
1016 e309128f Fabrice Bellard
#endif
1017
1018
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
1019 115329f1 Diego Biurrun
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
1020 e309128f Fabrice Bellard
        RTCP_TX_RATIO_DEN;
1021 18c05a37 Luca Abeni
    if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
1022
                           (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
1023 1b31b02e Luca Abeni
        rtcp_send_sr(s1, av_gettime());
1024 e309128f Fabrice Bellard
        s->last_octet_count = s->octet_count;
1025
        s->first_packet = 0;
1026
    }
1027 af74c95a Luca Abeni
    s->cur_timestamp = s->base_timestamp + pkt->pts;
1028 e309128f Fabrice Bellard
1029 01f4895c Michael Niedermayer
    switch(st->codec->codec_id) {
1030 e309128f Fabrice Bellard
    case CODEC_ID_PCM_MULAW:
1031
    case CODEC_ID_PCM_ALAW:
1032
    case CODEC_ID_PCM_U8:
1033
    case CODEC_ID_PCM_S8:
1034 01f4895c Michael Niedermayer
        rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
1035 e309128f Fabrice Bellard
        break;
1036
    case CODEC_ID_PCM_U16BE:
1037
    case CODEC_ID_PCM_U16LE:
1038
    case CODEC_ID_PCM_S16BE:
1039
    case CODEC_ID_PCM_S16LE:
1040 01f4895c Michael Niedermayer
        rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
1041 e309128f Fabrice Bellard
        break;
1042
    case CODEC_ID_MP2:
1043 80783dc2 Fabrice Bellard
    case CODEC_ID_MP3:
1044 e309128f Fabrice Bellard
        rtp_send_mpegaudio(s1, buf1, size);
1045
        break;
1046
    case CODEC_ID_MPEG1VIDEO:
1047 db628029 Luca Abeni
    case CODEC_ID_MPEG2VIDEO:
1048 98561024 Luca Abeni
        ff_rtp_send_mpegvideo(s1, buf1, size);
1049 e309128f Fabrice Bellard
        break;
1050 171dce48 Luca Abeni
    case CODEC_ID_AAC:
1051
        ff_rtp_send_aac(s1, buf1, size);
1052
        break;
1053 8b1ab7bf Fabrice Bellard
    case CODEC_ID_MPEG2TS:
1054
        rtp_send_mpegts_raw(s1, buf1, size);
1055
        break;
1056 e309128f Fabrice Bellard
    default:
1057 65e70450 Fabrice Bellard
        /* better than nothing : send the codec raw data */
1058
        rtp_send_raw(s1, buf1, size);
1059
        break;
1060 e309128f Fabrice Bellard
    }
1061
    return 0;
1062
}
1063
1064 d2a067d1 Måns Rullgård
AVOutputFormat rtp_muxer = {
1065 e309128f Fabrice Bellard
    "rtp",
1066
    "RTP output format",
1067
    NULL,
1068
    NULL,
1069 8b1ab7bf Fabrice Bellard
    sizeof(RTPDemuxContext),
1070 e309128f Fabrice Bellard
    CODEC_ID_PCM_MULAW,
1071
    CODEC_ID_NONE,
1072
    rtp_write_header,
1073
    rtp_write_packet,
1074
};