MythTV: rtp.c Source File

00001 /*
00002  * RTP input/output format
00003  * Copyright (c) 2002 Fabrice Bellard.
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 #include "avformat.h"
00022 #include "mpegts.h"
00023 #include "bitstream.h"
00024 
00025 #include <unistd.h>
00026 #include "network.h"
00027 
00028 #include "rtp_internal.h"
00029 #include "rtp_h264.h"
00030 #include "rtp_mpv.h"
00031 #include "rtp_aac.h"
00032 
00033 //#define DEBUG
00034 
00035 #define RTCP_SR_SIZE 28
00036 
00037 /* TODO: - add RTCP statistics reporting (should be optional).
00038 
00039          - add support for h263/mpeg4 packetized output : IDEA: send a
00040          buffer to 'rtp_write_packet' contains all the packets for ONE
00041          frame. Each packet should have a four byte header containing
00042          the length in big endian format (same trick as
00043          'url_open_dyn_packet_buf')
00044 */
00045 
00046 /* from http://www.iana.org/assignments/rtp-parameters last updated 05 January 2005 */
00047 AVRtpPayloadType_t AVRtpPayloadTypes[]=
00048 {
00049   {0, "PCMU",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_MULAW, 8000, 1},
00050   {1, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00051   {2, "Reserved",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00052   {3, "GSM",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00053   {4, "G723",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00054   {5, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00055   {6, "DVI4",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 16000, 1},
00056   {7, "LPC",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00057   {8, "PCMA",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_ALAW, 8000, 1},
00058   {9, "G722",        CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00059   {10, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 2},
00060   {11, "L16",        CODEC_TYPE_AUDIO,   CODEC_ID_PCM_S16BE, 44100, 1},
00061   {12, "QCELP",      CODEC_TYPE_AUDIO,   CODEC_ID_QCELP, 8000, 1},
00062   {13, "CN",         CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00063   {14, "MPA",        CODEC_TYPE_AUDIO,   CODEC_ID_MP2, 90000, -1},
00064   {15, "G728",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00065   {16, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 11025, 1},
00066   {17, "DVI4",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 22050, 1},
00067   {18, "G729",       CODEC_TYPE_AUDIO,   CODEC_ID_NONE, 8000, 1},
00068   {19, "reserved",   CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
00069   {20, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
00070   {21, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
00071   {22, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
00072   {23, "unassigned", CODEC_TYPE_AUDIO,   CODEC_ID_NONE, -1, -1},
00073   {24, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
00074   {25, "CelB",       CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
00075   {26, "JPEG",       CODEC_TYPE_VIDEO,   CODEC_ID_MJPEG, 90000, -1},
00076   {27, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
00077   {28, "nv",         CODEC_TYPE_VIDEO,   CODEC_ID_NONE, 90000, -1},
00078   {29, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
00079   {30, "unassigned", CODEC_TYPE_VIDEO,   CODEC_ID_NONE, -1, -1},
00080   {31, "H261",       CODEC_TYPE_VIDEO,   CODEC_ID_H261, 90000, -1},
00081   {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG1VIDEO, 90000, -1},
00082   {32, "MPV",        CODEC_TYPE_VIDEO,   CODEC_ID_MPEG2VIDEO, 90000, -1},
00083   {33, "MP2T",       CODEC_TYPE_DATA,    CODEC_ID_MPEG2TS, 90000, -1},
00084   {34, "H263",       CODEC_TYPE_VIDEO,   CODEC_ID_H263, 90000, -1},
00085   {35, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00086   {36, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00087   {37, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00088   {38, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00089   {39, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00090   {40, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00091   {41, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00092   {42, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00093   {43, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00094   {44, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00095   {45, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00096   {46, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00097   {47, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00098   {48, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00099   {49, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00100   {50, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00101   {51, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00102   {52, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00103   {53, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00104   {54, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00105   {55, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00106   {56, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00107   {57, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00108   {58, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00109   {59, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00110   {60, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00111   {61, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00112   {62, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00113   {63, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00114   {64, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00115   {65, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00116   {66, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00117   {67, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00118   {68, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00119   {69, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00120   {70, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00121   {71, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00122   {72, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00123   {73, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00124   {74, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00125   {75, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00126   {76, "reserved for RTCP conflict avoidance", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00127   {77, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00128   {78, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00129   {79, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00130   {80, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00131   {81, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00132   {82, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00133   {83, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00134   {84, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00135   {85, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00136   {86, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00137   {87, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00138   {88, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00139   {89, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00140   {90, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00141   {91, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00142   {92, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00143   {93, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00144   {94, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00145   {95, "unassigned", CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00146   {96, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00147   {97, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00148   {98, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00149   {99, "dynamic",    CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00150   {100, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00151   {101, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00152   {102, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00153   {103, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00154   {104, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00155   {105, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00156   {106, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00157   {107, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00158   {108, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00159   {109, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00160   {110, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00161   {111, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00162   {112, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00163   {113, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00164   {114, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00165   {115, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00166   {116, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00167   {117, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00168   {118, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00169   {119, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00170   {120, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00171   {121, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00172   {122, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00173   {123, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00174   {124, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00175   {125, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00176   {126, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00177   {127, "dynamic",   CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1},
00178   {-1, "",           CODEC_TYPE_UNKNOWN, CODEC_ID_NONE, -1, -1}
00179 };
00180 
00181 /* statistics functions */
00182 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
00183 
00184 static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", CODEC_TYPE_VIDEO, CODEC_ID_MPEG4};
00185 static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", CODEC_TYPE_AUDIO, CODEC_ID_AAC};
00186 
00187 static void register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
00188 {
00189     handler->next= RTPFirstDynamicPayloadHandler;
00190     RTPFirstDynamicPayloadHandler= handler;
00191 }
00192 
00193 void av_register_rtp_dynamic_payload_handlers(void)
00194 {
00195     register_dynamic_payload_handler(&mp4v_es_handler);
00196     register_dynamic_payload_handler(&mpeg4_generic_handler);
00197     register_dynamic_payload_handler(&ff_h264_dynamic_handler);
00198 }
00199 
00200 int rtp_get_codec_info(AVCodecContext *codec, int payload_type)
00201 {
00202     int i = 0;
00203 
00204     for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
00205         if (AVRtpPayloadTypes[i].pt == payload_type) {
00206             if (AVRtpPayloadTypes[i].codec_id != CODEC_ID_NONE) {
00207                 codec->codec_type = AVRtpPayloadTypes[i].codec_type;
00208                 codec->codec_id = AVRtpPayloadTypes[i].codec_id;
00209                 if (AVRtpPayloadTypes[i].audio_channels > 0)
00210                     codec->channels = AVRtpPayloadTypes[i].audio_channels;
00211                 if (AVRtpPayloadTypes[i].clock_rate > 0)
00212                     codec->sample_rate = AVRtpPayloadTypes[i].clock_rate;
00213                 return 0;
00214             }
00215         }
00216     return -1;
00217 }
00218 
00219 int rtp_get_payload_type(AVCodecContext *codec)
00220 {
00221     int i, payload_type;
00222 
00223     /* compute the payload type */
00224     for (payload_type = -1, i = 0; AVRtpPayloadTypes[i].pt >= 0; ++i)
00225         if (AVRtpPayloadTypes[i].codec_id == codec->codec_id) {
00226             if (codec->codec_id == CODEC_ID_PCM_S16BE)
00227                 if (codec->channels != AVRtpPayloadTypes[i].audio_channels)
00228                     continue;
00229             payload_type = AVRtpPayloadTypes[i].pt;
00230         }
00231     return payload_type;
00232 }
00233 
00234 const char *ff_rtp_enc_name(int payload_type)
00235 {
00236     int i;
00237 
00238     for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
00239         if (AVRtpPayloadTypes[i].pt == payload_type) {
00240             return AVRtpPayloadTypes[i].enc_name;
00241         }
00242 
00243     return "";
00244 }
00245 
00246 enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type)
00247 {
00248     int i;
00249 
00250     for (i = 0; AVRtpPayloadTypes[i].pt >= 0; i++)
00251         if (!strcmp(buf, AVRtpPayloadTypes[i].enc_name) && (codec_type == AVRtpPayloadTypes[i].codec_type)){
00252             return AVRtpPayloadTypes[i].codec_id;
00253         }
00254 
00255     return CODEC_ID_NONE;
00256 }
00257 
00258 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
00259 {
00260     if (buf[1] != 200)
00261         return -1;
00262     s->last_rtcp_ntp_time = AV_RB64(buf + 8);
00263     if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
00264         s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
00265     s->last_rtcp_timestamp = AV_RB32(buf + 16);
00266     return 0;
00267 }
00268 
00269 #define RTP_SEQ_MOD (1<<16)
00270 
00274 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
00275 {
00276     memset(s, 0, sizeof(RTPStatistics));
00277     s->max_seq= base_sequence;
00278     s->probation= 1;
00279 }
00280 
00284 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
00285 {
00286     s->max_seq= seq;
00287     s->cycles= 0;
00288     s->base_seq= seq -1;
00289     s->bad_seq= RTP_SEQ_MOD + 1;
00290     s->received= 0;
00291     s->expected_prior= 0;
00292     s->received_prior= 0;
00293     s->jitter= 0;
00294     s->transit= 0;
00295 }
00296 
00300 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
00301 {
00302     uint16_t udelta= seq - s->max_seq;
00303     const int MAX_DROPOUT= 3000;
00304     const int MAX_MISORDER = 100;
00305     const int MIN_SEQUENTIAL = 2;
00306 
00307     /* source not valid until MIN_SEQUENTIAL packets with sequence seq. numbers have been received */
00308     if(s->probation)
00309     {
00310         if(seq==s->max_seq + 1) {
00311             s->probation--;
00312             s->max_seq= seq;
00313             if(s->probation==0) {
00314                 rtp_init_sequence(s, seq);
00315                 s->received++;
00316                 return 1;
00317             }
00318         } else {
00319             s->probation= MIN_SEQUENTIAL - 1;
00320             s->max_seq = seq;
00321         }
00322     } else if (udelta < MAX_DROPOUT) {
00323         // in order, with permissible gap
00324         if(seq < s->max_seq) {
00325             //sequence number wrapped; count antother 64k cycles
00326             s->cycles += RTP_SEQ_MOD;
00327         }
00328         s->max_seq= seq;
00329     } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
00330         // sequence made a large jump...
00331         if(seq==s->bad_seq) {
00332             // two sequential packets-- assume that the other side restarted without telling us; just resync.
00333             rtp_init_sequence(s, seq);
00334         } else {
00335             s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
00336             return 0;
00337         }
00338     } else {
00339         // duplicate or reordered packet...
00340     }
00341     s->received++;
00342     return 1;
00343 }
00344 
00345 #if 0
00346 
00351 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
00352 {
00353     uint32_t transit= arrival_timestamp - sent_timestamp;
00354     int d;
00355     s->transit= transit;
00356     d= FFABS(transit - s->transit);
00357     s->jitter += d - ((s->jitter + 8)>>4);
00358 }
00359 #endif
00360 
00361 int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
00362 {
00363     ByteIOContext pb;
00364     uint8_t *buf;
00365     int len;
00366     int rtcp_bytes;
00367     RTPStatistics *stats= &s->statistics;
00368     uint32_t lost;
00369     uint32_t extended_max;
00370     uint32_t expected_interval;
00371     uint32_t received_interval;
00372     uint32_t lost_interval;
00373     uint32_t expected;
00374     uint32_t fraction;
00375     uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time?
00376 
00377     if (!s->rtp_ctx || (count < 1))
00378         return -1;
00379 
00380     /* TODO: I think this is way too often; RFC 1889 has algorithm for this */
00381     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
00382     s->octet_count += count;
00383     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
00384         RTCP_TX_RATIO_DEN;
00385     rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
00386     if (rtcp_bytes < 28)
00387         return -1;
00388     s->last_octet_count = s->octet_count;
00389 
00390     if (url_open_dyn_buf(&pb) < 0)
00391         return -1;
00392 
00393     // Receiver Report
00394     put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
00395     put_byte(&pb, 201);
00396     put_be16(&pb, 7); /* length in words - 1 */
00397     put_be32(&pb, s->ssrc); // our own SSRC
00398     put_be32(&pb, s->ssrc); // XXX: should be the server's here!
00399     // some placeholders we should really fill...
00400     // RFC 1889/p64
00401     extended_max= stats->cycles + stats->max_seq;
00402     expected= extended_max - stats->base_seq + 1;
00403     lost= expected - stats->received;
00404     lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
00405     expected_interval= expected - stats->expected_prior;
00406     stats->expected_prior= expected;
00407     received_interval= stats->received - stats->received_prior;
00408     stats->received_prior= stats->received;
00409     lost_interval= expected_interval - received_interval;
00410     if (expected_interval==0 || lost_interval<=0) fraction= 0;
00411     else fraction = (lost_interval<<8)/expected_interval;
00412 
00413     fraction= (fraction<<24) | lost;
00414 
00415     put_be32(&pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */
00416     put_be32(&pb, extended_max); /* max sequence received */
00417     put_be32(&pb, stats->jitter>>4); /* jitter */
00418 
00419     if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
00420     {
00421         put_be32(&pb, 0); /* last SR timestamp */
00422         put_be32(&pb, 0); /* delay since last SR */
00423     } else {
00424         uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
00425         uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
00426 
00427         put_be32(&pb, middle_32_bits); /* last SR timestamp */
00428         put_be32(&pb, delay_since_last); /* delay since last SR */
00429     }
00430 
00431     // CNAME
00432     put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */
00433     put_byte(&pb, 202);
00434     len = strlen(s->hostname);
00435     put_be16(&pb, (6 + len + 3) / 4); /* length in words - 1 */
00436     put_be32(&pb, s->ssrc);
00437     put_byte(&pb, 0x01);
00438     put_byte(&pb, len);
00439     put_buffer(&pb, s->hostname, len);
00440     // padding
00441     for (len = (6 + len) % 4; len % 4; len++) {
00442         put_byte(&pb, 0);
00443     }
00444 
00445     put_flush_packet(&pb);
00446     len = url_close_dyn_buf(&pb, &buf);
00447     if ((len > 0) && buf) {
00448         int result;
00449 #if defined(DEBUG)
00450         printf("sending %d bytes of RR\n", len);
00451 #endif
00452         result= url_write(s->rtp_ctx, buf, len);
00453 #if defined(DEBUG)
00454         printf("result from url_write: %d\n", result);
00455 #endif
00456         av_free(buf);
00457     }
00458     return 0;
00459 }
00460 
00467 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_t *rtp_payload_data)
00468 {
00469     RTPDemuxContext *s;
00470 
00471     s = av_mallocz(sizeof(RTPDemuxContext));
00472     if (!s)
00473         return NULL;
00474     s->payload_type = payload_type;
00475     s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
00476     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
00477     s->ic = s1;
00478     s->st = st;
00479     s->rtp_payload_data = rtp_payload_data;
00480     rtp_init_statistics(&s->statistics, 0); // do we know the initial sequence from sdp?
00481     if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
00482         s->ts = mpegts_parse_open(s->ic);
00483         if (s->ts == NULL) {
00484             av_free(s);
00485             return NULL;
00486         }
00487     } else {
00488         switch(st->codec->codec_id) {
00489         case CODEC_ID_MPEG1VIDEO:
00490         case CODEC_ID_MPEG2VIDEO:
00491         case CODEC_ID_MP2:
00492         case CODEC_ID_MP3:
00493         case CODEC_ID_MPEG4:
00494         case CODEC_ID_H264:
00495             st->need_parsing = AVSTREAM_PARSE_FULL;
00496             break;
00497         default:
00498             break;
00499         }
00500     }
00501     // needed to send back RTCP RR in RTSP sessions
00502     s->rtp_ctx = rtpc;
00503     gethostname(s->hostname, sizeof(s->hostname));
00504     return s;
00505 }
00506 
00507 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
00508 {
00509     int au_headers_length, au_header_size, i;
00510     GetBitContext getbitcontext;
00511     rtp_payload_data_t *infos;
00512 
00513     infos = s->rtp_payload_data;
00514 
00515     if (infos == NULL)
00516         return -1;
00517 
00518     /* decode the first 2 bytes where are stored the AUHeader sections
00519        length in bits */
00520     au_headers_length = AV_RB16(buf);
00521 
00522     if (au_headers_length > RTP_MAX_PACKET_LENGTH)
00523       return -1;
00524 
00525     infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
00526 
00527     /* skip AU headers length section (2 bytes) */
00528     buf += 2;
00529 
00530     init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
00531 
00532     /* XXX: Wrong if optionnal additional sections are present (cts, dts etc...) */
00533     au_header_size = infos->sizelength + infos->indexlength;
00534     if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
00535         return -1;
00536 
00537     infos->nb_au_headers = au_headers_length / au_header_size;
00538     infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
00539 
00540     /* XXX: We handle multiple AU Section as only one (need to fix this for interleaving)
00541        In my test, the FAAD decoder does not behave correctly when sending each AU one by one
00542        but does when sending the whole as one big packet...  */
00543     infos->au_headers[0].size = 0;
00544     infos->au_headers[0].index = 0;
00545     for (i = 0; i < infos->nb_au_headers; ++i) {
00546         infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
00547         infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
00548     }
00549 
00550     infos->nb_au_headers = 1;
00551 
00552     return 0;
00553 }
00554 
00558 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
00559 {
00560     switch(s->st->codec->codec_id) {
00561         case CODEC_ID_MP2:
00562         case CODEC_ID_MPEG1VIDEO:
00563         case CODEC_ID_MPEG2VIDEO:
00564             if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
00565                 int64_t addend;
00566 
00567                 int delta_timestamp;
00568                 /* XXX: is it really necessary to unify the timestamp base ? */
00569                 /* compute pts from timestamp with received ntp_time */
00570                 delta_timestamp = timestamp - s->last_rtcp_timestamp;
00571                 /* convert to 90 kHz without overflow */
00572                 addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14;
00573                 addend = (addend * 5625) >> 14;
00574                 pkt->pts = addend + delta_timestamp;
00575             }
00576             break;
00577         case CODEC_ID_AAC:
00578         case CODEC_ID_H264:
00579         case CODEC_ID_MPEG4:
00580             pkt->pts = timestamp;
00581             break;
00582         default:
00583             /* no timestamp info yet */
00584             break;
00585     }
00586     pkt->stream_index = s->st->index;
00587 }
00588 
00598 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
00599                      const uint8_t *buf, int len)
00600 {
00601     unsigned int ssrc, h;
00602     int payload_type, seq, ret;
00603     AVStream *st;
00604     uint32_t timestamp;
00605     int rv= 0;
00606 
00607     if (!buf) {
00608         /* return the next packets, if any */
00609         if(s->st && s->parse_packet) {
00610             timestamp= 0; 
00611             rv= s->parse_packet(s, pkt, &timestamp, NULL, 0);
00612             finalize_packet(s, pkt, timestamp);
00613             return rv;
00614         } else {
00615             // TODO: Move to a dynamic packet handler (like above)
00616             if (s->read_buf_index >= s->read_buf_size)
00617                 return -1;
00618             ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
00619                                       s->read_buf_size - s->read_buf_index);
00620             if (ret < 0)
00621                 return -1;
00622             s->read_buf_index += ret;
00623             if (s->read_buf_index < s->read_buf_size)
00624                 return 1;
00625             else
00626                 return 0;
00627         }
00628     }
00629 
00630     if (len < 12)
00631         return -1;
00632 
00633     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
00634         return -1;
00635     if (buf[1] >= 200 && buf[1] <= 204) {
00636         rtcp_parse_packet(s, buf, len);
00637         return -1;
00638     }
00639     payload_type = buf[1] & 0x7f;
00640     seq  = AV_RB16(buf + 2);
00641     timestamp = AV_RB32(buf + 4);
00642     ssrc = AV_RB32(buf + 8);
00643     /* store the ssrc in the RTPDemuxContext */
00644     s->ssrc = ssrc;
00645 
00646     /* NOTE: we can handle only one payload type */
00647     if (s->payload_type != payload_type)
00648         return -1;
00649 
00650     st = s->st;
00651     // only do something with this if all the rtp checks pass...
00652     if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
00653     {
00654         av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
00655                payload_type, seq, ((s->seq + 1) & 0xffff));
00656         return -1;
00657     }
00658 
00659     s->seq = seq;
00660     len -= 12;
00661     buf += 12;
00662 
00663     if (!st) {
00664         /* specific MPEG2TS demux support */
00665         ret = mpegts_parse_packet(s->ts, pkt, buf, len);
00666         if (ret < 0)
00667             return -1;
00668         if (ret < len) {
00669             s->read_buf_size = len - ret;
00670             memcpy(s->buf, buf + ret, s->read_buf_size);
00671             s->read_buf_index = 0;
00672             return 1;
00673         }
00674     } else {
00675         // at this point, the RTP header has been stripped;  This is ASSUMING that there is only 1 CSRC, which in't wise.
00676         switch(st->codec->codec_id) {
00677         case CODEC_ID_MP2:
00678             /* better than nothing: skip mpeg audio RTP header */
00679             if (len <= 4)
00680                 return -1;
00681             h = AV_RB32(buf);
00682             len -= 4;
00683             buf += 4;
00684             av_new_packet(pkt, len);
00685             memcpy(pkt->data, buf, len);
00686             break;
00687         case CODEC_ID_MPEG1VIDEO:
00688         case CODEC_ID_MPEG2VIDEO:
00689             /* better than nothing: skip mpeg video RTP header */
00690             if (len <= 4)
00691                 return -1;
00692             h = AV_RB32(buf);
00693             buf += 4;
00694             len -= 4;
00695             if (h & (1 << 26)) {
00696                 /* mpeg2 */
00697                 if (len <= 4)
00698                     return -1;
00699                 buf += 4;
00700                 len -= 4;
00701             }
00702             av_new_packet(pkt, len);
00703             memcpy(pkt->data, buf, len);
00704             break;
00705             // moved from below, verbatim.  this is because this section handles packets, and the lower switch handles
00706             // timestamps.
00707             // TODO: Put this into a dynamic packet handler...
00708         case CODEC_ID_AAC:
00709             if (rtp_parse_mp4_au(s, buf))
00710                 return -1;
00711             {
00712                 rtp_payload_data_t *infos = s->rtp_payload_data;
00713                 if (infos == NULL)
00714                     return -1;
00715                 buf += infos->au_headers_length_bytes + 2;
00716                 len -= infos->au_headers_length_bytes + 2;
00717 
00718                 /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define
00719                     one au_header */
00720                 av_new_packet(pkt, infos->au_headers[0].size);
00721                 memcpy(pkt->data, buf, infos->au_headers[0].size);
00722                 buf += infos->au_headers[0].size;
00723                 len -= infos->au_headers[0].size;
00724             }
00725             s->read_buf_size = len;
00726             rv= 0;
00727             break;
00728         default:
00729             if(s->parse_packet) {
00730                 rv= s->parse_packet(s, pkt, &timestamp, buf, len);
00731             } else {
00732                 av_new_packet(pkt, len);
00733                 memcpy(pkt->data, buf, len);
00734             }
00735             break;
00736         }
00737 
00738         // now perform timestamp things....
00739         finalize_packet(s, pkt, timestamp);
00740     }
00741     return rv;
00742 }
00743 
00744 void rtp_parse_close(RTPDemuxContext *s)
00745 {
00746     // TODO: fold this into the protocol specific data fields.
00747     if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
00748         mpegts_parse_close(s->ts);
00749     }
00750     av_free(s);
00751 }
00752 
00753 /* rtp output */
00754 
00755 static int rtp_write_header(AVFormatContext *s1)
00756 {
00757     RTPDemuxContext *s = s1->priv_data;
00758     int payload_type, max_packet_size, n;
00759     AVStream *st;
00760 
00761     if (s1->nb_streams != 1)
00762         return -1;
00763     st = s1->streams[0];
00764 
00765     payload_type = rtp_get_payload_type(st->codec);
00766     if (payload_type < 0)
00767         payload_type = RTP_PT_PRIVATE; /* private payload type */
00768     s->payload_type = payload_type;
00769 
00770 // following 2 FIXMies could be set based on the current time, theres normaly no info leak, as rtp will likely be transmitted immedeatly
00771     s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
00772     s->timestamp = s->base_timestamp;
00773     s->cur_timestamp = 0;
00774     s->ssrc = 0; /* FIXME: was random(), what should this be? */
00775     s->first_packet = 1;
00776     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
00777 
00778     max_packet_size = url_fget_max_packet_size(&s1->pb);
00779     if (max_packet_size <= 12)
00780         return AVERROR(EIO);
00781     s->max_payload_size = max_packet_size - 12;
00782 
00783     s->max_frames_per_packet = 0;
00784     if (s1->max_delay) {
00785         if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
00786             if (st->codec->frame_size == 0) {
00787                 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
00788             } else {
00789                 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);
00790             }
00791         }
00792         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
00793             /* FIXME: We should round down here... */
00794             s->max_frames_per_packet = av_rescale_q(s1->max_delay, AV_TIME_BASE_Q, st->codec->time_base);
00795         }
00796     }
00797 
00798     av_set_pts_info(st, 32, 1, 90000);
00799     switch(st->codec->codec_id) {
00800     case CODEC_ID_MP2:
00801     case CODEC_ID_MP3:
00802         s->buf_ptr = s->buf + 4;
00803         break;
00804     case CODEC_ID_MPEG1VIDEO:
00805     case CODEC_ID_MPEG2VIDEO:
00806         break;
00807     case CODEC_ID_MPEG2TS:
00808         n = s->max_payload_size / TS_PACKET_SIZE;
00809         if (n < 1)
00810             n = 1;
00811         s->max_payload_size = n * TS_PACKET_SIZE;
00812         s->buf_ptr = s->buf;
00813         break;
00814     case CODEC_ID_AAC:
00815         s->read_buf_index = 0;
00816     default:
00817         if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
00818             av_set_pts_info(st, 32, 1, st->codec->sample_rate);
00819         }
00820         s->buf_ptr = s->buf;
00821         break;
00822     }
00823 
00824     return 0;
00825 }
00826 
00827 /* send an rtcp sender report packet */
00828 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
00829 {
00830     RTPDemuxContext *s = s1->priv_data;
00831     uint32_t rtp_ts;
00832 
00833 #if defined(DEBUG)
00834     printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
00835 #endif
00836 
00837     if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
00838     s->last_rtcp_ntp_time = ntp_time;
00839     rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, AV_TIME_BASE_Q,
00840                           s1->streams[0]->time_base) + s->base_timestamp;
00841     put_byte(&s1->pb, (RTP_VERSION << 6));
00842     put_byte(&s1->pb, 200);
00843     put_be16(&s1->pb, 6); /* length in words - 1 */
00844     put_be32(&s1->pb, s->ssrc);
00845     put_be32(&s1->pb, ntp_time / 1000000);
00846     put_be32(&s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
00847     put_be32(&s1->pb, rtp_ts);
00848     put_be32(&s1->pb, s->packet_count);
00849     put_be32(&s1->pb, s->octet_count);
00850     put_flush_packet(&s1->pb);
00851 }
00852 
00853 /* send an rtp packet. sequence number is incremented, but the caller
00854    must update the timestamp itself */
00855 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
00856 {
00857     RTPDemuxContext *s = s1->priv_data;
00858 
00859 #ifdef DEBUG
00860     printf("rtp_send_data size=%d\n", len);
00861 #endif
00862 
00863     /* build the RTP header */
00864     put_byte(&s1->pb, (RTP_VERSION << 6));
00865     put_byte(&s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
00866     put_be16(&s1->pb, s->seq);
00867     put_be32(&s1->pb, s->timestamp);
00868     put_be32(&s1->pb, s->ssrc);
00869 
00870     put_buffer(&s1->pb, buf1, len);
00871     put_flush_packet(&s1->pb);
00872 
00873     s->seq++;
00874     s->octet_count += len;
00875     s->packet_count++;
00876 }
00877 
00878 /* send an integer number of samples and compute time stamp and fill
00879    the rtp send buffer before sending. */
00880 static void rtp_send_samples(AVFormatContext *s1,
00881                              const uint8_t *buf1, int size, int sample_size)
00882 {
00883     RTPDemuxContext *s = s1->priv_data;
00884     int len, max_packet_size, n;
00885 
00886     max_packet_size = (s->max_payload_size / sample_size) * sample_size;
00887     /* not needed, but who nows */
00888     if ((size % sample_size) != 0)
00889         av_abort();
00890     n = 0;
00891     while (size > 0) {
00892         s->buf_ptr = s->buf;
00893         len = FFMIN(max_packet_size, size);
00894 
00895         /* copy data */
00896         memcpy(s->buf_ptr, buf1, len);
00897         s->buf_ptr += len;
00898         buf1 += len;
00899         size -= len;
00900         s->timestamp = s->cur_timestamp + n / sample_size;
00901         ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
00902         n += (s->buf_ptr - s->buf);
00903     }
00904 }
00905 
00906 /* NOTE: we suppose that exactly one frame is given as argument here */
00907 /* XXX: test it */
00908 static void rtp_send_mpegaudio(AVFormatContext *s1,
00909                                const uint8_t *buf1, int size)
00910 {
00911     RTPDemuxContext *s = s1->priv_data;
00912     int len, count, max_packet_size;
00913 
00914     max_packet_size = s->max_payload_size;
00915 
00916     /* test if we must flush because not enough space */
00917     len = (s->buf_ptr - s->buf);
00918     if ((len + size) > max_packet_size) {
00919         if (len > 4) {
00920             ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
00921             s->buf_ptr = s->buf + 4;
00922         }
00923     }
00924     if (s->buf_ptr == s->buf + 4) {
00925         s->timestamp = s->cur_timestamp;
00926     }
00927 
00928     /* add the packet */
00929     if (size > max_packet_size) {
00930         /* big packet: fragment */
00931         count = 0;
00932         while (size > 0) {
00933             len = max_packet_size - 4;
00934             if (len > size)
00935                 len = size;
00936             /* build fragmented packet */
00937             s->buf[0] = 0;
00938             s->buf[1] = 0;
00939             s->buf[2] = count >> 8;
00940             s->buf[3] = count;
00941             memcpy(s->buf + 4, buf1, len);
00942             ff_rtp_send_data(s1, s->buf, len + 4, 0);
00943             size -= len;
00944             buf1 += len;
00945             count += len;
00946         }
00947     } else {
00948         if (s->buf_ptr == s->buf + 4) {
00949             /* no fragmentation possible */
00950             s->buf[0] = 0;
00951             s->buf[1] = 0;
00952             s->buf[2] = 0;
00953             s->buf[3] = 0;
00954         }
00955         memcpy(s->buf_ptr, buf1, size);
00956         s->buf_ptr += size;
00957     }
00958 }
00959 
00960 static void rtp_send_raw(AVFormatContext *s1,
00961                          const uint8_t *buf1, int size)
00962 {
00963     RTPDemuxContext *s = s1->priv_data;
00964     int len, max_packet_size;
00965 
00966     max_packet_size = s->max_payload_size;
00967 
00968     while (size > 0) {
00969         len = max_packet_size;
00970         if (len > size)
00971             len = size;
00972 
00973         s->timestamp = s->cur_timestamp;
00974         ff_rtp_send_data(s1, buf1, len, (len == size));
00975 
00976         buf1 += len;
00977         size -= len;
00978     }
00979 }
00980 
00981 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
00982 static void rtp_send_mpegts_raw(AVFormatContext *s1,
00983                                 const uint8_t *buf1, int size)
00984 {
00985     RTPDemuxContext *s = s1->priv_data;
00986     int len, out_len;
00987 
00988     while (size >= TS_PACKET_SIZE) {
00989         len = s->max_payload_size - (s->buf_ptr - s->buf);
00990         if (len > size)
00991             len = size;
00992         memcpy(s->buf_ptr, buf1, len);
00993         buf1 += len;
00994         size -= len;
00995         s->buf_ptr += len;
00996 
00997         out_len = s->buf_ptr - s->buf;
00998         if (out_len >= s->max_payload_size) {
00999             ff_rtp_send_data(s1, s->buf, out_len, 0);
01000             s->buf_ptr = s->buf;
01001         }
01002     }
01003 }
01004 
01005 /* write an RTP packet. 'buf1' must contain a single specific frame. */
01006 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
01007 {
01008     RTPDemuxContext *s = s1->priv_data;
01009     AVStream *st = s1->streams[0];
01010     int rtcp_bytes;
01011     int size= pkt->size;
01012     uint8_t *buf1= pkt->data;
01013 
01014 #ifdef DEBUG
01015     printf("%d: write len=%d\n", pkt->stream_index, size);
01016 #endif
01017 
01018     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
01019     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
01020         RTCP_TX_RATIO_DEN;
01021     if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
01022                            (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
01023         rtcp_send_sr(s1, av_gettime());
01024         s->last_octet_count = s->octet_count;
01025         s->first_packet = 0;
01026     }
01027     s->cur_timestamp = s->base_timestamp + pkt->pts;
01028 
01029     switch(st->codec->codec_id) {
01030     case CODEC_ID_PCM_MULAW:
01031     case CODEC_ID_PCM_ALAW:
01032     case CODEC_ID_PCM_U8:
01033     case CODEC_ID_PCM_S8:
01034         rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
01035         break;
01036     case CODEC_ID_PCM_U16BE:
01037     case CODEC_ID_PCM_U16LE:
01038     case CODEC_ID_PCM_S16BE:
01039     case CODEC_ID_PCM_S16LE:
01040         rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
01041         break;
01042     case CODEC_ID_MP2:
01043     case CODEC_ID_MP3:
01044         rtp_send_mpegaudio(s1, buf1, size);
01045         break;
01046     case CODEC_ID_MPEG1VIDEO:
01047     case CODEC_ID_MPEG2VIDEO:
01048         ff_rtp_send_mpegvideo(s1, buf1, size);
01049         break;
01050     case CODEC_ID_AAC:
01051         ff_rtp_send_aac(s1, buf1, size);
01052         break;
01053     case CODEC_ID_MPEG2TS:
01054         rtp_send_mpegts_raw(s1, buf1, size);
01055         break;
01056     default:
01057         /* better than nothing : send the codec raw data */
01058         rtp_send_raw(s1, buf1, size);
01059         break;
01060     }
01061     return 0;
01062 }
01063 
01064 AVOutputFormat rtp_muxer = {
01065     "rtp",
01066     "RTP output format",
01067     NULL,
01068     NULL,
01069     sizeof(RTPDemuxContext),
01070     CODEC_ID_PCM_MULAW,
01071     CODEC_ID_NONE,
01072     rtp_write_header,
01073     rtp_write_packet,
01074 };