Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtp.c @ 0ec12335

History | View | Annotate | Download (36.9 KB)

1
/*
2
 * RTP input/output format
3
 * Copyright (c) 2002 Fabrice Bellard.
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * 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
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#include "avformat.h"
22
#include "mpegts.h"
23
#include "bitstream.h"
24

    
25
#include <unistd.h>
26
#include "network.h"
27

    
28
#include "rtp_internal.h"
29
#include "rtp_h264.h"
30
#include "rtp_mpv.h"
31
#include "rtp_aac.h"
32

    
33
//#define DEBUG
34

    
35
#define RTCP_SR_SIZE 28
36

    
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
         'url_open_dyn_packet_buf')
44
*/
45

    
46
/* 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
  {12, "QCELP",      CODEC_TYPE_AUDIO,   CODEC_ID_QCELP, 8000, 1},
62
  {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
/* statistics functions */
181
RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
182

    
183
static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
184
static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
185

    
186
static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
187
{
188
    handler->next= RTPFirstDynamicPayloadHandler;
189
    RTPFirstDynamicPayloadHandler= handler;
190
}
191

    
192
void av_register_rtp_dynamic_payload_handlers(void)
193
{
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

    
199
int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
200
{
201
    if (AVRtpPayloadTypes[payload_type].codec_id != CODEC_ID_NONE) {
202
        codec->codec_type = AVRtpPayloadTypes[payload_type].codec_type;
203
        codec->codec_id = AVRtpPayloadTypes[payload_type].codec_id;
204
        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
    }
210
    return -1;
211
}
212

    
213
int rtp_get_payload_type(AVCodecContext *codec)
214
{
215
    int i, payload_type;
216

    
217
    /* compute the payload type */
218
    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
        }
225
    return payload_type;
226
}
227

    
228
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
229
{
230
    if (buf[1] != 200)
231
        return -1;
232
    s->last_rtcp_ntp_time = AV_RB64(buf + 8);
233
    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
234
        s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
235
    s->last_rtcp_timestamp = AV_RB32(buf + 16);
236
    return 0;
237
}
238

    
239
#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
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
    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

    
347
    if (!s->rtp_ctx || (count < 1))
348
        return -1;
349

    
350
    /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
351
    /* 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
    // 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

    
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
        int result;
419
#if defined(DEBUG)
420
        printf("sending %d bytes of RR\n", len);
421
#endif
422
        result= url_write(s->rtp_ctx, buf, len);
423
#if defined(DEBUG)
424
        printf("result from url_write: %d\n", result);
425
#endif
426
        av_free(buf);
427
    }
428
    return 0;
429
}
430

    
431
/**
432
 * 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
 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
435
 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
436
 */
437
RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
438
{
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
    s->rtp_payload_data = rtp_payload_data;
450
    rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
451
    if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
452
        s->ts = mpegts_parse_open(s->ic);
453
        if (s->ts == NULL) {
454
            av_free(s);
455
            return NULL;
456
        }
457
    } else {
458
        switch(st->codec->codec_id) {
459
        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
        case CODEC_ID_H264:
465
            st->need_parsing = AVSTREAM_PARSE_FULL;
466
            break;
467
        default:
468
            break;
469
        }
470
    }
471
    // needed to send back RTCP RR in RTSP sessions
472
    s->rtp_ctx = rtpc;
473
    gethostname(s->hostname, sizeof(s->hostname));
474
    return s;
475
}
476

    
477
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
    au_headers_length = AV_RB16(buf);
491

    
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
       In my test, the FAAD decoder does not behave correctly when sending each AU one by one
512
       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
/**
526
 * 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
        case CODEC_ID_AAC:
547
        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
 * Parse an RTP or RTCP packet directly sent as a buffer.
560
 * @param s RTP parse context.
561
 * @param pkt returned packet
562
 * @param buf input buffer or NULL to read the next packets
563
 * @param len buffer len
564
 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
565
 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
566
 */
567
int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
568
                     const uint8_t *buf, int len)
569
{
570
    unsigned int ssrc, h;
571
    int payload_type, seq, ret;
572
    AVStream *st;
573
    uint32_t timestamp;
574
    int rv= 0;
575

    
576
    if (!buf) {
577
        /* return the next packets, if any */
578
        if(s->st && s->parse_packet) {
579
            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
        } else {
584
            // TODO: Move to a dynamic packet handler (like above)
585
            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
        }
597
    }
598

    
599
    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
        rtcp_parse_packet(s, buf, len);
606
        return -1;
607
    }
