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