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