Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtp.c @ 1d1be919

History | View | Annotate | Download (38.1 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 <sys/types.h>
27
#include <sys/socket.h>
28
#include <netinet/in.h>
29
#ifndef __BEOS__
30
# include <arpa/inet.h>
31
#else
32
# include "barpainet.h"
33
#endif
34
#include <netdb.h>
35

    
36
#include "rtp_internal.h"
37
#include "rtp_h264.h"
38

    
39
//#define DEBUG
40

    
41

    
42
/* TODO: - add RTCP statistics reporting (should be optional).
43

44
         - add support for h263/mpeg4 packetized output : IDEA: send a
45
         buffer to 'rtp_write_packet' contains all the packets for ONE
46
         frame. Each packet should have a four byte header containing
47
         the length in big endian format (same trick as
48
         'url_open_dyn_packet_buf')
49
*/
50

    
51
/* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
52
AVRtpPayloadType_t AVRtpPayloadTypes[]=
53
{
54
  {0, "PCMU",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_MULAW, 8000, 1},
55
  {1, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
56
  {2, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
57
  {3, "GSM",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
58
  {4, "G723",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
59
  {5, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
60
  {6, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 16000, 1},
61
  {7, "LPC",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
62
  {8, "PCMA",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_ALAW, 8000, 1},
63
  {9, "G722",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
64
  {10, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 2},
65
  {11, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 1},
66
  {12, "QCELP",      CODEC_TYPE_AUDIO,   CODEC_ID_QCELP, 8000, 1},
67
  {13, "CN",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
68
  {14, "MPA",        CODEC_TYPE_AUDIO,   CODEC_ID_MP2, 90000, -1},
69
  {15, "G728",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
70
  {16, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 11025, 1},
71
  {17, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 22050, 1},
72
  {18, "G729",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
73
  {19, "reserved",   CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
74
  {20, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
75
  {21, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
76
  {22, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
77
  {23, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
78
  {24, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
79
  {25, "CelB",       CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
80
  {26, "JPEG",       CODEC_TYPE_VIDEO,   CODEC_ID_MJPEG, 90000, -1},
81
  {27, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
82
  {28, "nv",         CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
83
  {29, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
84
  {30, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
85
  {31, "H261",       CODEC_TYPE_VIDEO,   CODEC_ID_H261, 90000, -1},
86
  {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG1VIDEO, 90000, -1},
87
  {33, "MP2T",       CODEC_TYPE_DATA,    CODEC_ID_MPEG2TS, 90000, -1},
88
  {34, "H263",       CODEC_TYPE_VIDEO,   CODEC_ID_H263, 90000, -1},
89
  {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
90
  {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
91
  {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
92
  {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
93
  {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
94
  {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
95
  {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
96
  {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
97
  {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
98
  {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
99
  {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
100
  {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
101
  {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
102
  {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
103
  {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
104
  {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
105
  {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
106
  {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
107
  {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
108
  {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
109
  {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
110
  {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
111
  {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
112
  {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
113
  {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
114
  {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
115
  {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
116
  {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
117
  {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
118
  {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
119
  {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
120
  {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
121
  {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
122
  {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
123
  {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
124
  {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
125
  {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
126
  {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
127
  {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
128
  {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
129
  {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
130
  {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
131
  {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
132
  {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
133
  {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
134
  {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
135
  {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
136
  {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
137
  {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
138
  {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
139
  {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
140
  {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
141
  {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
142
  {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
143
  {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
144
  {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
145
  {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
146
  {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
147
  {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
148
  {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
149
  {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
150
  {96, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
151
  {97, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
152
  {98, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
153
  {99, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
154
  {100, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
155
  {101, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
156
  {102, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
157
  {103, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
158
  {104, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
159
  {105, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
160
  {106, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
161
  {107, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
162
  {108, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
163
  {109, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
164
  {110, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
165
  {111, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
166
  {112, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
167
  {113, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
168
  {114, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
169
  {115, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
170
  {116, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
171
  {117, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
172
  {118, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
173
  {119, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
174
  {120, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
175
  {121, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
176
  {122, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
177
  {123, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
178
  {124, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
179
  {125, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
180
  {126, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
181
  {127, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
182
  {-1, "",           CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
183
};
184

    
185
/* statistics functions */
186
RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
187

    
188
static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
189
static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_MPEG4AAC};
190

    
191
static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
192
{
193
    handler->next= RTPFirstDynamicPayloadHandler;
194
    RTPFirstDynamicPayloadHandler= handler;
195
}
196

    
197
void av_register_rtp_dynamic_payload_handlers()
198
{
199
    register_dynamic_payload_handler(&mp4v_es_handler);
200
    register_dynamic_payload_handler(&mpeg4_generic_handler);
201
    register_dynamic_payload_handler(&ff_h264_dynamic_handler);
202
}
203

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

    
218
/* return < 0 if unknown payload type */
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
static inline uint32_t decode_be32(const uint8_t *p)
235
{
236
    return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
237
}
238

    
239
static inline uint64_t decode_be64(const uint8_t *p)
240
{
241
    return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
242
}
243

    
244
static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
245
{
246
    if (buf[1] != 200)
247
        return -1;
248
    s->last_rtcp_ntp_time = decode_be64(buf + 8);
249
    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
250
        s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
251
    s->last_rtcp_timestamp = decode_be32(buf + 16);
252
    return 0;
253
}
254

    
255
#define RTP_SEQ_MOD (1<<16)
256

    
257
/**
258
* called on parse open packet
259
*/
260
static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
261
{
262
    memset(s, 0, sizeof(RTPStatistics));
263
    s->max_seq= base_sequence;
264
    s->probation= 1;
265
}
266

    
267
/**
268
* called whenever there is a large jump in sequence numbers, or when they get out of probation...
269
*/
270
static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
271
{
272
    s->max_seq= seq;
273
    s->cycles= 0;
274
    s->base_seq= seq -1;
275
    s->bad_seq= RTP_SEQ_MOD + 1;
276
    s->received= 0;
277
    s->expected_prior= 0;
278
    s->received_prior= 0;
279
    s->jitter= 0;
280
    s->transit= 0;
281
}
282

    
283
/**
284
* returns 1 if we should handle this packet.
285
*/
286
static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
287
{
288
    uint16_t udelta= seq - s->max_seq;
289
    const int MAX_DROPOUT= 3000;
290
    const int MAX_MISORDER = 100;
291
    const int MIN_SEQUENTIAL = 2;
292

    
293
    /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
294
    if(s->probation)
295
    {
296
        if(seq==s->max_seq + 1) {
297
            s->probation--;
298
            s->max_seq= seq;
299
            if(s->probation==0) {
300
                rtp_init_sequence(s, seq);
301
                s->received++;
302
                return 1;
303
            }
304
        } else {
305
            s->probation= MIN_SEQUENTIAL - 1;
306
            s->max_seq = seq;
307
        }
308
    } else if (udelta < MAX_DROPOUT) {
309
        // in order, with permissible gap
310
        if(seq < s->max_seq) {
311
            //sequence number wrapped; count antother 64k cycles
312
            s->cycles += RTP_SEQ_MOD;
313
        }
314
        s->max_seq= seq;
315
    } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
316
        // sequence made a large jump...
317
        if(seq==s->bad_seq) {
318
            // two sequential packets-- assume that the other side restarted without telling us; just resync.
319
            rtp_init_sequence(s, seq);
320
        } else {
321
            s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
322
            return 0;
323
        }
324
    } else {
325
        // duplicate or reordered packet...
326
    }
