0e129acea6f9d027cb733cc4e3142dfc48061dd5
[ffmpeg.git] / 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
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
37 static uint64_t ntp_time(void)
38 {
39   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
40 }
41
42 static 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 = 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 */
119 static 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 */
144 void 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. */
167 static 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 */
195 static 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
247 static 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 */
269 static 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. */
293 static 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
351 static 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
360 AVOutputFormat 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 };