00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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_mpv.h"
00030 #include "rtp_aac.h"
00031 #include "rtp_h264.h"
00032
00033
00034
00035 #define RTCP_SR_SIZE 28
00036
00037 static int rtp_write_header(AVFormatContext *s1)
00038 {
00039 RTPDemuxContext *s = s1->priv_data;
00040 int payload_type, max_packet_size, n;
00041 AVStream *st;
00042
00043 if (s1->nb_streams != 1)
00044 return -1;
00045 st = s1->streams[0];
00046
00047 payload_type = rtp_get_payload_type(st->codec);
00048 if (payload_type < 0)
00049 payload_type = RTP_PT_PRIVATE;
00050 s->payload_type = payload_type;
00051
00052
00053 s->base_timestamp = 0;
00054 s->timestamp = s->base_timestamp;
00055 s->cur_timestamp = 0;
00056 s->ssrc = 0;
00057 s->first_packet = 1;
00058 s->first_rtcp_ntp_time = AV_NOPTS_VALUE;
00059
00060 max_packet_size = url_fget_max_packet_size(s1->pb);
00061 if (max_packet_size <= 12)
00062 return AVERROR(EIO);
00063 s->max_payload_size = max_packet_size - 12;
00064
00065 s->max_frames_per_packet = 0;
00066 if (s1->max_delay) {
00067 if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
00068 if (st->codec->frame_size == 0) {
00069 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
00070 } else {
00071 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);
00072 }
00073 }
00074 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
00075
00076 s->max_frames_per_packet = av_rescale_q(s1->max_delay, AV_TIME_BASE_Q, st->codec->time_base);
00077 }
00078 }
00079
00080 av_set_pts_info(st, 32, 1, 90000);
00081 switch(st->codec->codec_id) {
00082 case CODEC_ID_MP2:
00083 case CODEC_ID_MP3:
00084 s->buf_ptr = s->buf + 4;
00085 break;
00086 case CODEC_ID_MPEG1VIDEO:
00087 case CODEC_ID_MPEG2VIDEO:
00088 break;
00089 case CODEC_ID_MPEG2TS:
00090 n = s->max_payload_size / TS_PACKET_SIZE;
00091 if (n < 1)
00092 n = 1;
00093 s->max_payload_size = n * TS_PACKET_SIZE;
00094 s->buf_ptr = s->buf;
00095 break;
00096 case CODEC_ID_AAC:
00097 s->read_buf_index = 0;
00098 default:
00099 if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
00100 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
00101 }
00102 s->buf_ptr = s->buf;
00103 break;
00104 }
00105
00106 return 0;
00107 }
00108
00109
00110 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
00111 {
00112 RTPDemuxContext *s = s1->priv_data;
00113 uint32_t rtp_ts;
00114
00115 #if defined(DEBUG)
00116 printf("RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
00117 #endif
00118
00119 if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE) s->first_rtcp_ntp_time = ntp_time;
00120 s->last_rtcp_ntp_time = ntp_time;
00121 rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, AV_TIME_BASE_Q,
00122 s1->streams[0]->time_base) + s->base_timestamp;
00123 put_byte(s1->pb, (RTP_VERSION << 6));
00124 put_byte(s1->pb, 200);
00125 put_be16(s1->pb, 6);
00126 put_be32(s1->pb, s->ssrc);
00127 put_be32(s1->pb, ntp_time / 1000000);
00128 put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
00129 put_be32(s1->pb, rtp_ts);
00130 put_be32(s1->pb, s->packet_count);
00131 put_be32(s1->pb, s->octet_count);
00132 put_flush_packet(s1->pb);
00133 }
00134
00135
00136
00137 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
00138 {
00139 RTPDemuxContext *s = s1->priv_data;
00140
00141 #ifdef DEBUG
00142 printf("rtp_send_data size=%d\n", len);
00143 #endif
00144
00145
00146 put_byte(s1->pb, (RTP_VERSION << 6));
00147 put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
00148 put_be16(s1->pb, s->seq);
00149 put_be32(s1->pb, s->timestamp);
00150 put_be32(s1->pb, s->ssrc);
00151
00152 put_buffer(s1->pb, buf1, len);
00153 put_flush_packet(s1->pb);
00154
00155 s->seq++;
00156 s->octet_count += len;
00157 s->packet_count++;
00158 }
00159
00160
00161
00162 static void rtp_send_samples(AVFormatContext *s1,
00163 const uint8_t *buf1, int size, int sample_size)
00164 {
00165 RTPDemuxContext *s = s1->priv_data;
00166 int len, max_packet_size, n;
00167
00168 max_packet_size = (s->max_payload_size / sample_size) * sample_size;
00169
00170 if ((size % sample_size) != 0)
00171 av_abort();
00172 n = 0;
00173 while (size > 0) {
00174 s->buf_ptr = s->buf;
00175 len = FFMIN(max_packet_size, size);
00176
00177
00178 memcpy(s->buf_ptr, buf1, len);
00179 s->buf_ptr += len;
00180 buf1 += len;
00181 size -= len;
00182 s->timestamp = s->cur_timestamp + n / sample_size;
00183 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
00184 n += (s->buf_ptr - s->buf);
00185 }
00186 }
00187
00188
00189
00190 static void rtp_send_mpegaudio(AVFormatContext *s1,
00191 const uint8_t *buf1, int size)
00192 {
00193 RTPDemuxContext *s = s1->priv_data;
00194 int len, count, max_packet_size;
00195
00196 max_packet_size = s->max_payload_size;
00197
00198
00199 len = (s->buf_ptr - s->buf);
00200 if ((len + size) > max_packet_size) {
00201 if (len > 4) {
00202 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
00203 s->buf_ptr = s->buf + 4;
00204 }
00205 }
00206 if (s->buf_ptr == s->buf + 4) {
00207 s->timestamp = s->cur_timestamp;
00208 }
00209
00210
00211 if (size > max_packet_size) {
00212
00213 count = 0;
00214 while (size > 0) {
00215 len = max_packet_size - 4;
00216 if (len > size)
00217 len = size;
00218
00219 s->buf[0] = 0;
00220 s->buf[1] = 0;
00221 s->buf[2] = count >> 8;
00222 s->buf[3] = count;
00223 memcpy(s->buf + 4, buf1, len);
00224 ff_rtp_send_data(s1, s->buf, len + 4, 0);
00225 size -= len;
00226 buf1 += len;
00227 count += len;
00228 }
00229 } else {
00230 if (s->buf_ptr == s->buf + 4) {
00231
00232 s->buf[0] = 0;
00233 s->buf[1] = 0;
00234 s->buf[2] = 0;
00235 s->buf[3] = 0;
00236 }
00237 memcpy(s->buf_ptr, buf1, size);
00238 s->buf_ptr += size;
00239 }
00240 }
00241
00242 static void rtp_send_raw(AVFormatContext *s1,
00243 const uint8_t *buf1, int size)
00244 {
00245 RTPDemuxContext *s = s1->priv_data;
00246 int len, max_packet_size;
00247
00248 max_packet_size = s->max_payload_size;
00249
00250 while (size > 0) {
00251 len = max_packet_size;
00252 if (len > size)
00253 len = size;
00254
00255 s->timestamp = s->cur_timestamp;
00256 ff_rtp_send_data(s1, buf1, len, (len == size));
00257
00258 buf1 += len;
00259 size -= len;
00260 }
00261 }
00262
00263
00264 static void rtp_send_mpegts_raw(AVFormatContext *s1,
00265 const uint8_t *buf1, int size)
00266 {
00267 RTPDemuxContext *s = s1->priv_data;
00268 int len, out_len;
00269
00270 while (size >= TS_PACKET_SIZE) {
00271 len = s->max_payload_size - (s->buf_ptr - s->buf);
00272 if (len > size)
00273 len = size;
00274 memcpy(s->buf_ptr, buf1, len);
00275 buf1 += len;
00276 size -= len;
00277 s->buf_ptr += len;
00278
00279 out_len = s->buf_ptr - s->buf;
00280 if (out_len >= s->max_payload_size) {
00281 ff_rtp_send_data(s1, s->buf, out_len, 0);
00282 s->buf_ptr = s->buf;
00283 }
00284 }
00285 }
00286
00287
00288 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
00289 {
00290 RTPDemuxContext *s = s1->priv_data;
00291 AVStream *st = s1->streams[0];
00292 int rtcp_bytes;
00293 int size= pkt->size;
00294 uint8_t *buf1= pkt->data;
00295
00296 #ifdef DEBUG
00297 printf("%d: write len=%d\n", pkt->stream_index, size);
00298 #endif
00299
00300
00301 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
00302 RTCP_TX_RATIO_DEN;
00303 if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
00304 (av_gettime() - s->last_rtcp_ntp_time > 5000000))) {
00305 rtcp_send_sr(s1, av_gettime());
00306 s->last_octet_count = s->octet_count;
00307 s->first_packet = 0;
00308 }
00309 s->cur_timestamp = s->base_timestamp + pkt->pts;
00310
00311 switch(st->codec->codec_id) {
00312 case CODEC_ID_PCM_MULAW:
00313 case CODEC_ID_PCM_ALAW:
00314 case CODEC_ID_PCM_U8:
00315 case CODEC_ID_PCM_S8:
00316 rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
00317 break;
00318 case CODEC_ID_PCM_U16BE:
00319 case CODEC_ID_PCM_U16LE:
00320 case CODEC_ID_PCM_S16BE:
00321 case CODEC_ID_PCM_S16LE:
00322 rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
00323 break;
00324 case CODEC_ID_MP2:
00325 case CODEC_ID_MP3:
00326 rtp_send_mpegaudio(s1, buf1, size);
00327 break;
00328 case CODEC_ID_MPEG1VIDEO:
00329 case CODEC_ID_MPEG2VIDEO:
00330 ff_rtp_send_mpegvideo(s1, buf1, size);
00331 break;
00332 case CODEC_ID_AAC:
00333 ff_rtp_send_aac(s1, buf1, size);
00334 break;
00335 case CODEC_ID_MPEG2TS:
00336 rtp_send_mpegts_raw(s1, buf1, size);
00337 break;
00338 case CODEC_ID_H264:
00339 ff_rtp_send_h264(s1, buf1, size);
00340 break;
00341 default:
00342
00343 rtp_send_raw(s1, buf1, size);
00344 break;
00345 }
00346 return 0;
00347 }
00348
00349 AVOutputFormat rtp_muxer = {
00350 "rtp",
00351 "RTP output format",
00352 NULL,
00353 NULL,
00354 sizeof(RTPDemuxContext),
00355 CODEC_ID_PCM_MULAW,
00356 CODEC_ID_NONE,
00357 rtp_write_header,
00358 rtp_write_packet,
00359 };