327
    s->received++;
328
    return 1;
329
}
330

    
331
#if 0
332
/**
333
* This function is currently unused; without a valid local ntp time, I don't see how we could calculate the
334
* difference between the arrival and sent timestamp.  As a result, the jitter and transit statistics values
335
* never change.  I left this in in case someone else can see a way. (rdm)
336
*/
337
static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
338
{
339
    uint32_t transit= arrival_timestamp - sent_timestamp;
340
    int d;
341
    s->transit= transit;
342
    d= FFABS(transit - s->transit);
343
    s->jitter += d - ((s->jitter + 8)>>4);
344
}
345
#endif
346

    
347
/**
348
 * some rtp servers assume client is dead if they don't hear from them...
349
 * so we send a Receiver Report to the provided ByteIO context
350
 * (we don't have access to the rtcp handle from here)
351
 */
352
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
353
{
354
    ByteIOContext pb;
355
    uint8_t *buf;
356
    int len;
357
    int rtcp_bytes;
358
    RTPStatistics *stats= &s->statistics;
359
    uint32_t lost;
360
    uint32_t extended_max;
361
    uint32_t expected_interval;
362
    uint32_t received_interval;
363
    uint32_t lost_interval;
364
    uint32_t expected;
365
    uint32_t fraction;
366
    uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
367

    
368
    if (!s->rtp_ctx || (count < 1))
369
        return -1;
370

    
371
    /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
372
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
373
    s->octet_count += count;
374
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
375
        RTCP_TX_RATIO_DEN;
376
    rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
377
    if (rtcp_bytes < 28)
378
        return -1;
379
    s->last_octet_count = s->octet_count;
380

    
381
    if (url_open_dyn_buf(&pb) < 0)
382
        return -1;
383

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

    
404
    fraction= (fraction<<24) | lost;
405

    
406
    put_be32(&pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
407
    put_be32(&pb, extended_max); /* max sequence received */
408
    put_be32(&pb, stats->jitter>>4); /* jitter */
409

    
410
    if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
411
    {
412
        put_be32(&pb, 0); /* last SR timestamp */
413
        put_be32(&pb, 0); /* delay since last SR */
414
    } else {
415
        uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
416
        uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
417

    
418
        put_be32(&pb, middle_32_bits); /* last SR timestamp */
419
        put_be32(&pb, delay_since_last); /* delay since last SR */
420
    }
421

    
422
    // CNAME
423
    put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
424
    put_byte(&pb, 202);
425
    len = strlen(s->hostname);
426
    put_be16(&pb, (6 + len + 3) / 4); /* length in words - 1 */
427
    put_be32(&pb, s->ssrc);
428
    put_byte(&pb, 0x01);
429
    put_byte(&pb, len);
430
    put_buffer(&pb, s->hostname, len);
431
    // padding
432
    for (len = (6 + len) % 4; len % 4; len++) {
433
        put_byte(&pb, 0);
434
    }
435

    
436
    put_flush_packet(&pb);
437
    len = url_close_dyn_buf(&pb, &buf);
438
    if ((len > 0) && buf) {
439
        int result;
440
#if defined(DEBUG)
441
        printf("sending %d bytes of RR\n", len);
442
#endif
443
        result= url_write(s->rtp_ctx, buf, len);
444
#if defined(DEBUG)
445
        printf("result from url_write: %d\n", result);
446
#endif
447
        av_free(buf);
448
    }
449
    return 0;
450
}
451

    
452
/**
453
 * open a new RTP parse context for stream 'st'. 'st' can be NULL for
454
 * MPEG2TS streams to indicate that they should be demuxed inside the
455
 * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
456
 * TODO: change this to not take rtp_payload data, and use the new dynamic payload system.
457
 */
458
RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
459
{
460
    RTPDemuxContext *s;
461

    
462
    s = av_mallocz(sizeof(RTPDemuxContext));
463
    if (!s)
464
        return NULL;
465
    s->payload_type = payload_type;
466
    s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
467
    s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
468
    s->ic = s1;
469
    s->st = st;
470
    s->rtp_payload_data = rtp_payload_data;
471
    rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
472
    if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
473
        s->ts = mpegts_parse_open(s->ic);
474
        if (s->ts == NULL) {
475
            av_free(s);
476
            return NULL;
477
        }
478
    } else {
479
        switch(st->codec->codec_id) {
480
        case CODEC_ID_MPEG1VIDEO:
481
        case CODEC_ID_MPEG2VIDEO:
482
        case CODEC_ID_MP2:
483
        case CODEC_ID_MP3:
484
        case CODEC_ID_MPEG4:
485
        case CODEC_ID_H264:
486
            st->need_parsing = 1;
487
            break;
488
        default:
489
            break;
490
        }
491
    }
492
    // needed to send back RTCP RR in RTSP sessions
493
    s->rtp_ctx = rtpc;
494
    gethostname(s->hostname, sizeof(s->hostname));
495
    return s;
496
}
497

    
498
static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
499
{
500
    int au_headers_length, au_header_size, i;
501
    GetBitContext getbitcontext;
502
    rtp_payload_data_t *infos;
503

    
504
    infos = s->rtp_payload_data;
505

    
506
    if (infos == NULL)
507
        return -1;
508

    
509
    /* decode the first 2 bytes where are stored the AUHeader sections
510
       length in bits */
511
    au_headers_length = BE_16(buf);
512

    
513
    if (au_headers_length > RTP_MAX_PACKET_LENGTH)
514
      return -1;
515

    
516
    infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
517

    
518
    /* skip AU headers length section (2 bytes) */
519
    buf += 2;
520

    
521
    init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
522

    
523
    /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
524
    au_header_size = infos->sizelength + infos->indexlength;
525
    if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
526
        return -1;
527

    
528
    infos->nb_au_headers = au_headers_length / au_header_size;
529
    infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
530

    
531
    /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
532
       In my test, the faad decoder doesnt behave correctly when sending each AU one by one
533
       but does when sending the whole as one big packet...  */
534
    infos->au_headers[0].size = 0;
535
    infos->au_headers[0].index = 0;
536
    for (i = 0; i < infos->nb_au_headers; ++i) {
537
        infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
538
        infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
539
    }
540

    
541
    infos->nb_au_headers = 1;
542

    
543
    return 0;
544
}
545

    
546
/**
547
 * This was the second switch in rtp_parse packet.  Normalizes time, if required, sets stream_index, etc.
548
 */