608
    payload_type = buf[1] & 0x7f;
609
    seq  = AV_RB16(buf + 2);
610
    timestamp = AV_RB32(buf + 4);
611
    ssrc = AV_RB32(buf + 8);
612
    /* store the ssrc in the RTPDemuxContext */
613
    s->ssrc = ssrc;
614

    
615
    /* NOTE: we can handle only one payload type */
616
    if (s->payload_type != payload_type)
617
        return -1;
618

    
619
    st = s->st;
620
    // only do something with this if all the rtp checks pass...
621
    if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
622
    {
623
        av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
624
               payload_type, seq, ((s->seq + 1) & 0xffff));
625
        return -1;
626
    }
627

    
628
    s->seq = seq;
629
    len -= 12;
630
    buf += 12;
631

    
632
    if (!st) {
633
        /* specific MPEG2TS demux support */
634
        ret = mpegts_parse_packet(s->ts, pkt, buf, len);
635
        if (ret < 0)
636
            return -1;
637
        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
        // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
645
        switch(st->codec->codec_id) {
646
        case CODEC_ID_MP2:
647
            /* better than nothing: skip mpeg audio RTP header */
648
            if (len <= 4)
649
                return -1;
650
            h = AV_RB32(buf);
651
            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
            /* better than nothing: skip mpeg video RTP header */
658
            if (len <= 4)
659
                return -1;
660
            h = AV_RB32(buf);
661
            buf += 4;
662
            len -= 4;
663
            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
            // 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
        case CODEC_ID_AAC:
677
            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
            rv= 0;
695
            break;
696
        default:
697
            if(s->parse_packet) {
698
                rv= s->parse_packet(s, pkt, &timestamp, buf, len);
699
            } else {
700
                av_new_packet(pkt, len);
701
                memcpy(pkt->data, buf, len);
702
            }
703
            break;
704
        }
705

    
706
        // now perform timestamp things....
707
        finalize_packet(s, pkt, timestamp);
708
    }
709
    return rv;
710
}
711

    
712
void rtp_parse_close(RTPDemuxContext *s)
713
{
714
    // TODO: fold this into the protocol specific data fields.
715
    if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
716
        mpegts_parse_close(s->ts);
717
    }
718
    av_free(s);
719
}
720

    
721
/* rtp output */
722

    
723
static int rtp_write_header(AVFormatContext *s1)
724
{
725
    RTPDemuxContext *s = s1->priv_data;
726
    int payload_type, max_packet_size, n;
727
    AVStream *st;
728

    
729
    if (s1->nb_streams != 1)
730
        return -1;
731
    st = s1->streams[0];
732

    
733
    payload_type = rtp_get_payload_type(st->codec);
734
    if (payload_type < 0)
735
        payload_type = RTP_PT_PRIVATE; /* private payload type */
736
    s->payload_type = payload_type;
737

    
738
// following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
739
    s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
740
    s->timestamp = s->base_timestamp;
741
    s->cur_timestamp = 0;
742
    s->ssrc = 0; /* FIXME: was random(), what should this be? */
743
    s->first_packet = 1;
744
    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
745

    
746
    max_packet_size = url_fget_max_packet_size(&s1->pb);
747
    if (max_packet_size <= 12)
748
        return AVERROR(EIO);
749
    s->max_payload_size = max_packet_size - 12;
750

    
751
    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
    av_set_pts_info(st, 32, 1, 90000);
767
    switch(st->codec->codec_id) {
768
    case CODEC_ID_MP2:
769
    case CODEC_ID_MP3:
770
        s->buf_ptr = s->buf + 4;
771
        break;
772
    case CODEC_ID_MPEG1VIDEO:
773
        break;
774
    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
    case CODEC_ID_AAC:
782
        s->read_buf_index = 0;
783
    default:
784
        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
785
            av_set_pts_info(st, 32, 1, st->codec->sample_rate);
786
        }
787
        s->buf_ptr = s->buf;
788
        break;
789
    }
790

    
791
    return 0;
