Libav
|
00001 /* 00002 * RTP 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 00022 #include "avformat.h" 00023 #include "mpegts.h" 00024 #include "internal.h" 00025 #include "libavutil/random_seed.h" 00026 00027 #include <unistd.h> 00028 00029 #include "rtpenc.h" 00030 00031 //#define DEBUG 00032 00033 #define RTCP_SR_SIZE 28 00034 00035 static int is_supported(enum CodecID id) 00036 { 00037 switch(id) { 00038 case CODEC_ID_H263: 00039 case CODEC_ID_H263P: 00040 case CODEC_ID_H264: 00041 case CODEC_ID_MPEG1VIDEO: 00042 case CODEC_ID_MPEG2VIDEO: 00043 case CODEC_ID_MPEG4: 00044 case CODEC_ID_AAC: 00045 case CODEC_ID_MP2: 00046 case CODEC_ID_MP3: 00047 case CODEC_ID_PCM_ALAW: 00048 case CODEC_ID_PCM_MULAW: 00049 case CODEC_ID_PCM_S8: 00050 case CODEC_ID_PCM_S16BE: 00051 case CODEC_ID_PCM_S16LE: 00052 case CODEC_ID_PCM_U16BE: 00053 case CODEC_ID_PCM_U16LE: 00054 case CODEC_ID_PCM_U8: 00055 case CODEC_ID_MPEG2TS: 00056 case CODEC_ID_AMR_NB: 00057 case CODEC_ID_AMR_WB: 00058 return 1; 00059 default: 00060 return 0; 00061 } 00062 } 00063 00064 static int rtp_write_header(AVFormatContext *s1) 00065 { 00066 RTPMuxContext *s = s1->priv_data; 00067 int max_packet_size, n; 00068 AVStream *st; 00069 00070 if (s1->nb_streams != 1) 00071 return -1; 00072 st = s1->streams[0]; 00073 if (!is_supported(st->codec->codec_id)) { 00074 av_log(s1, AV_LOG_ERROR, "Unsupported codec %x\n", st->codec->codec_id); 00075 00076 return -1; 00077 } 00078 00079 s->payload_type = ff_rtp_get_payload_type(st->codec); 00080 if (s->payload_type < 0) 00081 s->payload_type = RTP_PT_PRIVATE + (st->codec->codec_type == AVMEDIA_TYPE_AUDIO); 00082 00083 s->base_timestamp = ff_random_get_seed(); 00084 s->timestamp = s->base_timestamp; 00085 s->cur_timestamp = 0; 00086 s->ssrc = ff_random_get_seed(); 00087 s->first_packet = 1; 00088 s->first_rtcp_ntp_time = ff_ntp_time(); 00089 if (s1->start_time_realtime) 00090 /* Round the NTP time to whole milliseconds. */ 00091 s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 + 00092 NTP_OFFSET_US; 00093 00094 max_packet_size = url_fget_max_packet_size(s1->pb); 00095 if (max_packet_size <= 12) 00096 return AVERROR(EIO); 00097 s->buf = av_malloc(max_packet_size); 00098 if (s->buf == NULL) { 00099 return AVERROR(ENOMEM); 00100 } 00101 s->max_payload_size = max_packet_size - 12; 00102 00103 s->max_frames_per_packet = 0; 00104 if (s1->max_delay) { 00105 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 00106 if (st->codec->frame_size == 0) { 00107 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n"); 00108 } else { 00109 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); 00110 } 00111 } 00112 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 00113 /* FIXME: We should round down here... */ 00114 s->max_frames_per_packet = av_rescale_q(s1->max_delay, (AVRational){1, 1000000}, st->codec->time_base); 00115 } 00116 } 00117 00118 av_set_pts_info(st, 32, 1, 90000); 00119 switch(st->codec->codec_id) { 00120 case CODEC_ID_MP2: 00121 case CODEC_ID_MP3: 00122 s->buf_ptr = s->buf + 4; 00123 break; 00124 case CODEC_ID_MPEG1VIDEO: 00125 case CODEC_ID_MPEG2VIDEO: 00126 break; 00127 case CODEC_ID_MPEG2TS: 00128 n = s->max_payload_size / TS_PACKET_SIZE; 00129 if (n < 1) 00130 n = 1; 00131 s->max_payload_size = n * TS_PACKET_SIZE; 00132 s->buf_ptr = s->buf; 00133 break; 00134 case CODEC_ID_AMR_NB: 00135 case CODEC_ID_AMR_WB: 00136 if (!s->max_frames_per_packet) 00137 s->max_frames_per_packet = 12; 00138 if (st->codec->codec_id == CODEC_ID_AMR_NB) 00139 n = 31; 00140 else 00141 n = 61; 00142 /* max_header_toc_size + the largest AMR payload must fit */ 00143 if (1 + s->max_frames_per_packet + n > s->max_payload_size) { 00144 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n"); 00145 return -1; 00146 } 00147 if (st->codec->channels != 1) { 00148 av_log(s1, AV_LOG_ERROR, "Only mono is supported\n"); 00149 return -1; 00150 } 00151 case CODEC_ID_AAC: 00152 s->num_frames = 0; 00153 default: 00154 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { 00155 av_set_pts_info(st, 32, 1, st->codec->sample_rate); 00156 } 00157 s->buf_ptr = s->buf; 00158 break; 00159 } 00160 00161 return 0; 00162 } 00163 00164 /* send an rtcp sender report packet */ 00165 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time) 00166 { 00167 RTPMuxContext *s = s1->priv_data; 00168 uint32_t rtp_ts; 00169 00170 dprintf(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp); 00171 00172 s->last_rtcp_ntp_time = ntp_time; 00173 rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000}, 00174 s1->streams[0]->time_base) + s->base_timestamp; 00175 put_byte(s1->pb, (RTP_VERSION << 6)); 00176 put_byte(s1->pb, 200); 00177 put_be16(s1->pb, 6); /* length in words - 1 */ 00178 put_be32(s1->pb, s->ssrc); 00179 put_be32(s1->pb, ntp_time / 1000000); 00180 put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000); 00181 put_be32(s1->pb, rtp_ts); 00182 put_be32(s1->pb, s->packet_count); 00183 put_be32(s1->pb, s->octet_count); 00184 put_flush_packet(s1->pb); 00185 } 00186 00187 /* send an rtp packet. sequence number is incremented, but the caller 00188 must update the timestamp itself */ 00189 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m) 00190 { 00191 RTPMuxContext *s = s1->priv_data; 00192 00193 dprintf(s1, "rtp_send_data size=%d\n", len); 00194 00195 /* build the RTP header */ 00196 put_byte(s1->pb, (RTP_VERSION << 6)); 00197 put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7)); 00198 put_be16(s1->pb, s->seq); 00199 put_be32(s1->pb, s->timestamp); 00200 put_be32(s1->pb, s->ssrc); 00201 00202 put_buffer(s1->pb, buf1, len); 00203 put_flush_packet(s1->pb); 00204 00205 s->seq++; 00206 s->octet_count += len; 00207 s->packet_count++; 00208 } 00209 00210 /* send an integer number of samples and compute time stamp and fill 00211 the rtp send buffer before sending. */ 00212 static void rtp_send_samples(AVFormatContext *s1, 00213 const uint8_t *buf1, int size, int sample_size) 00214 { 00215 RTPMuxContext *s = s1->priv_data; 00216 int len, max_packet_size, n; 00217 00218 max_packet_size = (s->max_payload_size / sample_size) * sample_size; 00219 /* not needed, but who nows */ 00220 if ((size % sample_size) != 0) 00221 av_abort(); 00222 n = 0; 00223 while (size > 0) { 00224 s->buf_ptr = s->buf; 00225 len = FFMIN(max_packet_size, size); 00226 00227 /* copy data */ 00228 memcpy(s->buf_ptr, buf1, len); 00229 s->buf_ptr += len; 00230 buf1 += len; 00231 size -= len; 00232 s->timestamp = s->cur_timestamp + n / sample_size; 00233 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0); 00234 n += (s->buf_ptr - s->buf); 00235 } 00236 } 00237 00238 static void rtp_send_mpegaudio(AVFormatContext *s1, 00239 const uint8_t *buf1, int size) 00240 { 00241 RTPMuxContext *s = s1->priv_data; 00242 int len, count, max_packet_size; 00243 00244 max_packet_size = s->max_payload_size; 00245 00246 /* test if we must flush because not enough space */ 00247 len = (s->buf_ptr - s->buf); 00248 if ((len + size) > max_packet_size) { 00249 if (len > 4) { 00250 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0); 00251 s->buf_ptr = s->buf + 4; 00252 } 00253 } 00254 if (s->buf_ptr == s->buf + 4) { 00255 s->timestamp = s->cur_timestamp; 00256 } 00257 00258 /* add the packet */ 00259 if (size > max_packet_size) { 00260 /* big packet: fragment */ 00261 count = 0; 00262 while (size > 0) { 00263 len = max_packet_size - 4; 00264 if (len > size) 00265 len = size; 00266 /* build fragmented packet */ 00267 s->buf[0] = 0; 00268 s->buf[1] = 0; 00269 s->buf[2] = count >> 8; 00270 s->buf[3] = count; 00271 memcpy(s->buf + 4, buf1, len); 00272 ff_rtp_send_data(s1, s->buf, len + 4, 0); 00273 size -= len; 00274 buf1 += len; 00275 count += len; 00276 } 00277 } else { 00278 if (s->buf_ptr == s->buf + 4) { 00279 /* no fragmentation possible */ 00280 s->buf[0] = 0; 00281 s->buf[1] = 0; 00282 s->buf[2] = 0; 00283 s->buf[3] = 0; 00284 } 00285 memcpy(s->buf_ptr, buf1, size); 00286 s->buf_ptr += size; 00287 } 00288 } 00289 00290 static void rtp_send_raw(AVFormatContext *s1, 00291 const uint8_t *buf1, int size) 00292 { 00293 RTPMuxContext *s = s1->priv_data; 00294 int len, max_packet_size; 00295 00296 max_packet_size = s->max_payload_size; 00297 00298 while (size > 0) { 00299 len = max_packet_size; 00300 if (len > size) 00301 len = size; 00302 00303 s->timestamp = s->cur_timestamp; 00304 ff_rtp_send_data(s1, buf1, len, (len == size)); 00305 00306 buf1 += len; 00307 size -= len; 00308 } 00309 } 00310 00311 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */ 00312 static void rtp_send_mpegts_raw(AVFormatContext *s1, 00313 const uint8_t *buf1, int size) 00314 { 00315 RTPMuxContext *s = s1->priv_data; 00316 int len, out_len; 00317 00318 while (size >= TS_PACKET_SIZE) { 00319 len = s->max_payload_size - (s->buf_ptr - s->buf); 00320 if (len > size) 00321 len = size; 00322 memcpy(s->buf_ptr, buf1, len); 00323 buf1 += len; 00324 size -= len; 00325 s->buf_ptr += len; 00326 00327 out_len = s->buf_ptr - s->buf; 00328 if (out_len >= s->max_payload_size) { 00329 ff_rtp_send_data(s1, s->buf, out_len, 0); 00330 s->buf_ptr = s->buf; 00331 } 00332 } 00333 } 00334 00335 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt) 00336 { 00337 RTPMuxContext *s = s1->priv_data; 00338 AVStream *st = s1->streams[0]; 00339 int rtcp_bytes; 00340 int size= pkt->size; 00341 00342 dprintf(s1, "%d: write len=%d\n", pkt->stream_index, size); 00343 00344 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / 00345 RTCP_TX_RATIO_DEN; 00346 if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) && 00347 (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) { 00348 rtcp_send_sr(s1, ff_ntp_time()); 00349 s->last_octet_count = s->octet_count; 00350 s->first_packet = 0; 00351 } 00352 s->cur_timestamp = s->base_timestamp + pkt->pts; 00353 00354 switch(st->codec->codec_id) { 00355 case CODEC_ID_PCM_MULAW: 00356 case CODEC_ID_PCM_ALAW: 00357 case CODEC_ID_PCM_U8: 00358 case CODEC_ID_PCM_S8: 00359 rtp_send_samples(s1, pkt->data, size, 1 * st->codec->channels); 00360 break; 00361 case CODEC_ID_PCM_U16BE: 00362 case CODEC_ID_PCM_U16LE: 00363 case CODEC_ID_PCM_S16BE: 00364 case CODEC_ID_PCM_S16LE: 00365 rtp_send_samples(s1, pkt->data, size, 2 * st->codec->channels); 00366 break; 00367 case CODEC_ID_MP2: 00368 case CODEC_ID_MP3: 00369 rtp_send_mpegaudio(s1, pkt->data, size); 00370 break; 00371 case CODEC_ID_MPEG1VIDEO: 00372 case CODEC_ID_MPEG2VIDEO: 00373 ff_rtp_send_mpegvideo(s1, pkt->data, size); 00374 break; 00375 case CODEC_ID_AAC: 00376 ff_rtp_send_aac(s1, pkt->data, size); 00377 break; 00378 case CODEC_ID_AMR_NB: 00379 case CODEC_ID_AMR_WB: 00380 ff_rtp_send_amr(s1, pkt->data, size); 00381 break; 00382 case CODEC_ID_MPEG2TS: 00383 rtp_send_mpegts_raw(s1, pkt->data, size); 00384 break; 00385 case CODEC_ID_H264: 00386 ff_rtp_send_h264(s1, pkt->data, size); 00387 break; 00388 case CODEC_ID_H263: 00389 case CODEC_ID_H263P: 00390 ff_rtp_send_h263(s1, pkt->data, size); 00391 break; 00392 default: 00393 /* better than nothing : send the codec raw data */ 00394 rtp_send_raw(s1, pkt->data, size); 00395 break; 00396 } 00397 return 0; 00398 } 00399 00400 static int rtp_write_trailer(AVFormatContext *s1) 00401 { 00402 RTPMuxContext *s = s1->priv_data; 00403 00404 av_freep(&s->buf); 00405 00406 return 0; 00407 } 00408 00409 AVOutputFormat rtp_muxer = { 00410 "rtp", 00411 NULL_IF_CONFIG_SMALL("RTP output format"), 00412 NULL, 00413 NULL, 00414 sizeof(RTPMuxContext), 00415 CODEC_ID_PCM_MULAW, 00416 CODEC_ID_NONE, 00417 rtp_write_header, 00418 rtp_write_packet, 00419 rtp_write_trailer, 00420 };