549
static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
550
{
551
    switch(s->st->codec->codec_id) {
552
        case CODEC_ID_MP2:
553
        case CODEC_ID_MPEG1VIDEO:
554
            if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
555
                int64_t addend;
556

    
557
                int delta_timestamp;
558
                /* XXX: is it really necessary to unify the timestamp base ? */
559
                /* compute pts from timestamp with received ntp_time */
560
                delta_timestamp = timestamp - s->last_rtcp_timestamp;
561
                /* convert to 90 kHz without overflow */
562
                addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
563
                addend = (addend * 5625) >> 14;
564
                pkt->pts = addend + delta_timestamp;
565
            }
566
            break;
567
        case CODEC_ID_MPEG4AAC:
568
        case CODEC_ID_H264:
569
        case CODEC_ID_MPEG4:
570
            pkt->pts = timestamp;
571
            break;
572
        default:
573
            /* no timestamp info yet */
574
            break;
575
    }
576
    pkt->stream_index = s->st->index;
577
}
578

    
579
/**
580
 * Parse an RTP or RTCP packet directly sent as a buffer.
581
 * @param s RTP parse context.
582
 * @param pkt returned packet
583
 * @param buf input buffer or NULL to read the next packets
584
 * @param len buffer len
585
 * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
586
 * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
587
 */
