Add RTP packetization of Theora and Vorbis
[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 "avformat.h"
23 #include "mpegts.h"
24 #include "internal.h"
25 #include "libavutil/random_seed.h"
26
27 #include "rtpenc.h"
28
29 //#define DEBUG
30
31 #define RTCP_SR_SIZE 28
32
33 static int is_supported(enum CodecID id)
34 {
35     switch(id) {
36     case CODEC_ID_H263:
37     case CODEC_ID_H263P:
38     case CODEC_ID_H264:
39     case CODEC_ID_MPEG1VIDEO:
40     case CODEC_ID_MPEG2VIDEO:
41     case CODEC_ID_MPEG4:
42     case CODEC_ID_AAC:
43     case CODEC_ID_MP2:
44     case CODEC_ID_MP3:
45     case CODEC_ID_PCM_ALAW:
46     case CODEC_ID_PCM_MULAW:
47     case CODEC_ID_PCM_S8:
48     case CODEC_ID_PCM_S16BE:
49     case CODEC_ID_PCM_S16LE:
50     case CODEC_ID_PCM_U16BE:
51     case CODEC_ID_PCM_U16LE:
52     case CODEC_ID_PCM_U8:
53     case CODEC_ID_MPEG2TS:
54     case CODEC_ID_AMR_NB:
55     case CODEC_ID_AMR_WB:
56     case CODEC_ID_VORBIS:
57     case CODEC_ID_THEORA:
58         return 1;
59     default:
60         return 0;
61     }
62 }
63
64 static int rtp_write_header(AVFormatContext *s1)
65 {
66     RTPMuxContext *s = s1->priv_data;
67     int max_packet_size, n;
68     AVStream *st;
69
70     if (s1->nb_streams != 1)
71         return -1;
72     st = s1->streams[0];
73     if (!is_supported(st->codec->codec_id)) {
74         av_log(s1, AV_LOG_ERROR, "Unsupported codec %x\n", st->codec->codec_id);
75
76         return -1;
77     }
78
79     s->payload_type = ff_rtp_get_payload_type(st->codec);
80     if (s->payload_type < 0)
81         s->payload_type = RTP_PT_PRIVATE + (st->codec->codec_type == AVMEDIA_TYPE_AUDIO);
82
83     s->base_timestamp = av_get_random_seed();
84     s->timestamp = s->base_timestamp;
85     s->cur_timestamp = 0;
86     s->ssrc = av_get_random_seed();
87     s->first_packet = 1;
88     s->first_rtcp_ntp_time = ff_ntp_time();
89     if (s1->start_time_realtime)
90         /* Round the NTP time to whole milliseconds. */
91         s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +
92                                  NTP_OFFSET_US;
93
94     max_packet_size = url_fget_max_packet_size(s1->pb);
95     if (max_packet_size <= 12)
96         return AVERROR(EIO);
97     s->buf = av_malloc(max_packet_size);
98     if (s->buf == NULL) {
99         return AVERROR(ENOMEM);
100     }
101     s->max_payload_size = max_packet_size - 12;
102
103     s->max_frames_per_packet = 0;
104     if (s1->max_delay) {
105         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
106             if (st->codec->frame_size == 0) {
107                 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n");
108             } else {
109                 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);
110             }
111         }
112         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
113             /* FIXME: We should round down here... */
114             s->max_frames_per_packet = av_rescale_q(s1->max_delay, (AVRational){1, 1000000}, st->codec->time_base);
115         }
116     }
117
118     av_set_pts_info(st, 32, 1, 90000);
119     switch(st->codec->codec_id) {
120     case CODEC_ID_MP2:
121     case CODEC_ID_MP3:
122         s->buf_ptr = s->buf + 4;
123         break;
124     case CODEC_ID_MPEG1VIDEO:
125     case CODEC_ID_MPEG2VIDEO:
126         break;
127     case CODEC_ID_MPEG2TS:
128         n = s->max_payload_size / TS_PACKET_SIZE;
129         if (n < 1)
130             n = 1;
131         s->max_payload_size = n * TS_PACKET_SIZE;
132         s->buf_ptr = s->buf;
133         break;
134     case CODEC_ID_H264:
135         /* check for H.264 MP4 syntax */
136         if (st->codec->extradata_size > 4 && st->codec->extradata[0] == 1) {
137             s->nal_length_size = (st->codec->extradata[4] & 0x03) + 1;
138         }
139         break;
140     case CODEC_ID_VORBIS:
141     case CODEC_ID_THEORA:
142         if (!s->max_frames_per_packet) s->max_frames_per_packet = 15;
143         s->max_frames_per_packet = av_clip(s->max_frames_per_packet, 1, 15);
144         s->max_payload_size -= 6; // ident+frag+tdt/vdt+pkt_num+pkt_length
145         s->num_frames = 0;
146         goto defaultcase;
147     case CODEC_ID_AMR_NB:
148     case CODEC_ID_AMR_WB:
149         if (!s->max_frames_per_packet)
150             s->max_frames_per_packet = 12;
151         if (st->codec->codec_id == CODEC_ID_AMR_NB)
152             n = 31;
153         else
154             n = 61;
155         /* max_header_toc_size + the largest AMR payload must fit */
156         if (1 + s->max_frames_per_packet + n > s->max_payload_size) {
157             av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");
158             return -1;
159         }
160         if (st->codec->channels != 1) {
161             av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");
162             return -1;
163         }
164     case CODEC_ID_AAC:
165         s->num_frames = 0;
166     default:
167 defaultcase:
168         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
169             av_set_pts_info(st, 32, 1, st->codec->sample_rate);
170         }
171         s->buf_ptr = s->buf;
172         break;
173     }
174
175     return 0;
176 }
177
178 /* send an rtcp sender report packet */
179 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time)
180 {
181     RTPMuxContext *s = s1->priv_data;
182     uint32_t rtp_ts;
183
184     dprintf(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
185
186     s->last_rtcp_ntp_time = ntp_time;
187     rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
188                           s1->streams[0]->time_base) + s->base_timestamp;
189     put_byte(s1->pb, (RTP_VERSION << 6));
190     put_byte(s1->pb, 200);
191     put_be16(s1->pb, 6); /* length in words - 1 */
192     put_be32(s1->pb, s->ssrc);
193     put_be32(s1->pb, ntp_time / 1000000);
194     put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000);
195     put_be32(s1->pb, rtp_ts);
196     put_be32(s1->pb, s->packet_count);
197     put_be32(s1->pb, s->octet_count);
198     put_flush_packet(s1->pb);
199 }
200
201 /* send an rtp packet. sequence number is incremented, but the caller
202    must update the timestamp itself */
203 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
204 {
205     RTPMuxContext *s = s1->priv_data;
206
207     dprintf(s1, "rtp_send_data size=%d\n", len);
208
209     /* build the RTP header */
210     put_byte(s1->pb, (RTP_VERSION << 6));
211     put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));
212     put_be16(s1->pb, s->seq);
213     put_be32(s1->pb, s->timestamp);
214     put_be32(s1->pb, s->ssrc);
215
216     put_buffer(s1->pb, buf1, len);
217     put_flush_packet(s1->pb);
218
219     s->seq++;
220     s->octet_count += len;
221     s->packet_count++;
222 }
223
224 /* send an integer number of samples and compute time stamp and fill
225    the rtp send buffer before sending. */
226 static void rtp_send_samples(AVFormatContext *s1,
227                              const uint8_t *buf1, int size, int sample_size)
228 {
229     RTPMuxContext *s = s1->priv_data;
230     int len, max_packet_size, n;
231
232     max_packet_size = (s->max_payload_size / sample_size) * sample_size;
233     /* not needed, but who nows */
234     if ((size % sample_size) != 0)
235         av_abort();
236     n = 0;
237     while (size > 0) {
238         s->buf_ptr = s->buf;
239         len = FFMIN(max_packet_size, size);
240
241         /* copy data */
242         memcpy(s->buf_ptr, buf1, len);
243         s->buf_ptr += len;
244         buf1 += len;
245         size -= len;
246         s->timestamp = s->cur_timestamp + n / sample_size;
247         ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
248         n += (s->buf_ptr - s->buf);
249     }
250 }
251
252 static void rtp_send_mpegaudio(AVFormatContext *s1,
253                                const uint8_t *buf1, int size)
254 {
255     RTPMuxContext *s = s1->priv_data;
256     int len, count, max_packet_size;
257
258     max_packet_size = s->max_payload_size;
259
260     /* test if we must flush because not enough space */
261     len = (s->buf_ptr - s->buf);
262     if ((len + size) > max_packet_size) {
263         if (len > 4) {
264             ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);
265             s->buf_ptr = s->buf + 4;
266         }
267     }
268     if (s->buf_ptr == s->buf + 4) {
269         s->timestamp = s->cur_timestamp;
270     }
271
272     /* add the packet */
273     if (size > max_packet_size) {
274         /* big packet: fragment */
275         count = 0;
276         while (size > 0) {
277             len = max_packet_size - 4;
278             if (len > size)
279                 len = size;
280             /* build fragmented packet */
281             s->buf[0] = 0;
282             s->buf[1] = 0;
283             s->buf[2] = count >> 8;
284             s->buf[3] = count;
285             memcpy(s->buf + 4, buf1, len);
286             ff_rtp_send_data(s1, s->buf, len + 4, 0);
287             size -= len;
288             buf1 += len;
289             count += len;
290         }
291     } else {
292         if (s->buf_ptr == s->buf + 4) {
293             /* no fragmentation possible */
294             s->buf[0] = 0;
295             s->buf[1] = 0;
296             s->buf[2] = 0;
297             s->buf[3] = 0;
298         }
299         memcpy(s->buf_ptr, buf1, size);
300         s->buf_ptr += size;
301     }
302 }
303
304 static void rtp_send_raw(AVFormatContext *s1,
305                          const uint8_t *buf1, int size)
306 {
307     RTPMuxContext *s = s1->priv_data;
308     int len, max_packet_size;
309
310     max_packet_size = s->max_payload_size;
311
312     while (size > 0) {
313         len = max_packet_size;
314         if (len > size)
315             len = size;
316
317         s->timestamp = s->cur_timestamp;
318         ff_rtp_send_data(s1, buf1, len, (len == size));
319
320         buf1 += len;
321         size -= len;
322     }
323 }
324
325 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */
326 static void rtp_send_mpegts_raw(AVFormatContext *s1,
327                                 const uint8_t *buf1, int size)
328 {
329     RTPMuxContext *s = s1->priv_data;
330     int len, out_len;
331
332     while (size >= TS_PACKET_SIZE) {
333         len = s->max_payload_size - (s->buf_ptr - s->buf);
334         if (len > size)
335             len = size;
336         memcpy(s->buf_ptr, buf1, len);
337         buf1 += len;
338         size -= len;
339         s->buf_ptr += len;
340
341         out_len = s->buf_ptr - s->buf;
342         if (out_len >= s->max_payload_size) {
343             ff_rtp_send_data(s1, s->buf, out_len, 0);
344             s->buf_ptr = s->buf;
345         }
346     }
347 }
348
349 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
350 {
351     RTPMuxContext *s = s1->priv_data;
352     AVStream *st = s1->streams[0];
353     int rtcp_bytes;
354     int size= pkt->size;
355
356     dprintf(s1, "%d: write len=%d\n", pkt->stream_index, size);
357
358     rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
359         RTCP_TX_RATIO_DEN;
360     if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&
361                            (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) {
362         rtcp_send_sr(s1, ff_ntp_time());
363         s->last_octet_count = s->octet_count;
364         s->first_packet = 0;
365     }
366     s->cur_timestamp = s->base_timestamp + pkt->pts;
367
368     switch(st->codec->codec_id) {
369     case CODEC_ID_PCM_MULAW:
370     case CODEC_ID_PCM_ALAW:
371     case CODEC_ID_PCM_U8:
372     case CODEC_ID_PCM_S8:
373         rtp_send_samples(s1, pkt->data, size, 1 * st->codec->channels);
374         break;
375     case CODEC_ID_PCM_U16BE:
376     case CODEC_ID_PCM_U16LE:
377     case CODEC_ID_PCM_S16BE:
378     case CODEC_ID_PCM_S16LE:
379         rtp_send_samples(s1, pkt->data, size, 2 * st->codec->channels);
380         break;
381     case CODEC_ID_MP2:
382     case CODEC_ID_MP3:
383         rtp_send_mpegaudio(s1, pkt->data, size);
384         break;
385     case CODEC_ID_MPEG1VIDEO:
386     case CODEC_ID_MPEG2VIDEO:
387         ff_rtp_send_mpegvideo(s1, pkt->data, size);
388         break;
389     case CODEC_ID_AAC:
390         ff_rtp_send_aac(s1, pkt->data, size);
391         break;
392     case CODEC_ID_AMR_NB:
393     case CODEC_ID_AMR_WB:
394         ff_rtp_send_amr(s1, pkt->data, size);
395         break;
396     case CODEC_ID_MPEG2TS:
397         rtp_send_mpegts_raw(s1, pkt->data, size);
398         break;
399     case CODEC_ID_H264:
400         ff_rtp_send_h264(s1, pkt->data, size);
401         break;
402     case CODEC_ID_H263:
403     case CODEC_ID_H263P:
404         ff_rtp_send_h263(s1, pkt->data, size);
405         break;
406     case CODEC_ID_VORBIS:
407     case CODEC_ID_THEORA:
408         ff_rtp_send_xiph(s1, pkt->data, size);
409         break;
410     default:
411         /* better than nothing : send the codec raw data */
412         rtp_send_raw(s1, pkt->data, size);
413         break;
414     }
415     return 0;
416 }
417
418 static int rtp_write_trailer(AVFormatContext *s1)
419 {
420     RTPMuxContext *s = s1->priv_data;
421
422     av_freep(&s->buf);
423
424     return 0;
425 }
426
427 AVOutputFormat rtp_muxer = {
428     "rtp",
429     NULL_IF_CONFIG_SMALL("RTP output format"),
430     NULL,
431     NULL,
432     sizeof(RTPMuxContext),
433     CODEC_ID_PCM_MULAW,
434     CODEC_ID_NONE,
435     rtp_write_header,
436     rtp_write_packet,
437     rtp_write_trailer,
438 };