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