588
int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
589
                     const uint8_t *buf, int len)
590
{
591
    unsigned int ssrc, h;
592
    int payload_type, seq, ret;
593
    AVStream *st;
594
    uint32_t timestamp;
595
    int rv= 0;
596

    
597
    if (!buf) {
598
        /* return the next packets, if any */
599
        if(s->st && s->parse_packet) {
600
            timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned....
601
            rv= s->parse_packet(s, pkt, &timestamp, NULL, 0);
602
            finalize_packet(s, pkt, timestamp);
603
            return rv;
604
        } else {
605
            // TODO: Move to a dynamic packet handler (like above)
606
            if (s->read_buf_index >= s->read_buf_size)
607
                return -1;
608
            ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
609
                                      s->read_buf_size - s->read_buf_index);
610
            if (ret < 0)
611
                return -1;
612
            s->read_buf_index += ret;
613
            if (s->read_buf_index < s->read_buf_size)
614
                return 1;
615
            else
616
                return 0;
617
        }
618
    }
619

    
620
    if (len < 12)
621
        return -1;
622

    
623
    if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
624
        return -1;
625
    if (buf[1] >= 200 && buf[1] <= 204) {
626
        rtcp_parse_packet(s, buf, len);
627
        return -1;
628
    }
629
    payload_type = buf[1] & 0x7f;
