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

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