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