630
    seq  = (buf[2] << 8) | buf[3];
631
    timestamp = decode_be32(buf + 4);
632
    ssrc = decode_be32(buf + 8);
633
    /* store the ssrc in the RTPDemuxContext */
634
    s->ssrc = ssrc;
635

    
636
    /* NOTE: we can handle only one payload type */
637
    if (s->payload_type != payload_type)
638
        return -1;
639

    
640
    st = s->st;
641
    // only do something with this if all the rtp checks pass...
642
    if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
643
    {
644
        av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
645
               payload_type, seq, ((s->seq + 1) & 0xffff));
646
        return -1;
647
    }
648

    
649
    s->seq = seq;
650
    len -= 12;
651
    buf += 12;
652

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

    
707
                /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
708
                    one au_header */
709
                av_new_packet(pkt, infos->au_headers[0].size);
710
                memcpy(pkt->data, buf, infos->au_headers[0].size);
711
                buf += infos->au_headers[0].size;
712
                len -= infos->au_headers[0].size;
713
            }
714
            s->read_buf_size = len;
715
            s->buf_ptr = buf;
716
            rv= 0;
717
            break;
718
        default:
719
            if(s->parse_packet) {
720
                rv= s->parse_packet(s, pkt, &timestamp, buf, len);
721
            } else {
722
                av_new_packet(pkt, len);
723
                memcpy(pkt->data, buf, len);
724
            }
725
            break;
726
        }
727

    
728
        // now perform timestamp things....
729
        finalize_packet(s, pkt, timestamp);
730
    }
731
    return rv;
732
}
733

    
734
void rtp_parse_close(RTPDemuxContext *s)
735
{
736
    // TODO: fold this into the protocol specific data fields.
737
    if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
738
        mpegts_parse_close(s->ts);
739
    }
740
    av_free(s);
