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