00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "avformat.h"
00023 #include "mpegts.h"
00024 #include "internal.h"
00025 #include "libavutil/random_seed.h"
00026
00027 #include "rtpenc.h"
00028
00029
00030
00031 #define RTCP_SR_SIZE 28
00032
00033 static int is_supported(enum CodecID id)
00034 {
00035 switch(id) {
00036 case CODEC_ID_H263:
00037 case CODEC_ID_H263P:
00038 case CODEC_ID_H264:
00039 case CODEC_ID_MPEG1VIDEO:
00040 case CODEC_ID_MPEG2VIDEO:
00041 case CODEC_ID_MPEG4:
00042 case CODEC_ID_AAC:
00043 case CODEC_ID_MP2:
00044 case CODEC_ID_MP3:
00045 case CODEC_ID_PCM_ALAW:
00046 case CODEC_ID_PCM_MULAW:
00047 case CODEC_ID_PCM_S8:
00048 case CODEC_ID_PCM_S16BE:
00049 case CODEC_ID_PCM_S16LE:
00050 case CODEC_ID_PCM_U16BE:
00051 case CODEC_ID_PCM_U16LE:
00052 case CODEC_ID_PCM_U8:
00053 case CODEC_ID_MPEG2TS:
00054 case CODEC_ID_AMR_NB:
00055 case CODEC_ID_AMR_WB:
00056 case CODEC_ID_VORBIS:
00057 case CODEC_ID_THEORA:
00058 case CODEC_ID_VP8:
00059 case CODEC_ID_ADPCM_G722:
00060 return 1;
00061 default:
00062 return 0;
00063 }
00064 }
00065
00066 static int rtp_write_header(AVFormatContext *s1)
00067 {
00068 RTPMuxContext *s = s1->priv_data;
00069 int max_packet_size, n;
00070 AVStream *st;
00071
00072 if (s1->nb_streams != 1)
00073 return -1;
00074 st = s1->streams[0];
00075 if (!is_supported(st->codec->codec_id)) {
00076 av_log(s1, AV_LOG_ERROR, "Unsupported codec %x\n", st->codec->codec_id);
00077
00078 return -1;
00079 }
00080
00081 s->payload_type = ff_rtp_get_payload_type(st->codec);
00082 if (s->payload_type < 0)
00083 s->payload_type = RTP_PT_PRIVATE + (st->codec->codec_type == AVMEDIA_TYPE_AUDIO);
00084
00085 s->base_timestamp = av_get_random_seed();
00086 s->timestamp = s->base_timestamp;
00087 s->cur_timestamp = 0;
00088 s->ssrc = av_get_random_seed();
00089 s->first_packet = 1;
00090 s->first_rtcp_ntp_time = ff_ntp_time();
00091 if (s1->start_time_realtime)
00092
00093 s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
00094 NTP_OFFSET_US;
00095
00096 max_packet_size = s1->pb->max_packet_size;
00097 if (max_packet_size <= 12)
00098 return AVERROR(EIO);
00099 s->buf = av_malloc(max_packet_size);
00100 if (s->buf == NULL) {
00101 return AVERROR(ENOMEM);
00102 }
00103 s->max_payload_size = max_packet_size - 12;
00104
00105 s->max_frames_per_packet = 0;
00106 if (s1->max_delay) {
00107 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
00108 if (st->codec->frame_size == 0) {
00109 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
00110 } else {
00111 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);
00112 }
00113 }
00114 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
00115
00116 s->max_frames_per_packet = av_rescale_q(s1->max_delay, (AVRational){1, 1000000}, st->codec->time_base);
00117 }
00118 }
00119
00120 av_set_pts_info(st, 32, 1, 90000);
00121 switch(st->codec->codec_id) {
00122 case CODEC_ID_MP2:
00123 case CODEC_ID_MP3:
00124 s->buf_ptr = s->buf + 4;
00125 break;
00126 case CODEC_ID_MPEG1VIDEO:
00127 case CODEC_ID_MPEG2VIDEO:
00128 break;
00129 case CODEC_ID_MPEG2TS:
00130 n = s->max_payload_size / TS_PACKET_SIZE;
00131 if (n < 1)
00132 n = 1;
00133 s->max_payload_size = n * TS_PACKET_SIZE;
00134 s->buf_ptr = s->buf;
00135 break;
00136 case CODEC_ID_H264:
00137
00138 if (st->codec->extradata_size > 4 && st->codec->extradata[0] == 1) {
00139 s->nal_length_size = (st->codec->extradata[4] & 0x03) + 1;
00140 }
00141 break;
00142 case CODEC_ID_VORBIS:
00143 case CODEC_ID_THEORA:
00144 if (!s->max_frames_per_packet) s->max_frames_per_packet = 15;
00145 s->max_frames_per_packet = av_clip(s->max_frames_per_packet, 1, 15);
00146 s->max_payload_size -= 6;
00147 s->num_frames = 0;
00148 goto defaultcase;
00149 case CODEC_ID_VP8:
00150 av_log(s1, AV_LOG_ERROR, "RTP VP8 payload implementation is "
00151 "incompatible with the latest spec drafts.\n");
00152 break;
00153 case CODEC_ID_ADPCM_G722:
00154
00155
00156 av_set_pts_info(st, 32, 1, 8000);
00157 break;
00158 case CODEC_ID_AMR_NB:
00159 case CODEC_ID_AMR_WB:
00160 if (!s->max_frames_per_packet)
00161 s->max_frames_per_packet = 12;
00162 if (st->codec->codec_id == CODEC_ID_AMR_NB)
00163 n = 31;
00164 else
00165 n = 61;
00166
00167 if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
00168 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");
00169 return -1;
00170 }
00171 if (st->codec->channels != 1) {
00172 av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
00173 return -1;
00174 }
00175 case CODEC_ID_AAC:
00176 s->num_frames = 0;
00177 default:
00178 defaultcase:
00179 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
00180 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
00181 }
00182 s->buf_ptr = s->buf;
00183 break;
00184 }
00185
00186 return 0;
00187 }
00188
00189
00190 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
00191 {
00192 RTPMuxContext *s = s1->priv_data;
00193 uint32_t rtp_ts;
00194
00195 av_dlog(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
00196
00197 s->last_rtcp_ntp_time = ntp_time;
00198 rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
00199 s1->streams[0]->time_base) + s->base_timestamp;
00200 avio_w8(s1->pb, (RTP_VERSION << 6));
00201 avio_w8(s1->pb, RTCP_SR);
00202 avio_wb16(s1->pb, 6);
00203 avio_wb32(s1->pb, s->ssrc);
00204 avio_wb32(s1->pb, ntp_time / 1000000);
00205 avio_wb32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
00206 avio_wb32(s1->pb, rtp_ts);
00207 avio_wb32(s1->pb, s->packet_count);
00208 avio_wb32(s1->pb, s->octet_count);
00209 put_flush_packet(s1->pb);
00210 }
00211
00212
00213
00214 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
00215 {
00216 RTPMuxContext *s = s1->priv_data;
00217
00218 av_dlog(s1, "rtp_send_data size=%d\n", len);
00219
00220
00221 avio_w8(s1->pb, (RTP_VERSION << 6));
00222 avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
00223 avio_wb16(s1->pb, s->seq);
00224 avio_wb32(s1->pb, s->timestamp);
00225 avio_wb32(s1->pb, s->ssrc);
00226
00227 avio_write(s1->pb, buf1, len);
00228 put_flush_packet(s1->pb);
00229
00230 s->seq++;
00231 s->octet_count += len;
00232 s->packet_count++;
00233 }
00234
00235
00236
00237 static void rtp_send_samples(AVFormatContext *s1,
00238 const uint8_t *buf1, int size, int sample_size)
00239 {
00240 RTPMuxContext *s = s1->priv_data;
00241 int len, max_packet_size, n;
00242
00243 max_packet_size = (s->max_payload_size / sample_size) * sample_size;
00244
00245 if ((size % sample_size) != 0)
00246 av_abort();
00247 n = 0;
00248 while (size > 0) {
00249 s->buf_ptr = s->buf;
00250 len = FFMIN(max_packet_size, size);
00251
00252
00253 memcpy(s->buf_ptr, buf1, len);
00254 s->buf_ptr += len;
00255 buf1 += len;
00256 size -= len;
00257 s->timestamp = s->cur_timestamp + n / sample_size;
00258 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
00259 n += (s->buf_ptr - s->buf);
00260 }
00261 }
00262
00263 static void rtp_send_mpegaudio(AVFormatContext *s1,
00264 const uint8_t *buf1, int size)
00265 {
00266 RTPMuxContext *s = s1->priv_data;
00267 int len, count, max_packet_size;
00268
00269 max_packet_size = s->max_payload_size;
00270
00271
00272 len = (s->buf_ptr - s->buf);
00273 if ((len + size) > max_packet_size) {
00274 if (len > 4) {
00275 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
00276 s->buf_ptr = s->buf + 4;
00277 }
00278 }
00279 if (s->buf_ptr == s->buf + 4) {
00280 s->timestamp = s->cur_timestamp;
00281 }
00282
00283
00284 if (size > max_packet_size) {
00285
00286 count = 0;
00287 while (size > 0) {
00288 len = max_packet_size - 4;
00289 if (len > size)
00290 len = size;
00291
00292 s->buf[0] = 0;
00293 s->buf[1] = 0;
00294 s->buf[2] = count >> 8;
00295 s->buf[3] = count;
00296 memcpy(s->buf + 4, buf1, len);
00297 ff_rtp_send_data(s1, s->buf, len + 4, 0);
00298 size -= len;
00299 buf1 += len;
00300 count += len;
00301 }
00302 } else {
00303 if (s->buf_ptr == s->buf + 4) {
00304
00305 s->buf[0] = 0;
00306 s->buf[1] = 0;
00307 s->buf[2] = 0;
00308 s->buf[3] = 0;
00309 }
00310 memcpy(s->buf_ptr, buf1, size);
00311 s->buf_ptr += size;
00312 }
00313 }
00314
00315 static void rtp_send_raw(AVFormatContext *s1,
00316 const uint8_t *buf1, int size)
00317 {
00318 RTPMuxContext *s = s1->priv_data;
00319 int len, max_packet_size;
00320
00321 max_packet_size = s->max_payload_size;
00322
00323 while (size > 0) {
00324 len = max_packet_size;
00325 if (len > size)
00326 len = size;
00327
00328 s->timestamp = s->cur_timestamp;
00329 ff_rtp_send_data(s1, buf1, len, (len == size));
00330
00331 buf1 += len;
00332 size -= len;
00333 }
00334 }
00335
00336
00337 static void rtp_send_mpegts_raw(AVFormatContext *s1,
00338 const uint8_t *buf1, int size)
00339 {
00340 RTPMuxContext *s = s1->priv_data;
00341 int len, out_len;
00342
00343 while (size >= TS_PACKET_SIZE) {
00344 len = s->max_payload_size - (s->buf_ptr - s->buf);
00345 if (len > size)
00346 len = size;
00347 memcpy(s->buf_ptr, buf1, len);
00348 buf1 += len;
00349 size -= len;
00350 s->buf_ptr += len;
00351
00352 out_len = s->buf_ptr - s->buf;
00353 if (out_len >= s->max_payload_size) {
00354 ff_rtp_send_data(s1, s->buf, out_len, 0);
00355 s->buf_ptr = s->buf;
00356 }
00357 }
00358 }
00359
00360 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
00361 {
00362 RTPMuxContext *s = s1->priv_data;
00363 AVStream *st = s1->streams[0];
00364 int rtcp_bytes;
00365 int size= pkt->size;
00366
00367 av_dlog(s1, "%d: write len=%d\n", pkt->stream_index, size);
00368
00369 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
00370 RTCP_TX_RATIO_DEN;
00371 if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
00372 (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) {
00373 rtcp_send_sr(s1, ff_ntp_time());
00374 s->last_octet_count = s->octet_count;
00375 s->first_packet = 0;
00376 }
00377 s->cur_timestamp = s->base_timestamp + pkt->pts;
00378
00379 switch(st->codec->codec_id) {
00380 case CODEC_ID_PCM_MULAW:
00381 case CODEC_ID_PCM_ALAW:
00382 case CODEC_ID_PCM_U8:
00383 case CODEC_ID_PCM_S8:
00384 rtp_send_samples(s1, pkt->data, size, 1 * st->codec->channels);
00385 break;
00386 case CODEC_ID_PCM_U16BE:
00387 case CODEC_ID_PCM_U16LE:
00388 case CODEC_ID_PCM_S16BE:
00389 case CODEC_ID_PCM_S16LE:
00390 rtp_send_samples(s1, pkt->data, size, 2 * st->codec->channels);
00391 break;
00392 case CODEC_ID_ADPCM_G722:
00393
00394
00395
00396 rtp_send_samples(s1, pkt->data, size, 1 * st->codec->channels);
00397 break;
00398 case CODEC_ID_MP2:
00399 case CODEC_ID_MP3:
00400 rtp_send_mpegaudio(s1, pkt->data, size);
00401 break;
00402 case CODEC_ID_MPEG1VIDEO:
00403 case CODEC_ID_MPEG2VIDEO:
00404 ff_rtp_send_mpegvideo(s1, pkt->data, size);
00405 break;
00406 case CODEC_ID_AAC:
00407 ff_rtp_send_aac(s1, pkt->data, size);
00408 break;
00409 case CODEC_ID_AMR_NB:
00410 case CODEC_ID_AMR_WB:
00411 ff_rtp_send_amr(s1, pkt->data, size);
00412 break;
00413 case CODEC_ID_MPEG2TS:
00414 rtp_send_mpegts_raw(s1, pkt->data, size);
00415 break;
00416 case CODEC_ID_H264:
00417 ff_rtp_send_h264(s1, pkt->data, size);
00418 break;
00419 case CODEC_ID_H263:
00420 case CODEC_ID_H263P:
00421 ff_rtp_send_h263(s1, pkt->data, size);
00422 break;
00423 case CODEC_ID_VORBIS:
00424 case CODEC_ID_THEORA:
00425 ff_rtp_send_xiph(s1, pkt->data, size);
00426 break;
00427 case CODEC_ID_VP8:
00428 ff_rtp_send_vp8(s1, pkt->data, size);
00429 break;
00430 default:
00431
00432 rtp_send_raw(s1, pkt->data, size);
00433 break;
00434 }
00435 return 0;
00436 }
00437
00438 static int rtp_write_trailer(AVFormatContext *s1)
00439 {
00440 RTPMuxContext *s = s1->priv_data;
00441
00442 av_freep(&s->buf);
00443
00444 return 0;
00445 }
00446
00447 AVOutputFormat ff_rtp_muxer = {
00448 "rtp",
00449 NULL_IF_CONFIG_SMALL("RTP output format"),
00450 NULL,
00451 NULL,
00452 sizeof(RTPMuxContext),
00453 CODEC_ID_PCM_MULAW,
00454 CODEC_ID_NONE,
00455 rtp_write_header,
00456 rtp_write_packet,
00457 rtp_write_trailer,
00458 };