741
}
742

    
743
/* rtp output */
744

    
745
static int rtp_write_header(AVFormatContext *s1)
746
{
747
    RTPDemuxContext *s = s1->priv_data;
748
    int payload_type, max_packet_size, n;
749
    AVStream *st;
750

    
751
    if (s1->nb_streams != 1)
752
        return -1;
753
    st = s1->streams[0];
754

    
755
    payload_type = rtp_get_payload_type(st->codec);
756
    if (payload_type < 0)
757
        payload_type = RTP_PT_PRIVATE; /* private payload type */
758
    s->payload_type = payload_type;
759

    
760
// following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
761
    s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
762
    s->timestamp = s->base_timestamp;
763
    s->ssrc = 0; /* FIXME: was random(), what should this be? */
764
    s->first_packet = 1;
765

    
766
    max_packet_size = url_fget_max_packet_size(&s1->pb);
767
    if (max_packet_size <= 12)
768
        return AVERROR_IO;
769
    s->max_payload_size = max_packet_size - 12;
770

    
771
    switch(st->codec->codec_id) {
772
    case CODEC_ID_MP2:
773
    case CODEC_ID_MP3:
774
        s->buf_ptr = s->buf + 4;
775
        s->cur_timestamp = 0;
776
        break;
777
    case CODEC_ID_MPEG1VIDEO:
778
        s->cur_timestamp = 0;
779
        break;
780
    case CODEC_ID_MPEG2TS:
781
        n = s->max_payload_size / TS_PACKET_SIZE;
782
        if (n < 1)
783
            n = 1;
784
        s->max_payload_size = n * TS_PACKET_SIZE;
785
        s->buf_ptr = s->buf;
786
        break;
787
    default:
788
        s->buf_ptr = s->buf;
789
        break;
790
    }
791

    
792
    return 0;
793
}
794

    
795
/* send an rtcp sender report packet */
796
static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
797
{
798
    RTPDemuxContext *s = s1->priv_data;
799
#if defined(DEBUG)
800
    printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
801
#endif
802
    put_byte(&s1->pb, (RTP_VERSION << 6));
803
    put_byte(&s1->pb, 200);
804
    put_be16(&s1->pb, 6); /* length in words - 1 */
805
    put_be32(&s1->pb, s->ssrc);
806
    put_be64(&s1->pb, ntp_time);
807
    put_be32(&s1->pb, s->timestamp);
808
    put_be32(&s1->pb, s->packet_count);
809
    put_be32(&s1->pb, s->octet_count);
810
    put_flush_packet(&s1->pb);
811
}
812

    
813
/* send an rtp packet. sequence number is incremented, but the caller
814
   must update the timestamp itself */
815
static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
816
{
817
    RTPDemuxContext *s = s1->priv_data;
818

    
819
#ifdef DEBUG
820
    printf("rtp_send_data size=%d\n", len);
821
#endif
822

    
823
    /* build the RTP header */
824
    put_byte(&s1->pb, (RTP_VERSION << 6));
825
    put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
826
    put_be16(&s1->pb, s->seq);
827
    put_be32(&s1->pb, s->timestamp);
828
    put_be32(&s1->pb, s->ssrc);
829

    
830
    put_buffer(&s1->pb, buf1, len);
831
    put_flush_packet(&s1->pb);
832

    
833
    s->seq++;
834
    s->octet_count += len;
835
    s->packet_count++;
836
}
837

    
838
/* send an integer number of samples and compute time stamp and fill
839
   the rtp send buffer before sending. */
840
static void rtp_send_samples(AVFormatContext *s1,
841
                             const uint8_t *buf1, int size, int sample_size)
842
{
843
    RTPDemuxContext *s = s1->priv_data;
844
    int len, max_packet_size, n;
845

    
846
    max_packet_size = (s->max_payload_size / sample_size) * sample_size;
847
    /* not needed, but who nows */
848
    if ((size % sample_size) != 0)
849
        av_abort();
850
    while (size > 0) {
851
        len = (max_packet_size - (s->buf_ptr - s->buf));
852
        if (len > size)
853
            len = size;
854

    
855
        /* copy data */
856
        memcpy(s->buf_ptr, buf1, len);
857
        s->buf_ptr += len;
858
        buf1 += len;
859
        size -= len;
860
        n = (s->buf_ptr - s->buf);
861
        /* if buffer full, then send it */
862
        if (n >= max_packet_size) {
863
            rtp_send_data(s1, s->buf, n, 0);
864
            s->buf_ptr = s->buf;
865
            /* update timestamp */
866
            s->timestamp += n / sample_size;
867
        }
868
    }
869
}
870

    
871
/* NOTE: we suppose that exactly one frame is given as argument here */
872
/* XXX: test it */
873
static void rtp_send_mpegaudio(AVFormatContext *s1,
874
                               const uint8_t *buf1, int size)
