Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtp.c @ 0a5790d1

History | View | Annotate | Download (37.4 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 4934884a Ryan Martell
31 e309128f Fabrice Bellard
//#define DEBUG
32
33
34
/* TODO: - add RTCP statistics reporting (should be optional).
35

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