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