875
{
876
    RTPDemuxContext *s = s1->priv_data;
877
    AVStream *st = s1->streams[0];
878
    int len, count, max_packet_size;
879

    
880
    max_packet_size = s->max_payload_size;
881

    
882
    /* test if we must flush because not enough space */
883
    len = (s->buf_ptr - s->buf);
884
    if ((len + size) > max_packet_size) {
885
        if (len > 4) {
886
            rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
887
            s->buf_ptr = s->buf + 4;
888
            /* 90 KHz time stamp */
889
            s->timestamp = s->base_timestamp +
890
                (s->cur_timestamp * 90000LL) / st->codec->sample_rate;
891
        }
892
    }
893

    
894
    /* add the packet */
895
    if (size > max_packet_size) {
896
        /* big packet: fragment */
897
        count = 0;
898
        while (size > 0) {
899
            len = max_packet_size - 4;
900
            if (len > size)
901
                len = size;
902
            /* build fragmented packet */
903
            s->buf[0] = 0;
904
            s->buf[1] = 0;
905
            s->buf[2] = count >> 8;
906
            s->buf[3] = count;
907
            memcpy(s->buf + 4, buf1, len);
908
            rtp_send_data(s1, s->buf, len + 4, 0);
909
            size -= len;
910
            buf1 += len;
911
            count += len;
912
        }
913
    } else {
914
        if (s->buf_ptr == s->buf + 4) {
915
            /* no fragmentation possible */
916
            s->buf[0] = 0;
917
            s->buf[1] = 0;
918
            s->buf[2] = 0;
919
            s->buf[3] = 0;
920
        }
921
        memcpy(s->buf_ptr, buf1, size);
922
        s->buf_ptr += size;
923
    }
924
    s->cur_timestamp += st->codec->frame_size;
925
}
926

    
927
/* NOTE: a single frame must be passed with sequence header if
928
   needed. XXX: use slices. */
929
static void rtp_send_mpegvideo(AVFormatContext *s1,
930
                               const uint8_t *buf1, int size)
931
{
932
    RTPDemuxContext *s = s1->priv_data;
933
    AVStream *st = s1->streams[0];
934
    int len, h, max_packet_size;
935
    uint8_t *q;
936

    
937
    max_packet_size = s->max_payload_size;
938

    
939
    while (size > 0) {
940
        /* XXX: more correct headers */
941
        h = 0;
942
        if (st->codec->sub_id == 2)
943
            h |= 1 << 26; /* mpeg 2 indicator */
944
        q = s->buf;
945
        *q++ = h >> 24;
946
        *q++ = h >> 16;
947
        *q++ = h >> 8;
948
        *q++ = h;
949

    
950
        if (st->codec->sub_id == 2) {
951
            h = 0;
952
            *q++ = h >> 24;
953
            *q++ = h >> 16;
954
            *q++ = h >> 8;
955
            *q++ = h;
956
        }
957

    
958
        len = max_packet_size - (q - s->buf);
959
        if (len > size)
960
            len = size;
961

    
962
        memcpy(q, buf1, len);
963
        q += len;
964

    
965
        /* 90 KHz time stamp */
966
        s->timestamp = s->base_timestamp +
967
            av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
968
        rtp_send_data(s1, s->buf, q - s->buf, (len == size));
969

    
970
        buf1 += len;
971
        size -= len;
972
    }
973
    s->cur_timestamp++;
974
}
975

    
976
static void rtp_send_raw(AVFormatContext *s1,
977
                         const uint8_t *buf1, int size)