792
}
793

    
794
/* send an rtcp sender report packet */
795
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
796
{
797
    RTPDemuxContext *s = s1->priv_data;
798
    uint32_t rtp_ts;
799

    
800
#if defined(DEBUG)
801
    printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
802
#endif
803

    
804
    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
805
    s->last_rtcp_ntp_time = ntp_time;
806
    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
    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
    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
    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
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
823
{
824
    RTPDemuxContext *s = s1->priv_data;
825

    
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
    put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
833
    put_be16(&s1->pb, s->seq);
834
    put_be32(&s1->pb, s->timestamp);
835
    put_be32(&s1->pb, s->ssrc);
836

    
837
    put_buffer(&s1->pb, buf1, len);
838
    put_flush_packet(&s1->pb);
839

    
840
    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
                             const uint8_t *buf1, int size, int sample_size)
849
{
850
    RTPDemuxContext *s = s1->priv_data;
851
    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
    n = 0;
858
    while (size > 0) {
859
        s->buf_ptr = s->buf;
860
        len = FFMIN(max_packet_size, size);
861

    
862
        /* copy data */
863
        memcpy(s->buf_ptr, buf1, len);
864
        s->buf_ptr += len;
865
        buf1 += len;
866
        size -= len;
867
        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
    }
871
}
872

    
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
                               const uint8_t *buf1, int size)
877
{
878
    RTPDemuxContext *s = s1->priv_data;
879
    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
            ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
888
            s->buf_ptr = s->buf + 4;
889
        }
890
    }
891
    if (s->buf_ptr == s->buf + 4) {
892
        s->timestamp = s->cur_timestamp;
893
    }
894

    
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
            ff_rtp_send_data(s1, s->buf, len + 4, 0);
910
            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
static void rtp_send_raw(AVFormatContext *s1,
928
                         const uint8_t *buf1, int size)
929
{
930
    RTPDemuxContext *s = s1->priv_data;
931
    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
        s->timestamp = s->cur_timestamp;
941
        ff_rtp_send_data(s1, buf1, len, (len == size));
942

    
943
        buf1 += len;
944
        size -= len;
945
    }
946
}
947

    
948
/* 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

    
964
        out_len = s->buf_ptr - s->buf;
965
        if (out_len >= s->max_payload_size) {
966
            ff_rtp_send_data(s1, s->buf, out_len, 0);
967
            s->buf_ptr = s->buf;
968
        }
969
    }
970
}
971

    
972
/* write an RTP packet. 'buf1' must contain a single specific frame. */
973
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
974
{
975
    RTPDemuxContext *s = s1->priv_data;
976
    AVStream *st = s1->streams[0];
977
    int rtcp_bytes;
978
    int size= pkt->size;
979
    uint8_t *buf1= pkt->data;
980

    
981
#ifdef DEBUG
982
    printf("%d: write len=%d\n", pkt->stream_index, size);
983
#endif
984

    
985
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
986
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
987
        RTCP_TX_RATIO_DEN;
988
    if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
989
                           (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
990
        rtcp_send_sr(s1, av_gettime());
991
        s->last_octet_count = s->octet_count;
992
        s->first_packet = 0;
993
    }
994
    s->cur_timestamp = s->base_timestamp + pkt->pts;
995

    
996
    switch(st->codec->codec_id) {
997
    case CODEC_ID_PCM_MULAW:
998
    case CODEC_ID_PCM_ALAW:
999
    case CODEC_ID_PCM_U8:
1000
    case CODEC_ID_PCM_S8:
1001
        rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
1002
        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
        rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
1008
        break;
1009
    case CODEC_ID_MP2:
1010
    case CODEC_ID_MP3:
1011
        rtp_send_mpegaudio(s1, buf1, size);
1012
        break;
1013
    case CODEC_ID_MPEG1VIDEO:
1014
        ff_rtp_send_mpegvideo(s1, buf1, size);
1015
        break;
1016
    case CODEC_ID_AAC:
1017
        ff_rtp_send_aac(s1, buf1, size);
1018
        break;
1019
    case CODEC_ID_MPEG2TS:
1020
        rtp_send_mpegts_raw(s1, buf1, size);
1021
        break;
1022
    default:
1023
        /* better than nothing : send the codec raw data */
1024
        rtp_send_raw(s1, buf1, size);
1025
        break;
1026
    }
1027
    return 0;
1028
}
1029

    
1030
AVOutputFormat rtp_muxer = {
1031
    "rtp",
1032
    "RTP output format",
1033
    NULL,
1034
    NULL,
1035
    sizeof(RTPDemuxContext),
1036
    CODEC_ID_PCM_MULAW,
1037
    CODEC_ID_NONE,
1038
    rtp_write_header,
1039
    rtp_write_packet,
1040
};