git.sesse.net Git - ffmpeg/blob - libavformat/rtpenc.c

   1 /*
   2  * RTP output format
   3  * Copyright (c) 2002 Fabrice Bellard.
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21 #include "avformat.h"
  22 #include "mpegts.h"
  23 #include "bitstream.h"
  24
  25 #include <unistd.h>
  26 #include "network.h"
  27
  28 #include "rtp_internal.h"
  29 #include "rtp_mpv.h"
  30 #include "rtp_aac.h"
  31 #include "rtp_h264.h"
  32
  33 //#define DEBUG
  34
  35 #define RTCP_SR_SIZE 28
  36
  37 static int rtp_write_header(AVFormatContext *s1)
  38 {
  39     RTPDemuxContext *s = s1->priv_data;
  40     int payload_type, max_packet_size, n;
  41     AVStream *st;
  42
  43     if (s1->nb_streams != 1)
  44         return -1;
  45     st = s1->streams[0];
  46
  47     payload_type = rtp_get_payload_type(st->codec);
  48     if (payload_type < 0)
  49         payload_type = RTP_PT_PRIVATE; /* private payload type */
  50     s->payload_type = payload_type;
  51
  52 // following 2 FIXMEs could be set based on the current time, there is normally no info leak, as RTP will likely be transmitted immediately
  53     s->base_timestamp = 0; /* FIXME: was random(), what should this be? */
  54     s->timestamp = s->base_timestamp;
  55     s->cur_timestamp = 0;
  56     s->ssrc = 0; /* FIXME: was random(), what should this be? */
  57     s->first_packet = 1;
  58     s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
  59
  60     max_packet_size = url_fget_max_packet_size(s1->pb);
  61     if (max_packet_size <= 12)
  62         return AVERROR(EIO);
  63     s->max_payload_size = max_packet_size - 12;
  64
  65     s->max_frames_per_packet = 0;
  66     if (s1->max_delay) {
  67         if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
  68             if (st->codec->frame_size == 0) {
  69                 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
  70             } else {
  71                 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);
  72             }
  73         }
  74         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
  75             /* FIXME: We should round down here... */
  76             s->max_frames_per_packet = av_rescale_q(s1->max_delay, AV_TIME_BASE_Q, st->codec->time_base);
  77         }
  78     }
  79
  80     av_set_pts_info(st, 32, 1, 90000);
  81     switch(st->codec->codec_id) {
  82     case CODEC_ID_MP2:
  83     case CODEC_ID_MP3:
  84         s->buf_ptr = s->buf + 4;
  85         break;
  86     case CODEC_ID_MPEG1VIDEO:
  87     case CODEC_ID_MPEG2VIDEO:
  88         break;
  89     case CODEC_ID_MPEG2TS:
  90         n = s->max_payload_size / TS_PACKET_SIZE;
  91         if (n < 1)
  92             n = 1;
  93         s->max_payload_size = n * TS_PACKET_SIZE;
  94         s->buf_ptr = s->buf;
  95         break;
  96     case CODEC_ID_AAC:
  97         s->read_buf_index = 0;
  98     default:
  99         if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
 100             av_set_pts_info(st, 32, 1, st->codec->sample_rate);
 101         }
 102         s->buf_ptr = s->buf;
 103         break;
 104     }
 105
 106     return 0;
 107 }
 108
 109 /* send an rtcp sender report packet */
 110 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
 111 {
 112     RTPDemuxContext *s = s1->priv_data;
 113     uint32_t rtp_ts;
 114
 115 #if defined(DEBUG)
 116     printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
 117 #endif
 118
 119     if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
 120     s->last_rtcp_ntp_time = ntp_time;
 121     rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, AV_TIME_BASE_Q,
 122                           s1->streams[0]->time_base) + s->base_timestamp;
 123     put_byte(s1->pb, (RTP_VERSION << 6));
 124     put_byte(s1->pb, 200);
 125     put_be16(s1->pb, 6); /* length in words - 1 */
 126     put_be32(s1->pb, s->ssrc);
 127     put_be32(s1->pb, ntp_time / 1000000);
 128     put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
 129     put_be32(s1->pb, rtp_ts);
 130     put_be32(s1->pb, s->packet_count);
 131     put_be32(s1->pb, s->octet_count);
 132     put_flush_packet(s1->pb);
 133 }
 134
 135 /* send an rtp packet. sequence number is incremented, but the caller
 136    must update the timestamp itself */
 137 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
 138 {
 139     RTPDemuxContext *s = s1->priv_data;
 140
 141 #ifdef DEBUG
 142     printf("rtp_send_data size=%d\n", len);
 143 #endif
 144
 145     /* build the RTP header */
 146     put_byte(s1->pb, (RTP_VERSION << 6));
 147     put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
 148     put_be16(s1->pb, s->seq);
 149     put_be32(s1->pb, s->timestamp);
 150     put_be32(s1->pb, s->ssrc);
 151
 152     put_buffer(s1->pb, buf1, len);
 153     put_flush_packet(s1->pb);
 154
 155     s->seq++;
 156     s->octet_count += len;
 157     s->packet_count++;
 158 }
 159
 160 /* send an integer number of samples and compute time stamp and fill
 161    the rtp send buffer before sending. */
 162 static void rtp_send_samples(AVFormatContext *s1,
 163                              const uint8_t *buf1, int size, int sample_size)
 164 {
 165     RTPDemuxContext *s = s1->priv_data;
 166     int len, max_packet_size, n;
 167
 168     max_packet_size = (s->max_payload_size / sample_size) * sample_size;
 169     /* not needed, but who nows */
 170     if ((size % sample_size) != 0)
 171         av_abort();
 172     n = 0;
 173     while (size > 0) {
 174         s->buf_ptr = s->buf;
 175         len = FFMIN(max_packet_size, size);
 176
 177         /* copy data */
 178         memcpy(s->buf_ptr, buf1, len);
 179         s->buf_ptr += len;
 180         buf1 += len;
 181         size -= len;
 182         s->timestamp = s->cur_timestamp + n / sample_size;
 183         ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
 184         n += (s->buf_ptr - s->buf);
 185     }
 186 }
 187
 188 /* NOTE: we suppose that exactly one frame is given as argument here */
 189 /* XXX: test it */
 190 static void rtp_send_mpegaudio(AVFormatContext *s1,
 191                                const uint8_t *buf1, int size)
 192 {
 193     RTPDemuxContext *s = s1->priv_data;
 194     int len, count, max_packet_size;
 195
 196     max_packet_size = s->max_payload_size;
 197
 198     /* test if we must flush because not enough space */
 199     len = (s->buf_ptr - s->buf);
 200     if ((len + size) > max_packet_size) {
 201         if (len > 4) {
 202             ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
 203             s->buf_ptr = s->buf + 4;
 204         }
 205     }
 206     if (s->buf_ptr == s->buf + 4) {
 207         s->timestamp = s->cur_timestamp;
 208     }
 209
 210     /* add the packet */
 211     if (size > max_packet_size) {
 212         /* big packet: fragment */
 213         count = 0;
 214         while (size > 0) {
 215             len = max_packet_size - 4;
 216             if (len > size)
 217                 len = size;
 218             /* build fragmented packet */
 219             s->buf[0] = 0;
 220             s->buf[1] = 0;
 221             s->buf[2] = count >> 8;
 222             s->buf[3] = count;
 223             memcpy(s->buf + 4, buf1, len);
 224             ff_rtp_send_data(s1, s->buf, len + 4, 0);
 225             size -= len;
 226             buf1 += len;
 227             count += len;
 228         }
 229     } else {
 230         if (s->buf_ptr == s->buf + 4) {
 231             /* no fragmentation possible */
 232             s->buf[0] = 0;
 233             s->buf[1] = 0;
 234             s->buf[2] = 0;
 235             s->buf[3] = 0;
 236         }
 237         memcpy(s->buf_ptr, buf1, size);
 238         s->buf_ptr += size;
 239     }
 240 }
 241
 242 static void rtp_send_raw(AVFormatContext *s1,
 243                          const uint8_t *buf1, int size)
 244 {
 245     RTPDemuxContext *s = s1->priv_data;
 246     int len, max_packet_size;
 247
 248     max_packet_size = s->max_payload_size;
 249
 250     while (size > 0) {
 251         len = max_packet_size;
 252         if (len > size)
 253             len = size;
 254
 255         s->timestamp = s->cur_timestamp;
 256         ff_rtp_send_data(s1, buf1, len, (len == size));
 257
 258         buf1 += len;
 259         size -= len;
 260     }
 261 }
 262
 263 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
 264 static void rtp_send_mpegts_raw(AVFormatContext *s1,
 265                                 const uint8_t *buf1, int size)
 266 {
 267     RTPDemuxContext *s = s1->priv_data;
 268     int len, out_len;
 269
 270     while (size >= TS_PACKET_SIZE) {
 271         len = s->max_payload_size - (s->buf_ptr - s->buf);
 272         if (len > size)
 273             len = size;
 274         memcpy(s->buf_ptr, buf1, len);
 275         buf1 += len;
 276         size -= len;
 277         s->buf_ptr += len;
 278
 279         out_len = s->buf_ptr - s->buf;
 280         if (out_len >= s->max_payload_size) {
 281             ff_rtp_send_data(s1, s->buf, out_len, 0);
 282             s->buf_ptr = s->buf;
 283         }
 284     }
 285 }
 286
 287 /* write an RTP packet. 'buf1' must contain a single specific frame. */
 288 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
 289 {
 290     RTPDemuxContext *s = s1->priv_data;
 291     AVStream *st = s1->streams[0];
 292     int rtcp_bytes;
 293     int size= pkt->size;
 294     uint8_t *buf1= pkt->data;
 295
 296 #ifdef DEBUG
 297     printf("%d: write len=%d\n", pkt->stream_index, size);
 298 #endif
 299
 300     /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */
 301     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
 302         RTCP_TX_RATIO_DEN;
 303     if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
 304                            (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
 305         rtcp_send_sr(s1, av_gettime());
 306         s->last_octet_count = s->octet_count;
 307         s->first_packet = 0;
 308     }
 309     s->cur_timestamp = s->base_timestamp + pkt->pts;
 310
 311     switch(st->codec->codec_id) {
 312     case CODEC_ID_PCM_MULAW:
 313     case CODEC_ID_PCM_ALAW:
 314     case CODEC_ID_PCM_U8:
 315     case CODEC_ID_PCM_S8:
 316         rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
 317         break;
 318     case CODEC_ID_PCM_U16BE:
 319     case CODEC_ID_PCM_U16LE:
 320     case CODEC_ID_PCM_S16BE:
 321     case CODEC_ID_PCM_S16LE:
 322         rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
 323         break;
 324     case CODEC_ID_MP2:
 325     case CODEC_ID_MP3:
 326         rtp_send_mpegaudio(s1, buf1, size);
 327         break;
 328     case CODEC_ID_MPEG1VIDEO:
 329     case CODEC_ID_MPEG2VIDEO:
 330         ff_rtp_send_mpegvideo(s1, buf1, size);
 331         break;
 332     case CODEC_ID_AAC:
 333         ff_rtp_send_aac(s1, buf1, size);
 334         break;
 335     case CODEC_ID_MPEG2TS:
 336         rtp_send_mpegts_raw(s1, buf1, size);
 337         break;
 338     case CODEC_ID_H264:
 339         ff_rtp_send_h264(s1, buf1, size);
 340         break;
 341     default:
 342         /* better than nothing : send the codec raw data */
 343         rtp_send_raw(s1, buf1, size);
 344         break;
 345     }
 346     return 0;
 347 }
 348
 349 AVOutputFormat rtp_muxer = {
 350     "rtp",
 351     "RTP output format",
 352     NULL,
 353     NULL,
 354     sizeof(RTPDemuxContext),
 355     CODEC_ID_PCM_MULAW,
 356     CODEC_ID_NONE,
 357     rtp_write_header,
 358     rtp_write_packet,
 359 };