978
{
979
    RTPDemuxContext *s = s1->priv_data;
980
    AVStream *st = s1->streams[0];
981
    int len, max_packet_size;
982

    
983
    max_packet_size = s->max_payload_size;
984

    
985
    while (size > 0) {
986
        len = max_packet_size;
987
        if (len > size)
988
            len = size;
989

    
990
        /* 90 KHz time stamp */
991
        s->timestamp = s->base_timestamp +
992
            av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
993
        rtp_send_data(s1, buf1, len, (len == size));
994

    
995
        buf1 += len;
996
        size -= len;
997
    }
998
    s->cur_timestamp++;
999
}
1000

    
1001
/* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
1002
static void rtp_send_mpegts_raw(AVFormatContext *s1,
1003
                                const uint8_t *buf1, int size)
1004
{
1005
    RTPDemuxContext *s = s1->priv_data;
1006
    int len, out_len;
1007

    
1008
    while (size >= TS_PACKET_SIZE) {
1009
        len = s->max_payload_size - (s->buf_ptr - s->buf);
1010
        if (len > size)
1011
            len = size;
1012
        memcpy(s->buf_ptr, buf1, len);
1013
        buf1 += len;
1014
        size -= len;
1015
        s->buf_ptr += len;
1016

    
1017
        out_len = s->buf_ptr - s->buf;
1018
        if (out_len >= s->max_payload_size) {
1019
            rtp_send_data(s1, s->buf, out_len, 0);
1020
            s->buf_ptr = s->buf;
1021
        }
1022
    }
1023
}
1024

    
1025
/* write an RTP packet. 'buf1' must contain a single specific frame. */
1026
static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
1027
{
1028
    RTPDemuxContext *s = s1->priv_data;
1029
    AVStream *st = s1->streams[0];
1030
    int rtcp_bytes;
1031
    int64_t ntp_time;
1032
    int size= pkt->size;
1033
    uint8_t *buf1= pkt->data;
1034

    
1035
#ifdef DEBUG
1036
    printf("%d: write len=%d\n", pkt->stream_index, size);
1037
#endif
1038

    
1039
    /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
1040
    rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
1041
        RTCP_TX_RATIO_DEN;
1042
    if (s->first_packet || rtcp_bytes >= 28) {
1043
        /* compute NTP time */
1044
        /* XXX: 90 kHz timestamp hardcoded */
1045
        ntp_time = (pkt->pts << 28) / 5625;
1046
        rtcp_send_sr(s1, ntp_time);
1047
        s->last_octet_count = s->octet_count;
1048
        s->first_packet = 0;
1049
    }
1050

    
1051
    switch(st->codec->codec_id) {
1052
    case CODEC_ID_PCM_MULAW:
1053
    case CODEC_ID_PCM_ALAW:
1054
    case CODEC_ID_PCM_U8:
1055
    case CODEC_ID_PCM_S8:
1056
        rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
1057
        break;
1058
    case CODEC_ID_PCM_U16BE:
1059
    case CODEC_ID_PCM_U16LE:
1060
    case CODEC_ID_PCM_S16BE:
1061
    case CODEC_ID_PCM_S16LE:
1062
        rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
1063
        break;
1064
    case CODEC_ID_MP2:
1065
    case CODEC_ID_MP3:
1066
        rtp_send_mpegaudio(s1, buf1, size);
1067
        break;
1068
    case CODEC_ID_MPEG1VIDEO:
1069
        rtp_send_mpegvideo(s1, buf1, size);
1070
        break;
1071
    case CODEC_ID_MPEG2TS:
1072
        rtp_send_mpegts_raw(s1, buf1, size);
1073
        break;
1074
    default:
1075
        /* better than nothing : send the codec raw data */
1076
        rtp_send_raw(s1, buf1, size);
1077
        break;
1078
    }
1079
    return 0;
1080
}
1081

    
1082
static int rtp_write_trailer(AVFormatContext *s1)
1083
{
1084
    //    RTPDemuxContext *s = s1->priv_data;
1085
    return 0;
1086
}
1087

    
1088
AVOutputFormat rtp_muxer = {
1089
    "rtp",
1090
    "RTP output format",
1091
    NULL,
1092
    NULL,
1093
    sizeof(RTPDemuxContext),
1094
    CODEC_ID_PCM_MULAW,
1095
    CODEC_ID_NONE,
1096
    rtp_write_header,
1097
    rtp_write_packet,
1098
    rtp_write_trailer,
1099
};