Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtp.c @ 0ec12335

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