git.sesse.net Git - ffmpeg/blob - libavformat/rtp.c

   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 //#define DEBUG
  37
  38
  39 /* TODO: - add RTCP statistics reporting (should be optional).
  40
  41          - add support for h263/mpeg4 packetized output : IDEA: send a
  42          buffer to 'rtp_write_packet' contains all the packets for ONE
  43          frame. Each packet should have a four byte header containing
  44          the length in big endian format (same trick as
  45          'url_open_dyn_packet_buf')
  46 */
  47
  48 /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
  49 AVRtpPayloadType_t AVRtpPayloadTypes[]=
  50 {
  51   {0, "PCMU",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_MULAW, 8000, 1},
  52   {1, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  53   {2, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  54   {3, "GSM",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  55   {4, "G723",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  56   {5, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  57   {6, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 16000, 1},
  58   {7, "LPC",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  59   {8, "PCMA",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_ALAW, 8000, 1},
  60   {9, "G722",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  61   {10, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 2},
  62   {11, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 1},
  63   {12, "QCELP",      CODEC_TYPE_AUDIO,   CODEC_ID_QCELP, 8000, 1},
  64   {13, "CN",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  65   {14, "MPA",        CODEC_TYPE_AUDIO,   CODEC_ID_MP2, 90000, -1},
  66   {15, "G728",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  67   {16, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 11025, 1},
  68   {17, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 22050, 1},
  69   {18, "G729",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
  70   {19, "reserved",   CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
  71   {20, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
  72   {21, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
  73   {22, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
  74   {23, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
  75   {24, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
  76   {25, "CelB",       CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
  77   {26, "JPEG",       CODEC_TYPE_VIDEO,   CODEC_ID_MJPEG, 90000, -1},
  78   {27, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
  79   {28, "nv",         CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
  80   {29, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
  81   {30, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
  82   {31, "H261",       CODEC_TYPE_VIDEO,   CODEC_ID_H261, 90000, -1},
  83   {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG1VIDEO, 90000, -1},
  84   {33, "MP2T",       CODEC_TYPE_DATA,    CODEC_ID_MPEG2TS, 90000, -1},
  85   {34, "H263",       CODEC_TYPE_VIDEO,   CODEC_ID_H263, 90000, -1},
  86   {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  87   {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  88   {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  89   {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  90   {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  91   {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  92   {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  93   {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  94   {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  95   {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  96   {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  97   {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  98   {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
  99   {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 100   {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 101   {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 102   {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 103   {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 104   {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 105   {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 106   {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 107   {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 108   {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 109   {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 110   {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 111   {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 112   {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 113   {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 114   {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 115   {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 116   {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 117   {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 118   {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 119   {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 120   {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 121   {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 122   {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 123   {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 124   {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 125   {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 126   {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 127   {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 128   {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 129   {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 130   {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 131   {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 132   {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 133   {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 134   {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 135   {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 136   {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 137   {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 138   {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 139   {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 140   {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 141   {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 142   {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 143   {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 144   {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 145   {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 146   {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 147   {96, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 148   {97, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 149   {98, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 150   {99, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 151   {100, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 152   {101, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 153   {102, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 154   {103, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 155   {104, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 156   {105, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 157   {106, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 158   {107, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 159   {108, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 160   {109, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 161   {110, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 162   {111, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 163   {112, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 164   {113, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 165   {114, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 166   {115, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 167   {116, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 168   {117, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 169   {118, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 170   {119, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 171   {120, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 172   {121, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 173   {122, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 174   {123, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 175   {124, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 176   {125, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 177   {126, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 178   {127, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
 179   {-1, "",           CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
 180 };
 181
 182 AVRtpDynamicPayloadType_t AVRtpDynamicPayloadTypes[]=
 183 {
 184     {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4},
 185     {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_MPEG4AAC},
 186     {"", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE}
 187 };
 188
 189 struct RTPDemuxContext {
 190     AVFormatContext *ic;
 191     AVStream *st;
 192     int payload_type;
 193     uint32_t ssrc;
 194     uint16_t seq;
 195     uint32_t timestamp;
 196     uint32_t base_timestamp;
 197     uint32_t cur_timestamp;
 198     int max_payload_size;
 199     MpegTSContext *ts; /* only used for MP2T payloads */
 200     int read_buf_index;
 201     int read_buf_size;
 202
 203     /* rtcp sender statistics receive */
 204     int64_t last_rtcp_ntp_time;
 205     int64_t first_rtcp_ntp_time;
 206     uint32_t last_rtcp_timestamp;
 207     /* rtcp sender statistics */
 208     unsigned int packet_count;
 209     unsigned int octet_count;
 210     unsigned int last_octet_count;
 211     int first_packet;
 212     /* buffer for output */
 213     uint8_t buf[RTP_MAX_PACKET_LENGTH];
 214     uint8_t *buf_ptr;
 215     /* special infos for au headers parsing */
 216     rtp_payload_data_t *rtp_payload_data;
 217 };
 218
 219 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
 220 {
 221     if (AVRtpPayloadTypes[payload_type].codec_id != CODEC_ID_NONE) {
 222         codec->codec_type = AVRtpPayloadTypes[payload_type].codec_type;
 223         codec->codec_id = AVRtpPayloadTypes[payload_type].codec_id;
 224         if (AVRtpPayloadTypes[payload_type].audio_channels > 0)
 225             codec->channels = AVRtpPayloadTypes[payload_type].audio_channels;
 226         if (AVRtpPayloadTypes[payload_type].clock_rate > 0)
 227             codec->sample_rate = AVRtpPayloadTypes[payload_type].clock_rate;
 228         return 0;
 229     }
 230     return -1;
 231 }
 232
 233 /* return < 0 if unknown payload type */
 234 int rtp_get_payload_type(AVCodecContext *codec)
 235 {
 236     int i, payload_type;
 237
 238     /* compute the payload type */
 239     for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
 240         if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
 241             if (codec->codec_id == CODEC_ID_PCM_S16BE)
 242                 if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
 243                     continue;
 244             payload_type = AVRtpPayloadTypes[i].pt;
 245         }
 246     return payload_type;
 247 }
 248
 249 static inline uint32_t decode_be32(const uint8_t *p)
 250 {
 251     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 252 }
 253
 254 static inline uint64_t decode_be64(const uint8_t *p)
 255 {
 256     return ((uint64_t)decode_be32(p) << 32) | decode_be32(p + 4);
 257 }
 258
 259 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
 260 {
 261     if (buf[1] != 200)
 262         return -1;
 263     s->last_rtcp_ntp_time = decode_be64(buf + 8);
 264     if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
 265         s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
 266     s->last_rtcp_timestamp = decode_be32(buf + 16);
 267     return 0;
 268 }
 269
 270 /**
 271  * open a new RTP parse context for stream 'st'. 'st' can be NULL for
 272  * MPEG2TS streams to indicate that they should be demuxed inside the
 273  * rtp demux (otherwise CODEC_ID_MPEG2TS packets are returned)
 274  */
 275 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_type, rtp_payload_data_t *rtp_payload_data)
 276 {
 277     RTPDemuxContext *s;
 278
 279     s = av_mallocz(sizeof(RTPDemuxContext));
 280     if (!s)
 281         return NULL;
 282     s->payload_type = payload_type;
 283     s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
 284     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
 285     s->ic = s1;
 286     s->st = st;
 287     s->rtp_payload_data = rtp_payload_data;
 288     if (!strcmp(AVRtpPayloadTypes[payload_type].enc_name, "MP2T")) {
 289         s->ts = mpegts_parse_open(s->ic);
 290         if (s->ts == NULL) {
 291             av_free(s);
 292             return NULL;
 293         }
 294     } else {
 295         switch(st->codec->codec_id) {
 296         case CODEC_ID_MPEG1VIDEO:
 297         case CODEC_ID_MPEG2VIDEO:
 298         case CODEC_ID_MP2:
 299         case CODEC_ID_MP3:
 300         case CODEC_ID_MPEG4:
 301             st->need_parsing = 1;
 302             break;
 303         default:
 304             break;
 305         }
 306     }
 307     return s;
 308 }
 309
 310 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
 311 {
 312     int au_headers_length, au_header_size, i;
 313     GetBitContext getbitcontext;
 314     rtp_payload_data_t *infos;
 315
 316     infos = s->rtp_payload_data;
 317
 318     if (infos == NULL)
 319         return -1;
 320
 321     /* decode the first 2 bytes where are stored the AUHeader sections
 322        length in bits */
 323     au_headers_length = BE_16(buf);
 324
 325     if (au_headers_length > RTP_MAX_PACKET_LENGTH)
 326       return -1;
 327
 328     infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
 329
 330     /* skip AU headers length section (2 bytes) */
 331     buf += 2;
 332
 333     init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
 334
 335     /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
 336     au_header_size = infos->sizelength + infos->indexlength;
 337     if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
 338         return -1;
 339
 340     infos->nb_au_headers = au_headers_length / au_header_size;
 341     infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
 342
 343     /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
 344        In my test, the faad decoder doesnt behave correctly when sending each AU one by one
 345        but does when sending the whole as one big packet...  */
 346     infos->au_headers[0].size = 0;
 347     infos->au_headers[0].index = 0;
 348     for (i = 0; i < infos->nb_au_headers; ++i) {
 349         infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
 350         infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
 351     }
 352
 353     infos->nb_au_headers = 1;
 354
 355     return 0;
 356 }
 357
 358 /**
 359  * Parse an RTP or RTCP packet directly sent as a buffer.
 360  * @param s RTP parse context.
 361  * @param pkt returned packet
 362  * @param buf input buffer or NULL to read the next packets
 363  * @param len buffer len
 364  * @return 0 if a packet is returned, 1 if a packet is returned and more can follow
 365  * (use buf as NULL to read the next). -1 if no packet (error or no more packet).
 366  */
 367 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
 368                      const uint8_t *buf, int len)
 369 {
 370     unsigned int ssrc, h;
 371     int payload_type, seq, delta_timestamp, ret;
 372     AVStream *st;
 373     uint32_t timestamp;
 374
 375     if (!buf) {
 376         /* return the next packets, if any */
 377         if (s->read_buf_index >= s->read_buf_size)
 378             return -1;
 379         ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
 380                                   s->read_buf_size - s->read_buf_index);
 381         if (ret < 0)
 382             return -1;
 383         s->read_buf_index += ret;
 384         if (s->read_buf_index < s->read_buf_size)
 385             return 1;
 386         else
 387             return 0;
 388     }
 389
 390     if (len < 12)
 391         return -1;
 392
 393     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
 394         return -1;
 395     if (buf[1] >= 200 && buf[1] <= 204) {
 396         rtcp_parse_packet(s, buf, len);
 397         return -1;
 398     }
 399     payload_type = buf[1] & 0x7f;
 400     seq  = (buf[2] << 8) | buf[3];
 401     timestamp = decode_be32(buf + 4);
 402     ssrc = decode_be32(buf + 8);
 403
 404     /* NOTE: we can handle only one payload type */
 405     if (s->payload_type != payload_type)
 406         return -1;
 407
 408     st = s->st;
 409 #if defined(DEBUG) || 1
 410     if (seq != ((s->seq + 1) & 0xffff)) {
 411         av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
 412                payload_type, seq, ((s->seq + 1) & 0xffff));
 413     }
 414 #endif
 415     s->seq = seq;
 416     len -= 12;
 417     buf += 12;
 418
 419     if (!st) {
 420         /* specific MPEG2TS demux support */
 421         ret = mpegts_parse_packet(s->ts, pkt, buf, len);
 422         if (ret < 0)
 423             return -1;
 424         if (ret < len) {
 425             s->read_buf_size = len - ret;
 426             memcpy(s->buf, buf + ret, s->read_buf_size);
 427             s->read_buf_index = 0;
 428             return 1;
 429         }
 430     } else {
 431         switch(st->codec->codec_id) {
 432         case CODEC_ID_MP2:
 433             /* better than nothing: skip mpeg audio RTP header */
 434             if (len <= 4)
 435                 return -1;
 436             h = decode_be32(buf);
 437             len -= 4;
 438             buf += 4;
 439             av_new_packet(pkt, len);
 440             memcpy(pkt->data, buf, len);
 441             break;
 442         case CODEC_ID_MPEG1VIDEO:
 443             /* better than nothing: skip mpeg video RTP header */
 444             if (len <= 4)
 445                 return -1;
 446             h = decode_be32(buf);
 447             buf += 4;
 448             len -= 4;
 449             if (h & (1 << 26)) {
 450                 /* mpeg2 */
 451                 if (len <= 4)
 452                     return -1;
 453                 buf += 4;
 454                 len -= 4;
 455             }
 456             av_new_packet(pkt, len);
 457             memcpy(pkt->data, buf, len);
 458             break;
 459         default:
 460             av_new_packet(pkt, len);
 461             memcpy(pkt->data, buf, len);
 462             break;
 463         }
 464
 465         switch(st->codec->codec_id) {
 466         case CODEC_ID_MP2:
 467         case CODEC_ID_MPEG1VIDEO:
 468             if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
 469                 int64_t addend;
 470                 /* XXX: is it really necessary to unify the timestamp base ? */
 471                 /* compute pts from timestamp with received ntp_time */
 472                 delta_timestamp = timestamp - s->last_rtcp_timestamp;
 473                 /* convert to 90 kHz without overflow */
 474                 addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
 475                 addend = (addend * 5625) >> 14;
 476                 pkt->pts = addend + delta_timestamp;
 477             }
 478             break;
 479         case CODEC_ID_MPEG4:
 480             pkt->pts = timestamp;
 481             break;
 482         case CODEC_ID_MPEG4AAC:
 483             if (rtp_parse_mp4_au(s, buf))
 484               return -1;
 485             {
 486             rtp_payload_data_t *infos = s->rtp_payload_data;
 487             if (infos == NULL)
 488                 return -1;
 489             buf += infos->au_headers_length_bytes + 2;
 490             len -= infos->au_headers_length_bytes + 2;
 491
 492             /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
 493                one au_header */
 494             av_new_packet(pkt, infos->au_headers[0].size);
 495             memcpy(pkt->data, buf, infos->au_headers[0].size);
 496             buf += infos->au_headers[0].size;
 497             len -= infos->au_headers[0].size;
 498             }
 499             s->read_buf_size = len;
 500             s->buf_ptr = buf;
 501             pkt->stream_index = s->st->index;
 502             return 0;
 503         default:
 504             /* no timestamp info yet */
 505             break;
 506         }
 507         pkt->stream_index = s->st->index;
 508     }
 509     return 0;
 510 }
 511
 512 void rtp_parse_close(RTPDemuxContext *s)
 513 {
 514     if (!strcmp(AVRtpPayloadTypes[s->payload_type].enc_name, "MP2T")) {
 515         mpegts_parse_close(s->ts);
 516     }
 517     av_free(s);
 518 }
 519
 520 /* rtp output */
 521
 522 static int rtp_write_header(AVFormatContext *s1)
 523 {
 524     RTPDemuxContext *s = s1->priv_data;
 525     int payload_type, max_packet_size, n;
 526     AVStream *st;
 527
 528     if (s1->nb_streams != 1)
 529         return -1;
 530     st = s1->streams[0];
 531
 532     payload_type = rtp_get_payload_type(st->codec);
 533     if (payload_type < 0)
 534         payload_type = RTP_PT_PRIVATE; /* private payload type */
 535     s->payload_type = payload_type;
 536
 537 // following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
 538     s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
 539     s->timestamp = s->base_timestamp;
 540     s->ssrc = 0; /* FIXME: was random(), what should this be? */
 541     s->first_packet = 1;
 542
 543     max_packet_size = url_fget_max_packet_size(&s1->pb);
 544     if (max_packet_size <= 12)
 545         return AVERROR_IO;
 546     s->max_payload_size = max_packet_size - 12;
 547
 548     switch(st->codec->codec_id) {
 549     case CODEC_ID_MP2:
 550     case CODEC_ID_MP3:
 551         s->buf_ptr = s->buf + 4;
 552         s->cur_timestamp = 0;
 553         break;
 554     case CODEC_ID_MPEG1VIDEO:
 555         s->cur_timestamp = 0;
 556         break;
 557     case CODEC_ID_MPEG2TS:
 558         n = s->max_payload_size / TS_PACKET_SIZE;
 559         if (n < 1)
 560             n = 1;
 561         s->max_payload_size = n * TS_PACKET_SIZE;
 562         s->buf_ptr = s->buf;
 563         break;
 564     default:
 565         s->buf_ptr = s->buf;
 566         break;
 567     }
 568
 569     return 0;
 570 }
 571
 572 /* send an rtcp sender report packet */
 573 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
 574 {
 575     RTPDemuxContext *s = s1->priv_data;
 576 #if defined(DEBUG)
 577     printf("RTCP: %02x %Lx %x\n", s->payload_type, ntp_time, s->timestamp);
 578 #endif
 579     put_byte(&s1->pb, (RTP_VERSION << 6));
 580     put_byte(&s1->pb, 200);
 581     put_be16(&s1->pb, 6); /* length in words - 1 */
 582     put_be32(&s1->pb, s->ssrc);
 583     put_be64(&s1->pb, ntp_time);
 584     put_be32(&s1->pb, s->timestamp);
 585     put_be32(&s1->pb, s->packet_count);
 586     put_be32(&s1->pb, s->octet_count);
 587     put_flush_packet(&s1->pb);
 588 }
 589
 590 /* send an rtp packet. sequence number is incremented, but the caller
 591    must update the timestamp itself */
 592 static void rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
 593 {
 594     RTPDemuxContext *s = s1->priv_data;
 595
 596 #ifdef DEBUG
 597     printf("rtp_send_data size=%d\n", len);
 598 #endif
 599
 600     /* build the RTP header */
 601     put_byte(&s1->pb, (RTP_VERSION << 6));
 602     put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
 603     put_be16(&s1->pb, s->seq);
 604     put_be32(&s1->pb, s->timestamp);
 605     put_be32(&s1->pb, s->ssrc);
 606
 607     put_buffer(&s1->pb, buf1, len);
 608     put_flush_packet(&s1->pb);
 609
 610     s->seq++;
 611     s->octet_count += len;
 612     s->packet_count++;
 613 }
 614
 615 /* send an integer number of samples and compute time stamp and fill
 616    the rtp send buffer before sending. */
 617 static void rtp_send_samples(AVFormatContext *s1,
 618                              const uint8_t *buf1, int size, int sample_size)
 619 {
 620     RTPDemuxContext *s = s1->priv_data;
 621     int len, max_packet_size, n;
 622
 623     max_packet_size = (s->max_payload_size / sample_size) * sample_size;
 624     /* not needed, but who nows */
 625     if ((size % sample_size) != 0)
 626         av_abort();
 627     while (size > 0) {
 628         len = (max_packet_size - (s->buf_ptr - s->buf));
 629         if (len > size)
 630             len = size;
 631
 632         /* copy data */
 633         memcpy(s->buf_ptr, buf1, len);
 634         s->buf_ptr += len;
 635         buf1 += len;
 636         size -= len;
 637         n = (s->buf_ptr - s->buf);
 638         /* if buffer full, then send it */
 639         if (n >= max_packet_size) {
 640             rtp_send_data(s1, s->buf, n, 0);
 641             s->buf_ptr = s->buf;
 642             /* update timestamp */
 643             s->timestamp += n / sample_size;
 644         }
 645     }
 646 }
 647
 648 /* NOTE: we suppose that exactly one frame is given as argument here */
 649 /* XXX: test it */
 650 static void rtp_send_mpegaudio(AVFormatContext *s1,
 651                                const uint8_t *buf1, int size)
 652 {
 653     RTPDemuxContext *s = s1->priv_data;
 654     AVStream *st = s1->streams[0];
 655     int len, count, max_packet_size;
 656
 657     max_packet_size = s->max_payload_size;
 658
 659     /* test if we must flush because not enough space */
 660     len = (s->buf_ptr - s->buf);
 661     if ((len + size) > max_packet_size) {
 662         if (len > 4) {
 663             rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
 664             s->buf_ptr = s->buf + 4;
 665             /* 90 KHz time stamp */
 666             s->timestamp = s->base_timestamp +
 667                 (s->cur_timestamp * 90000LL) / st->codec->sample_rate;
 668         }
 669     }
 670
 671     /* add the packet */
 672     if (size > max_packet_size) {
 673         /* big packet: fragment */
 674         count = 0;
 675         while (size > 0) {
 676             len = max_packet_size - 4;
 677             if (len > size)
 678                 len = size;
 679             /* build fragmented packet */
 680             s->buf[0] = 0;
 681             s->buf[1] = 0;
 682             s->buf[2] = count >> 8;
 683             s->buf[3] = count;
 684             memcpy(s->buf + 4, buf1, len);
 685             rtp_send_data(s1, s->buf, len + 4, 0);
 686             size -= len;
 687             buf1 += len;
 688             count += len;
 689         }
 690     } else {
 691         if (s->buf_ptr == s->buf + 4) {
 692             /* no fragmentation possible */
 693             s->buf[0] = 0;
 694             s->buf[1] = 0;
 695             s->buf[2] = 0;
 696             s->buf[3] = 0;
 697         }
 698         memcpy(s->buf_ptr, buf1, size);
 699         s->buf_ptr += size;
 700     }
 701     s->cur_timestamp += st->codec->frame_size;
 702 }
 703
 704 /* NOTE: a single frame must be passed with sequence header if
 705    needed. XXX: use slices. */
 706 static void rtp_send_mpegvideo(AVFormatContext *s1,
 707                                const uint8_t *buf1, int size)
 708 {
 709     RTPDemuxContext *s = s1->priv_data;
 710     AVStream *st = s1->streams[0];
 711     int len, h, max_packet_size;
 712     uint8_t *q;
 713
 714     max_packet_size = s->max_payload_size;
 715
 716     while (size > 0) {
 717         /* XXX: more correct headers */
 718         h = 0;
 719         if (st->codec->sub_id == 2)
 720             h |= 1 << 26; /* mpeg 2 indicator */
 721         q = s->buf;
 722         *q++ = h >> 24;
 723         *q++ = h >> 16;
 724         *q++ = h >> 8;
 725         *q++ = h;
 726
 727         if (st->codec->sub_id == 2) {
 728             h = 0;
 729             *q++ = h >> 24;
 730             *q++ = h >> 16;
 731             *q++ = h >> 8;
 732             *q++ = h;
 733         }
 734
 735         len = max_packet_size - (q - s->buf);
 736         if (len > size)
 737             len = size;
 738
 739         memcpy(q, buf1, len);
 740         q += len;
 741
 742         /* 90 KHz time stamp */
 743         s->timestamp = s->base_timestamp +
 744             av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
 745         rtp_send_data(s1, s->buf, q - s->buf, (len == size));
 746
 747         buf1 += len;
 748         size -= len;
 749     }
 750     s->cur_timestamp++;
 751 }
 752
 753 static void rtp_send_raw(AVFormatContext *s1,
 754                          const uint8_t *buf1, int size)
 755 {
 756     RTPDemuxContext *s = s1->priv_data;
 757     AVStream *st = s1->streams[0];
 758     int len, max_packet_size;
 759
 760     max_packet_size = s->max_payload_size;
 761
 762     while (size > 0) {
 763         len = max_packet_size;
 764         if (len > size)
 765             len = size;
 766
 767         /* 90 KHz time stamp */
 768         s->timestamp = s->base_timestamp +
 769             av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
 770         rtp_send_data(s1, buf1, len, (len == size));
 771
 772         buf1 += len;
 773         size -= len;
 774     }
 775     s->cur_timestamp++;
 776 }
 777
 778 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
 779 static void rtp_send_mpegts_raw(AVFormatContext *s1,
 780                                 const uint8_t *buf1, int size)
 781 {
 782     RTPDemuxContext *s = s1->priv_data;
 783     int len, out_len;
 784
 785     while (size >= TS_PACKET_SIZE) {
 786         len = s->max_payload_size - (s->buf_ptr - s->buf);
 787         if (len > size)
 788             len = size;
 789         memcpy(s->buf_ptr, buf1, len);
 790         buf1 += len;
 791         size -= len;
 792         s->buf_ptr += len;
 793
 794         out_len = s->buf_ptr - s->buf;
 795         if (out_len >= s->max_payload_size) {
 796             rtp_send_data(s1, s->buf, out_len, 0);
 797             s->buf_ptr = s->buf;
 798         }
 799     }
 800 }
 801
 802 /* write an RTP packet. 'buf1' must contain a single specific frame. */
 803 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
 804 {
 805     RTPDemuxContext *s = s1->priv_data;
 806     AVStream *st = s1->streams[0];
 807     int rtcp_bytes;
 808     int64_t ntp_time;
 809     int size= pkt->size;
 810     uint8_t *buf1= pkt->data;
 811
 812 #ifdef DEBUG
 813     printf("%d: write len=%d\n", pkt->stream_index, size);
 814 #endif
 815
 816     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
 817     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
 818         RTCP_TX_RATIO_DEN;
 819     if (s->first_packet || rtcp_bytes >= 28) {
 820         /* compute NTP time */
 821         /* XXX: 90 kHz timestamp hardcoded */
 822         ntp_time = (pkt->pts << 28) / 5625;
 823         rtcp_send_sr(s1, ntp_time);
 824         s->last_octet_count = s->octet_count;
 825         s->first_packet = 0;
 826     }
 827
 828     switch(st->codec->codec_id) {
 829     case CODEC_ID_PCM_MULAW:
 830     case CODEC_ID_PCM_ALAW:
 831     case CODEC_ID_PCM_U8:
 832     case CODEC_ID_PCM_S8:
 833         rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
 834         break;
 835     case CODEC_ID_PCM_U16BE:
 836     case CODEC_ID_PCM_U16LE:
 837     case CODEC_ID_PCM_S16BE:
 838     case CODEC_ID_PCM_S16LE:
 839         rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
 840         break;
 841     case CODEC_ID_MP2:
 842     case CODEC_ID_MP3:
 843         rtp_send_mpegaudio(s1, buf1, size);
 844         break;
 845     case CODEC_ID_MPEG1VIDEO:
 846         rtp_send_mpegvideo(s1, buf1, size);
 847         break;
 848     case CODEC_ID_MPEG2TS:
 849         rtp_send_mpegts_raw(s1, buf1, size);
 850         break;
 851     default:
 852         /* better than nothing : send the codec raw data */
 853         rtp_send_raw(s1, buf1, size);
 854         break;
 855     }
 856     return 0;
 857 }
 858
 859 static int rtp_write_trailer(AVFormatContext *s1)
 860 {
 861     //    RTPDemuxContext *s = s1->priv_data;
 862     return 0;
 863 }
 864
 865 AVOutputFormat rtp_muxer = {
 866     "rtp",
 867     "RTP output format",
 868     NULL,
 869     NULL,
 870     sizeof(RTPDemuxContext),
 871     CODEC_ID_PCM_MULAW,
 872     CODEC_ID_NONE,
 873     rtp_write_header,
 874     rtp_write_packet,
 875     rtp_write_trailer,
 876 };