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