Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtp.c @ 7e1720de

History | View | Annotate | Download (37.8 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
  {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG2VIDEO, 90000, -1},
83
  {33, "MP2T",       CODEC_TYPE_DATA,    CODEC_ID_MPEG2TS, 90000, -1},
84
  {34, "H263",       CODEC_TYPE_VIDEO,   CODEC_ID_H263, 90000, -1},
85
  {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
86
  {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
87
  {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
88
  {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
89
  {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
90
  {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
91
  {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
92
  {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
93
  {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
94
  {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
95
  {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
96
  {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
97
  {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
98
  {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
99
  {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
100
  {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
101
  {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
102
  {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
103
  {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
104
  {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
105
  {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
106
  {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
107
  {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
108
  {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
109
  {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
110
  {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
111
  {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
112
  {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
113
  {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
114
  {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
115
  {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
116
  {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
117
  {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
118
  {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
119
  {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
120
  {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
121
  {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
122
  {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
123
  {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
124
  {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
125
  {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
126
  {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
127
  {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
128
  {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
129
  {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
130
  {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
131
  {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
132
  {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
133
  {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
134
  {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
135
  {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
136
  {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
137
  {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
138
  {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
139
  {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
140
  {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
141
  {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
142
  {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
143
  {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
144
  {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
145
  {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
146
  {96, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
147
  {97, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
148
  {98, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
149
  {99, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
150
  {100, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
151
  {101, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
152
  {102, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
153
  {103, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
154
  {104, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
155
  {105, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
156
  {106, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
157
  {107, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
158
  {108, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
159
  {109, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
160
  {110, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
161
  {111, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
162
  {112, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
163
  {113, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
164
  {114, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
165
  {115, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
166
  {116, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
167
  {117, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
168
  {118, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
169
  {119, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
170
  {120, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
171
  {121, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
172
  {122, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
173
  {123, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
174
  {124, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
175
  {125, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
176
  {126, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
177
  {127, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
178
  {-1, "",           CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
179
};
180

    
181
/* statistics functions */
182
RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
183

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

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

    
193
void av_register_rtp_dynamic_payload_handlers(void)
194
{
195
    register_dynamic_payload_handler(&mp4v_es_handler);
196
    register_dynamic_payload_handler(&mpeg4_generic_handler);
197
    register_dynamic_payload_handler(&ff_h264_dynamic_handler);
198
}
199

    
200
int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
201
{
202
    int i = 0;
203

    
204
    for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
205
        if (AVRtpPayloadTypes[i].pt == payload_type) {
206
            if (AVRtpPayloadTypes[i].codec_id != CODEC_ID_NONE) {
207
                codec->codec_type = AVRtpPayloadTypes[i].codec_type;
208
                codec->codec_id = AVRtpPayloadTypes[i].codec_id;
209
                if (AVRtpPayloadTypes[i].audio_channels > 0)
210
                    codec->channels = AVRtpPayloadTypes[i].audio_channels;
211
                if (AVRtpPayloadTypes[i].clock_rate > 0)
212
                    codec->sample_rate = AVRtpPayloadTypes[i].clock_rate;
213
                return 0;
214
            }
215
        }
216
    return -1;
217
}
218

    
219
int rtp_get_payload_type(AVCodecContext *codec)
220
{
221
    int i, payload_type;
222

    
223
    /* compute the payload type */
224
    for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
225
        if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
226
            if (codec->codec_id == CODEC_ID_PCM_S16BE)
227
                if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
228
                    continue;
229
            payload_type = AVRtpPayloadTypes[i].pt;
230
        }
231
    return payload_type;
232
}
233

    
234
const char *ff_rtp_enc_name(int payload_type)
235
{
236
    int i;
237

    
238
    for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
239
        if (AVRtpPayloadTypes[i].pt == payload_type) {
240
            return AVRtpPayloadTypes[i].enc_name;
241
        }
242

    
243
    return "";
244
}
245

    
246
enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type)
247
{
248
    int i;
249

    
250
    for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
251
        if (!strcmp(buf, AVRtpPayloadTypes[i].enc_name) && (codec_type == AVRtpPayloadTypes[i].codec_type)){
252
            return AVRtpPayloadTypes[i].codec_id;
253
        }
254

    
255
    return CODEC_ID_NONE;
256
}
257

    
258
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
259
{
260
    if (buf[1] != 200)
261
        return -1;
262
    s->last_rtcp_ntp_time = AV_RB64(buf + 8);
263
    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
264
        s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
265
    s->last_rtcp_timestamp = AV_RB32(buf + 16);
266
    return 0;
267
}
268

    
269
#define RTP_SEQ_MOD (1<<16)
270

    
271
/**
272
* called on parse open packet
273
*/
274
static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
275
{
276
    memset(s, 0, sizeof(RTPStatistics));
277
    s->max_seq= base_sequence;
278
    s->probation= 1;
279
}
280

    
281
/**
282
* called whenever there is a large jump in sequence numbers, or when they get out of probation...
283
*/
284
static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
285
{
286
    s->max_seq= seq;
287
    s->cycles= 0;
288
    s->base_seq= seq -1;
289
    s->bad_seq= RTP_SEQ_MOD + 1;
290
    s->received= 0;
291
    s->expected_prior= 0;
292
    s->received_prior= 0;
293
    s->jitter= 0;
294
    s->transit= 0;
295
}
296

    
297
/**
298
* returns 1 if we should handle this packet.
299
*/
300
static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
301
{
302
    uint16_t udelta= seq - s->max_seq;
303
    const int MAX_DROPOUT= 3000;
304
    const int MAX_MISORDER = 100;
305
    const int MIN_SEQUENTIAL = 2;
306

    
307
    /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
308
    if(s->probation)
309
    {
310
        if(seq==s->max_seq + 1) {
311
            s->probation--;
312
            s->max_seq= seq;
313
            if(s->probation==0) {
314
                rtp_init_sequence(s, seq);
315
                s->received++;
316
                return 1;
317
            }
318
        } else {
319
            s->probation= MIN_SEQUENTIAL - 1;
320
            s->max_seq = seq;
321
        }
322
    } else if (udelta < MAX_DROPOUT) {
323
        // in order, with permissible gap
324
        if(seq < s->max_seq) {
325
            //sequence number wrapped; count antother 64k cycles
326
            s->cycles += RTP_SEQ_MOD;
327
        }
328
        s->max_seq= seq;
329
    } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
330
        // sequence made a large jump...
331
        if(seq==s->bad_seq) {
332
            // two sequential packets-- assume that the other side restarted without telling us; just resync.
333
            rtp_init_sequence(s, seq);
334
        } else {
335
            s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
336
            return 0;
337
        }
338
    } else {
339
        // duplicate or reordered packet...
340
    }
341
    s->received++;
342
    return 1;
343
}
344

    
345
#if 0
346
/**
347
* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
348
* difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
349
* never change.  I left this in in case someone else can see a way. (rdm)
350
*/
351
static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
352
{
353
    uint32_t transit= arrival_timestamp - sent_timestamp;
354
    int d;
355
    s->transit= transit;
356
    d= FFABS(transit - s->transit);
357
    s->jitter += d - ((s->jitter + 8)>>4);
358
}
359
#endif
360

    
361
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
362
{
363
    ByteIOContext *pb;
364
    uint8_t *buf;
365
    int len;
366
    int rtcp_bytes;
367
    RTPStatistics *stats= &s->statistics;
368
    uint32_t lost;
369
    uint32_t extended_max;
370
    uint32_t expected_interval;
371
    uint32_t received_interval;
372
    uint32_t lost_interval;
373
    uint32_t expected;
374
    uint32_t fraction;
375
    uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
376

    
377
    if (!s->rtp_ctx || (count < 1))
378
        return -1;
379

    
380
    /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
381
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
382
    s->octet_count += count;
383
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
384
        RTCP_TX_RATIO_DEN;
385
    rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
386
    if (rtcp_bytes < 28)
387
        return -1;
388
    s->last_octet_count = s->octet_count;
389

    
390
    if (url_open_dyn_buf(&pb) < 0)
391
        return -1;
392

    
393
    // Receiver Report
394
    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
395
    put_byte(pb, 201);
396
    put_be16(pb, 7); /* length in words - 1 */
397
    put_be32(pb, s->ssrc); // our own SSRC
398
    put_be32(pb, s->ssrc); // XXX: should be the server's here!
399
    // some placeholders we should really fill...
400
    // RFC 1889/p64
401
    extended_max= stats->cycles + stats->max_seq;
402
    expected= extended_max - stats->base_seq + 1;
403
    lost= expected - stats->received;
404
    lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
405
    expected_interval= expected - stats->expected_prior;
406
    stats->expected_prior= expected;
407
    received_interval= stats->received - stats->received_prior;
408
    stats->received_prior= stats->received;
409
    lost_interval= expected_interval - received_interval;
410
    if (expected_interval==0 || lost_interval<=0) fraction= 0;
411
    else fraction = (lost_interval<<8)/expected_interval;
412

    
413
    fraction= (fraction<<24) | lost;
414

    
415
    put_be32(pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
416
    put_be32(pb, extended_max); /* max sequence received */
417
    put_be32(pb, stats->jitter>>4); /* jitter */
418

    
419
    if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
420
    {
421
        put_be32(pb, 0); /* last SR timestamp */
422
        put_be32(pb, 0); /* delay since last SR */
423
    } else {
424
        uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
425
        uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
426

    
427
        put_be32(pb, middle_32_bits); /* last SR timestamp */
428
        put_be32(pb, delay_since_last); /* delay since last SR */
429
    }
430

    
431
    // CNAME
432
    put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
433
    put_byte(pb, 202);
434
    len = strlen(s->hostname);
435
    put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
436
    put_be32(pb, s->ssrc);
437
    put_byte(pb, 0x01);
438
    put_byte(pb, len);
439
    put_buffer(pb, s->hostname, len);
440
    // padding
441
    for (len = (6 + len) % 4; len % 4; len++) {
442
        put_byte(pb, 0);
443
    }
444

    
445
    put_flush_packet(pb);
446
    len = url_close_dyn_buf(pb, &buf);
447
    if ((len > 0) && buf) {
448
        int result;
449
#if defined(DEBUG)
450
        printf("sending %d bytes of RR\n", len);
451
#endif
452
        result= url_write(s->rtp_ctx, buf, len);
453
#if defined(DEBUG)
454
        printf("result from url_write: %d\n", result);
455
#endif
456
        av_free(buf);
457
    }
458
    return 0;
459
}
460

    
461
/**
462
 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
463
 * MPEG2TS streams to indicate that they should be demuxed inside the
464
 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
465
 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
466
 */
467
RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
468
{
469
    RTPDemuxContext *s;
470

    
471
    s = av_mallocz(sizeof(RTPDemuxContext));
472
    if (!s)
473
        return NULL;
474
    s->payload_type = payload_type;
475
    s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
476
    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
477
    s->ic = s1;
478
    s->st = st;
479
    s->rtp_payload_data = rtp_payload_data;
480
    rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
481
    if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
482
        s->ts = mpegts_parse_open(s->ic);
483
        if (s->ts == NULL) {
484
            av_free(s);
485
            return NULL;
486
        }
487
    } else {
488
        switch(st->codec->codec_id) {
489
        case CODEC_ID_MPEG1VIDEO:
490
        case CODEC_ID_MPEG2VIDEO:
491
        case CODEC_ID_MP2:
492
        case CODEC_ID_MP3:
493
        case CODEC_ID_MPEG4:
494
        case CODEC_ID_H264:
495
            st->need_parsing = AVSTREAM_PARSE_FULL;
496
            break;
497
        default:
498
            break;
499
        }
500
    }
501
    // needed to send back RTCP RR in RTSP sessions
502
    s->rtp_ctx = rtpc;
503
    gethostname(s->hostname, sizeof(s->hostname));
504
    return s;
505
}
506

    
507
static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
508
{
509
    int au_headers_length, au_header_size, i;
510
    GetBitContext getbitcontext;
511
    rtp_payload_data_t *infos;
512

    
513
    infos = s->rtp_payload_data;
514

    
515
    if (infos == NULL)
516
        return -1;
517

    
518
    /* decode the first 2 bytes where are stored the AUHeader sections
519
       length in bits */
520
    au_headers_length = AV_RB16(buf);
521

    
522
    if (au_headers_length > RTP_MAX_PACKET_LENGTH)
523
      return -1;
524

    
525
    infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
526

    
527
    /* skip AU headers length section (2 bytes) */
528
    buf += 2;
529

    
530
    init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
531

    
532
    /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
533
    au_header_size = infos->sizelength + infos->indexlength;
534
    if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
535
        return -1;
536

    
537
    infos->nb_au_headers = au_headers_length / au_header_size;
538
    infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
539

    
540
    /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
541
       In my test, the FAAD decoder does not behave correctly when sending each AU one by one
542
       but does when sending the whole as one big packet...  */
543
    infos->au_headers[0].size = 0;
544
    infos->au_headers[0].index = 0;
545
    for (i = 0; i < infos->nb_au_headers; ++i) {
546
        infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
547
        infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
548
    }
549

    
550
    infos->nb_au_headers = 1;
551

    
552
    return 0;
553
}
554

    
555
/**
556
 * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
557
 */
558
static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
559
{
560
    switch(s->st->codec->codec_id) {
561
        case CODEC_ID_MP2:
562
        case CODEC_ID_MPEG1VIDEO:
563
        case CODEC_ID_MPEG2VIDEO:
564
            if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
565
                int64_t addend;
566

    
567
                int delta_timestamp;
568
                /* XXX: is it really necessary to unify the timestamp base ? */
569
                /* compute pts from timestamp with received ntp_time */
570
                delta_timestamp = timestamp - s->last_rtcp_timestamp;
571
                /* convert to 90 kHz without overflow */
572
                addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
573
                addend = (addend * 5625) >> 14;
574
                pkt->pts = addend + delta_timestamp;
575
            }
576
            break;
577
        case CODEC_ID_AAC:
578
        case CODEC_ID_H264:
579
        case CODEC_ID_MPEG4:
580
            pkt->pts = timestamp;
581
            break;
582
        default:
583
            /* no timestamp info yet */
584
            break;
585
    }
586
    pkt->stream_index = s->st->index;
587
}
588

    
589
/**
590
 * Parse an RTP or RTCP packet directly sent as a buffer.
591
 * @param s RTP parse context.
592
 * @param pkt returned packet
593
 * @param buf input buffer or NULL to read the next packets
594
 * @param len buffer len
595
 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
596
 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
597
 */
598
int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
599
                     const uint8_t *buf, int len)
600
{
601
    unsigned int ssrc, h;
602
    int payload_type, seq, ret;
603
    AVStream *st;
604
    uint32_t timestamp;
605
    int rv= 0;
606

    
607
    if (!buf) {
608
        /* return the next packets, if any */
609
        if(s->st && s->parse_packet) {
610
            timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
611
            rv= s->parse_packet(s, pkt, &timestamp, NULL, 0);
612
            finalize_packet(s, pkt, timestamp);
613
            return rv;
614
        } else {
615
            // TODO: Move to a dynamic packet handler (like above)
616
            if (s->read_buf_index >= s->read_buf_size)
617
                return -1;
618
            ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
619
                                      s->read_buf_size - s->read_buf_index);
620
            if (ret < 0)
621
                return -1;
622
            s->read_buf_index += ret;
623
            if (s->read_buf_index < s->read_buf_size)
624
                return 1;
625
            else
626
                return 0;
627
        }
628
    }
629

    
630
    if (len < 12)
631
        return -1;
632

    
633
    if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
634
        return -1;
635
    if (buf[1] >= 200 && buf[1] <= 204) {
636
        rtcp_parse_packet(s, buf, len);
637
        return -1;
638
    }
639
    payload_type = buf[1] & 0x7f;
640
    seq  = AV_RB16(buf + 2);
641
    timestamp = AV_RB32(buf + 4);
642
    ssrc = AV_RB32(buf + 8);
643
    /* store the ssrc in the RTPDemuxContext */
644
    s->ssrc = ssrc;
645

    
646
    /* NOTE: we can handle only one payload type */
647
    if (s->payload_type != payload_type)
648
        return -1;
649

    
650
    st = s->st;
651
    // only do something with this if all the rtp checks pass...
652
    if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
653
    {
654
        av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
655
               payload_type, seq, ((s->seq + 1) & 0xffff));
656
        return -1;
657
    }
658

    
659
    s->seq = seq;
660
    len -= 12;
661
    buf += 12;
662

    
663
    if (!st) {
664
        /* specific MPEG2TS demux support */
665
        ret = mpegts_parse_packet(s->ts, pkt, buf, len);
666
        if (ret < 0)
667
            return -1;
668
        if (ret < len) {
669
            s->read_buf_size = len - ret;
670
            memcpy(s->buf, buf + ret, s->read_buf_size);
671
            s->read_buf_index = 0;
672
            return 1;
673
        }
674
    } else {
675
        // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
676
        switch(st->codec->codec_id) {
677
        case CODEC_ID_MP2:
678
            /* better than nothing: skip mpeg audio RTP header */
679
            if (len <= 4)
680
                return -1;
681
            h = AV_RB32(buf);
682
            len -= 4;
683
            buf += 4;
684
            av_new_packet(pkt, len);
685
            memcpy(pkt->data, buf, len);
686
            break;
687
        case CODEC_ID_MPEG1VIDEO:
688
        case CODEC_ID_MPEG2VIDEO:
689
            /* better than nothing: skip mpeg video RTP header */
690
            if (len <= 4)
691
                return -1;
692
            h = AV_RB32(buf);
693
            buf += 4;
694
            len -= 4;
695
            if (h & (1 << 26)) {
696
                /* mpeg2 */
697
                if (len <= 4)
698
                    return -1;
699
                buf += 4;
700
                len -= 4;
701
            }
702
            av_new_packet(pkt, len);
703
            memcpy(pkt->data, buf, len);
704
            break;
705
            // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
706
            // timestamps.
707
            // TODO: Put this into a dynamic packet handler...
708
        case CODEC_ID_AAC:
709
            if (rtp_parse_mp4_au(s, buf))
710
                return -1;
711
            {
712
                rtp_payload_data_t *infos = s->rtp_payload_data;
713
                if (infos == NULL)
714
                    return -1;
715
                buf += infos->au_headers_length_bytes + 2;
716
                len -= infos->au_headers_length_bytes + 2;
717

    
718
                /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
719
                    one au_header */
720
                av_new_packet(pkt, infos->au_headers[0].size);
721
                memcpy(pkt->data, buf, infos->au_headers[0].size);
722
                buf += infos->au_headers[0].size;
723
                len -= infos->au_headers[0].size;
724
            }
725
            s->read_buf_size = len;
726
            rv= 0;
727
            break;
728
        default:
729
            if(s->parse_packet) {
730
                rv= s->parse_packet(s, pkt, &timestamp, buf, len);
731
            } else {
732
                av_new_packet(pkt, len);
733
                memcpy(pkt->data, buf, len);
734
            }
735
            break;
736
        }
737

    
738
        // now perform timestamp things....
739
        finalize_packet(s, pkt, timestamp);
740
    }
741
    return rv;
742
}
743

    
744
void rtp_parse_close(RTPDemuxContext *s)
745
{
746
    // TODO: fold this into the protocol specific data fields.
747
    if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
748
        mpegts_parse_close(s->ts);
749
    }
750
    av_free(s);
751
}
752

    
753
/* rtp output */
754

    
755
static int rtp_write_header(AVFormatContext *s1)
756
{
757
    RTPDemuxContext *s = s1->priv_data;
758
    int payload_type, max_packet_size, n;
759
    AVStream *st;
760

    
761
    if (s1->nb_streams != 1)
762
        return -1;
763
    st = s1->streams[0];
764

    
765
    payload_type = rtp_get_payload_type(st->codec);
766
    if (payload_type < 0)
767
        payload_type = RTP_PT_PRIVATE; /* private payload type */
768
    s->payload_type = payload_type;
769

    
770
// following 2 FIXMEs could be set based on the current time, there is normally no info leak, as RTP will likely be transmitted immediately
771
    s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
772
    s->timestamp = s->base_timestamp;
773
    s->cur_timestamp = 0;
774
    s->ssrc = 0; /* FIXME: was random(), what should this be? */
775
    s->first_packet = 1;
776
    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
777

    
778
    max_packet_size = url_fget_max_packet_size(s1->pb);
779
    if (max_packet_size <= 12)
780
        return AVERROR(EIO);
781
    s->max_payload_size = max_packet_size - 12;
782

    
783
    s->max_frames_per_packet = 0;
784
    if (s1->max_delay) {
785
        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
786
            if (st->codec->frame_size == 0) {
787
                av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
788
            } else {
789
                s->max_frames_per_packet = av_rescale_rnd(s1->max_delay, st->codec->sample_rate, AV_TIME_BASE * st->codec->frame_size, AV_ROUND_DOWN);
790
            }
791
        }
792
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
793
            /* FIXME: We should round down here... */
794
            s->max_frames_per_packet = av_rescale_q(s1->max_delay, AV_TIME_BASE_Q, st->codec->time_base);
795
        }
796
    }
797

    
798
    av_set_pts_info(st, 32, 1, 90000);
799
    switch(st->codec->codec_id) {
800
    case CODEC_ID_MP2:
801
    case CODEC_ID_MP3:
802
        s->buf_ptr = s->buf + 4;
803
        break;
804
    case CODEC_ID_MPEG1VIDEO:
805
    case CODEC_ID_MPEG2VIDEO:
806
        break;
807
    case CODEC_ID_MPEG2TS:
808
        n = s->max_payload_size / TS_PACKET_SIZE;
809
        if (n < 1)
810
            n = 1;
811
        s->max_payload_size = n * TS_PACKET_SIZE;
812
        s->buf_ptr = s->buf;
813
        break;
814
    case CODEC_ID_AAC:
815
        s->read_buf_index = 0;
816
    default:
817
        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
818
            av_set_pts_info(st, 32, 1, st->codec->sample_rate);
819
        }
820
        s->buf_ptr = s->buf;
821
        break;
822
    }
823

    
824
    return 0;
825
}
826

    
827
/* send an rtcp sender report packet */
828
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
829
{
830
    RTPDemuxContext *s = s1->priv_data;
831
    uint32_t rtp_ts;
832

    
833
#if defined(DEBUG)
834
    printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
835
#endif
836

    
837
    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
838
    s->last_rtcp_ntp_time = ntp_time;
839
    rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, AV_TIME_BASE_Q,
840
                          s1->streams[0]->time_base) + s->base_timestamp;
841
    put_byte(s1->pb, (RTP_VERSION << 6));
842
    put_byte(s1->pb, 200);
843
    put_be16(s1->pb, 6); /* length in words - 1 */
844
    put_be32(s1->pb, s->ssrc);
845
    put_be32(s1->pb, ntp_time / 1000000);
846
    put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
847
    put_be32(s1->pb, rtp_ts);
848
    put_be32(s1->pb, s->packet_count);
849
    put_be32(s1->pb, s->octet_count);
850
    put_flush_packet(s1->pb);
851
}
852

    
853
/* send an rtp packet. sequence number is incremented, but the caller
854
   must update the timestamp itself */
855
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
856
{
857
    RTPDemuxContext *s = s1->priv_data;
858

    
859
#ifdef DEBUG
860
    printf("rtp_send_data size=%d\n", len);
861
#endif
862

    
863
    /* build the RTP header */
864
    put_byte(s1->pb, (RTP_VERSION << 6));
865
    put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
866
    put_be16(s1->pb, s->seq);
867
    put_be32(s1->pb, s->timestamp);
868
    put_be32(s1->pb, s->ssrc);
869

    
870
    put_buffer(s1->pb, buf1, len);
871
    put_flush_packet(s1->pb);
872

    
873
    s->seq++;
874
    s->octet_count += len;
875
    s->packet_count++;
876
}
877

    
878
/* send an integer number of samples and compute time stamp and fill
879
   the rtp send buffer before sending. */
880
static void rtp_send_samples(AVFormatContext *s1,
881
                             const uint8_t *buf1, int size, int sample_size)
882
{
883
    RTPDemuxContext *s = s1->priv_data;
884
    int len, max_packet_size, n;
885

    
886
    max_packet_size = (s->max_payload_size / sample_size) * sample_size;
887
    /* not needed, but who nows */
888
    if ((size % sample_size) != 0)
889
        av_abort();
890
    n = 0;
891
    while (size > 0) {
892
        s->buf_ptr = s->buf;
893
        len = FFMIN(max_packet_size, size);
894

    
895
        /* copy data */
896
        memcpy(s->buf_ptr, buf1, len);
897
        s->buf_ptr += len;
898
        buf1 += len;
899
        size -= len;
900
        s->timestamp = s->cur_timestamp + n / sample_size;
901
        ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
902
        n += (s->buf_ptr - s->buf);
903
    }
904
}
905

    
906
/* NOTE: we suppose that exactly one frame is given as argument here */
907
/* XXX: test it */
908
static void rtp_send_mpegaudio(AVFormatContext *s1,
909
                               const uint8_t *buf1, int size)
910
{
911
    RTPDemuxContext *s = s1->priv_data;
912
    int len, count, max_packet_size;
913

    
914
    max_packet_size = s->max_payload_size;
915

    
916
    /* test if we must flush because not enough space */
917
    len = (s->buf_ptr - s->buf);
918
    if ((len + size) > max_packet_size) {
919
        if (len > 4) {
920
            ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
921
            s->buf_ptr = s->buf + 4;
922
        }
923
    }
924
    if (s->buf_ptr == s->buf + 4) {
925
        s->timestamp = s->cur_timestamp;
926
    }
927

    
928
    /* add the packet */
929
    if (size > max_packet_size) {
930
        /* big packet: fragment */
931
        count = 0;
932
        while (size > 0) {
933
            len = max_packet_size - 4;
934
            if (len > size)
935
                len = size;
936
            /* build fragmented packet */
937
            s->buf[0] = 0;
938
            s->buf[1] = 0;
939
            s->buf[2] = count >> 8;
940
            s->buf[3] = count;
941
            memcpy(s->buf + 4, buf1, len);
942
            ff_rtp_send_data(s1, s->buf, len + 4, 0);
943
            size -= len;
944
            buf1 += len;
945
            count += len;
946
        }
947
    } else {
948
        if (s->buf_ptr == s->buf + 4) {
949
            /* no fragmentation possible */
950
            s->buf[0] = 0;
951
            s->buf[1] = 0;
952
            s->buf[2] = 0;
953
            s->buf[3] = 0;
954
        }
955
        memcpy(s->buf_ptr, buf1, size);
956
        s->buf_ptr += size;
957
    }
958
}
959

    
960
static void rtp_send_raw(AVFormatContext *s1,
961
                         const uint8_t *buf1, int size)
962
{
963
    RTPDemuxContext *s = s1->priv_data;
964
    int len, max_packet_size;
965

    
966
    max_packet_size = s->max_payload_size;
967

    
968
    while (size > 0) {
969
        len = max_packet_size;
970
        if (len > size)
971
            len = size;
972

    
973
        s->timestamp = s->cur_timestamp;
974
        ff_rtp_send_data(s1, buf1, len, (len == size));
975

    
976
        buf1 += len;
977
        size -= len;
978
    }
979
}
980

    
981
/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
982
static void rtp_send_mpegts_raw(AVFormatContext *s1,
983
                                const uint8_t *buf1, int size)
984
{
985
    RTPDemuxContext *s = s1->priv_data;
986
    int len, out_len;
987

    
988
    while (size >= TS_PACKET_SIZE) {
989
        len = s->max_payload_size - (s->buf_ptr - s->buf);
990
        if (len > size)
991
            len = size;
992
        memcpy(s->buf_ptr, buf1, len);
993
        buf1 += len;
994
        size -= len;
995
        s->buf_ptr += len;
996

    
997
        out_len = s->buf_ptr - s->buf;
998
        if (out_len >= s->max_payload_size) {
999
            ff_rtp_send_data(s1, s->buf, out_len, 0);
1000
            s->buf_ptr = s->buf;
1001
        }
1002
    }
1003
}
1004

    
1005
/* write an RTP packet. 'buf1' must contain a single specific frame. */
1006
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
1007
{
1008
    RTPDemuxContext *s = s1->priv_data;
1009
    AVStream *st = s1->streams[0];
1010
    int rtcp_bytes;
1011
    int size= pkt->size;
1012
    uint8_t *buf1= pkt->data;
1013

    
1014
#ifdef DEBUG
1015
    printf("%d: write len=%d\n", pkt->stream_index, size);
1016
#endif
1017

    
1018
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
1019
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
1020
        RTCP_TX_RATIO_DEN;
1021
    if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
1022
                           (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
1023
        rtcp_send_sr(s1, av_gettime());
1024
        s->last_octet_count = s->octet_count;
1025
        s->first_packet = 0;
1026
    }
1027
    s->cur_timestamp = s->base_timestamp + pkt->pts;
1028

    
1029
    switch(st->codec->codec_id) {
1030
    case CODEC_ID_PCM_MULAW:
1031
    case CODEC_ID_PCM_ALAW:
1032
    case CODEC_ID_PCM_U8:
1033
    case CODEC_ID_PCM_S8:
1034
        rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
1035
        break;
1036
    case CODEC_ID_PCM_U16BE:
1037
    case CODEC_ID_PCM_U16LE:
1038
    case CODEC_ID_PCM_S16BE:
1039
    case CODEC_ID_PCM_S16LE:
1040
        rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
1041
        break;
1042
    case CODEC_ID_MP2:
1043
    case CODEC_ID_MP3:
1044
        rtp_send_mpegaudio(s1, buf1, size);
1045
        break;
1046
    case CODEC_ID_MPEG1VIDEO:
1047
    case CODEC_ID_MPEG2VIDEO:
1048
        ff_rtp_send_mpegvideo(s1, buf1, size);
1049
        break;
1050
    case CODEC_ID_AAC:
1051
        ff_rtp_send_aac(s1, buf1, size);
1052
        break;
1053
    case CODEC_ID_MPEG2TS:
1054
        rtp_send_mpegts_raw(s1, buf1, size);
1055
        break;
1056
    default:
1057
        /* better than nothing : send the codec raw data */
1058
        rtp_send_raw(s1, buf1, size);
1059
        break;
1060
    }
1061
    return 0;
1062
}
1063

    
1064
AVOutputFormat rtp_muxer = {
1065
    "rtp",
1066
    "RTP output format",
1067
    NULL,
1068
    NULL,
1069
    sizeof(RTPDemuxContext),
1070
    CODEC_ID_PCM_MULAW,
1071
    CODEC_ID_NONE,
1072
    rtp_write_header,
1073
    rtp_write_packet,
1074
};