Mercurial > libavformat.hg
annotate rtpenc.c @ 6449:3a28e6827095 libavformat
Solving memory leak and initialization problem with prev_pkt / pkt.
author | bindhammer |
---|---|
date | Tue, 31 Aug 2010 07:15:11 +0000 |
parents | 37944ce385a0 |
children | f06908662125 |
rev | line source |
---|---|
0 | 1 /* |
2892
0d82fdf4fa94
Split the RTP muxer out of rtp.c, to simplify the RTSP demuxer's dependencies
lucabe
parents:
2891
diff
changeset
|
2 * RTP output format |
4251
77e0c7511d41
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
3579
diff
changeset
|
3 * Copyright (c) 2002 Fabrice Bellard |
0 | 4 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1332
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1332
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1332
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
0 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1332
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1332
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 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 | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1332
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
885
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
3286 | 21 |
0 | 22 #include "avformat.h" |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
23 #include "mpegts.h" |
5807
f4ca0041b4f4
Make the ntp_time function available to other parts of libavformat, as ff_ntp_time
mstorsjo
parents:
5646
diff
changeset
|
24 #include "internal.h" |
5901
7028f9476da4
Initialize ssrc and base_timestamp using ff_random_get_seed()
mstorsjo
parents:
5842
diff
changeset
|
25 #include "libavutil/random_seed.h" |
0 | 26 |
4388 | 27 #include "rtpenc.h" |
1419 | 28 |
0 | 29 //#define DEBUG |
30 | |
2705
cc693f9e80ee
Use a symbolic name for the payload size of an RTCP Sender Report packet
lucabe
parents:
2587
diff
changeset
|
31 #define RTCP_SR_SIZE 28 |
0 | 32 |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
33 static int is_supported(enum CodecID id) |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
34 { |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
35 switch(id) { |
4814 | 36 case CODEC_ID_H263: |
37 case CODEC_ID_H263P: | |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
38 case CODEC_ID_H264: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
39 case CODEC_ID_MPEG1VIDEO: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
40 case CODEC_ID_MPEG2VIDEO: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
41 case CODEC_ID_MPEG4: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
42 case CODEC_ID_AAC: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
43 case CODEC_ID_MP2: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
44 case CODEC_ID_MP3: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
45 case CODEC_ID_PCM_ALAW: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
46 case CODEC_ID_PCM_MULAW: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
47 case CODEC_ID_PCM_S8: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
48 case CODEC_ID_PCM_S16BE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
49 case CODEC_ID_PCM_S16LE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
50 case CODEC_ID_PCM_U16BE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
51 case CODEC_ID_PCM_U16LE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
52 case CODEC_ID_PCM_U8: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
53 case CODEC_ID_MPEG2TS: |
4836 | 54 case CODEC_ID_AMR_NB: |
55 case CODEC_ID_AMR_WB: | |
6349 | 56 case CODEC_ID_VORBIS: |
57 case CODEC_ID_THEORA: | |
6379 | 58 case CODEC_ID_VP8: |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
59 return 1; |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
60 default: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
61 return 0; |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
62 } |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
63 } |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
64 |
0 | 65 static int rtp_write_header(AVFormatContext *s1) |
66 { | |
4388 | 67 RTPMuxContext *s = s1->priv_data; |
5477 | 68 int max_packet_size, n; |
0 | 69 AVStream *st; |
70 | |
71 if (s1->nb_streams != 1) | |
72 return -1; | |
73 st = s1->streams[0]; | |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
74 if (!is_supported(st->codec->codec_id)) { |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
75 av_log(s1, AV_LOG_ERROR, "Unsupported codec %x\n", st->codec->codec_id); |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
76 |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
77 return -1; |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
78 } |
0 | 79 |
5477 | 80 s->payload_type = ff_rtp_get_payload_type(st->codec); |
81 if (s->payload_type < 0) | |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
82 s->payload_type = RTP_PT_PRIVATE + (st->codec->codec_type == AVMEDIA_TYPE_AUDIO); |
0 | 83 |
6036
201152a121b5
Make ff_random_get_seed public, rename to av_get_random_seed, export the header
mstorsjo
parents:
5910
diff
changeset
|
84 s->base_timestamp = av_get_random_seed(); |
0 | 85 s->timestamp = s->base_timestamp; |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
86 s->cur_timestamp = 0; |
6036
201152a121b5
Make ff_random_get_seed public, rename to av_get_random_seed, export the header
mstorsjo
parents:
5910
diff
changeset
|
87 s->ssrc = av_get_random_seed(); |
0 | 88 s->first_packet = 1; |
5807
f4ca0041b4f4
Make the ntp_time function available to other parts of libavformat, as ff_ntp_time
mstorsjo
parents:
5646
diff
changeset
|
89 s->first_rtcp_ntp_time = ff_ntp_time(); |
5842
cc35562d3747
Use AVFormatContext.start_time_realtime in the RTP muxer
mstorsjo
parents:
5807
diff
changeset
|
90 if (s1->start_time_realtime) |
cc35562d3747
Use AVFormatContext.start_time_realtime in the RTP muxer
mstorsjo
parents:
5807
diff
changeset
|
91 /* Round the NTP time to whole milliseconds. */ |
cc35562d3747
Use AVFormatContext.start_time_realtime in the RTP muxer
mstorsjo
parents:
5807
diff
changeset
|
92 s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 + |
cc35562d3747
Use AVFormatContext.start_time_realtime in the RTP muxer
mstorsjo
parents:
5807
diff
changeset
|
93 NTP_OFFSET_US; |
0 | 94 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
95 max_packet_size = url_fget_max_packet_size(s1->pb); |
0 | 96 if (max_packet_size <= 12) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2222
diff
changeset
|
97 return AVERROR(EIO); |
4391 | 98 s->buf = av_malloc(max_packet_size); |
99 if (s->buf == NULL) { | |
100 return AVERROR(ENOMEM); | |
101 } | |
0 | 102 s->max_payload_size = max_packet_size - 12; |
103 | |
2587
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
104 s->max_frames_per_packet = 0; |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
105 if (s1->max_delay) { |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
106 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { |
2587
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
107 if (st->codec->frame_size == 0) { |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
108 av_log(s1, AV_LOG_ERROR, "Cannot respect max delay: frame size = 0\n"); |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
109 } else { |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
110 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); |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
111 } |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
112 } |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
113 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { |
2587
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
114 /* FIXME: We should round down here... */ |
3500 | 115 s->max_frames_per_packet = av_rescale_q(s1->max_delay, (AVRational){1, 1000000}, st->codec->time_base); |
2587
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
116 } |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
117 } |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
118 |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
119 av_set_pts_info(st, 32, 1, 90000); |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
777
diff
changeset
|
120 switch(st->codec->codec_id) { |
0 | 121 case CODEC_ID_MP2: |
232 | 122 case CODEC_ID_MP3: |
0 | 123 s->buf_ptr = s->buf + 4; |
124 break; | |
125 case CODEC_ID_MPEG1VIDEO: | |
2760 | 126 case CODEC_ID_MPEG2VIDEO: |
0 | 127 break; |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
128 case CODEC_ID_MPEG2TS: |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
129 n = s->max_payload_size / TS_PACKET_SIZE; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
130 if (n < 1) |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
131 n = 1; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
132 s->max_payload_size = n * TS_PACKET_SIZE; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
133 s->buf_ptr = s->buf; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
134 break; |
6136
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
135 case CODEC_ID_H264: |
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
136 /* check for H.264 MP4 syntax */ |
6139
397ef451b549
Simplify (no need to check for st->codec->extradata) and correct
lucabe
parents:
6136
diff
changeset
|
137 if (st->codec->extradata_size > 4 && st->codec->extradata[0] == 1) { |
6136
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
138 s->nal_length_size = (st->codec->extradata[4] & 0x03) + 1; |
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
139 } |
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
140 break; |
6349 | 141 case CODEC_ID_VORBIS: |
142 case CODEC_ID_THEORA: | |
143 if (!s->max_frames_per_packet) s->max_frames_per_packet = 15; | |
144 s->max_frames_per_packet = av_clip(s->max_frames_per_packet, 1, 15); | |
145 s->max_payload_size -= 6; // ident+frag+tdt/vdt+pkt_num+pkt_length | |
146 s->num_frames = 0; | |
147 goto defaultcase; | |
6379 | 148 case CODEC_ID_VP8: |
149 av_log(s1, AV_LOG_WARNING, "RTP VP8 payload is still experimental\n"); | |
150 break; | |
4836 | 151 case CODEC_ID_AMR_NB: |
152 case CODEC_ID_AMR_WB: | |
153 if (!s->max_frames_per_packet) | |
154 s->max_frames_per_packet = 12; | |
155 if (st->codec->codec_id == CODEC_ID_AMR_NB) | |
156 n = 31; | |
157 else | |
158 n = 61; | |
159 /* max_header_toc_size + the largest AMR payload must fit */ | |
160 if (1 + s->max_frames_per_packet + n > s->max_payload_size) { | |
161 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n"); | |
162 return -1; | |
163 } | |
164 if (st->codec->channels != 1) { | |
165 av_log(s1, AV_LOG_ERROR, "Only mono is supported\n"); | |
166 return -1; | |
167 } | |
2550
e9c34ec665c6
Support for AAC streaming over RTP. Fragmentation is not implemented yet
lucabe
parents:
2540
diff
changeset
|
168 case CODEC_ID_AAC: |
4380
1b695f013cd3
Introduce a new num_frames field in RTPDemuxContext so that rtp_aac.c
lucabe
parents:
4291
diff
changeset
|
169 s->num_frames = 0; |
0 | 170 default: |
6349 | 171 defaultcase: |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
172 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { |
2539
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
173 av_set_pts_info(st, 32, 1, st->codec->sample_rate); |
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
174 } |
0 | 175 s->buf_ptr = s->buf; |
176 break; | |
177 } | |
178 | |
179 return 0; | |
180 } | |
181 | |
182 /* send an rtcp sender report packet */ | |
65 | 183 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time) |
0 | 184 { |
4388 | 185 RTPMuxContext *s = s1->priv_data; |
2539
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
186 uint32_t rtp_ts; |
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
187 |
3579 | 188 dprintf(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp); |
2539
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
189 |
2706
b1723b8da595
Do not send too many RTCP packets (according to RFC 3550, the minimum
lucabe
parents:
2705
diff
changeset
|
190 s->last_rtcp_ntp_time = ntp_time; |
3500 | 191 rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000}, |
2539
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
192 s1->streams[0]->time_base) + s->base_timestamp; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
193 put_byte(s1->pb, (RTP_VERSION << 6)); |
6404
37944ce385a0
rtp: Replace hardcoded RTCP packet types with defines
mstorsjo
parents:
6379
diff
changeset
|
194 put_byte(s1->pb, RTCP_SR); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
195 put_be16(s1->pb, 6); /* length in words - 1 */ |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
196 put_be32(s1->pb, s->ssrc); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
197 put_be32(s1->pb, ntp_time / 1000000); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
198 put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
199 put_be32(s1->pb, rtp_ts); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
200 put_be32(s1->pb, s->packet_count); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
201 put_be32(s1->pb, s->octet_count); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
202 put_flush_packet(s1->pb); |
0 | 203 } |
204 | |
205 /* send an rtp packet. sequence number is incremented, but the caller | |
206 must update the timestamp itself */ | |
2406
18e94e5989d8
Move the RTP packetization code for MPEG12 video in its own file (rtp_mpv.c)
lucabe
parents:
2274
diff
changeset
|
207 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m) |
0 | 208 { |
4388 | 209 RTPMuxContext *s = s1->priv_data; |
0 | 210 |
3579 | 211 dprintf(s1, "rtp_send_data size=%d\n", len); |
0 | 212 |
213 /* build the RTP header */ | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
214 put_byte(s1->pb, (RTP_VERSION << 6)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
215 put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
216 put_be16(s1->pb, s->seq); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
217 put_be32(s1->pb, s->timestamp); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
218 put_be32(s1->pb, s->ssrc); |
885 | 219 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
220 put_buffer(s1->pb, buf1, len); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
221 put_flush_packet(s1->pb); |
885 | 222 |
0 | 223 s->seq++; |
224 s->octet_count += len; | |
225 s->packet_count++; | |
226 } | |
227 | |
228 /* send an integer number of samples and compute time stamp and fill | |
229 the rtp send buffer before sending. */ | |
230 static void rtp_send_samples(AVFormatContext *s1, | |
241 | 231 const uint8_t *buf1, int size, int sample_size) |
0 | 232 { |
4388 | 233 RTPMuxContext *s = s1->priv_data; |
0 | 234 int len, max_packet_size, n; |
235 | |
236 max_packet_size = (s->max_payload_size / sample_size) * sample_size; | |
237 /* not needed, but who nows */ | |
238 if ((size % sample_size) != 0) | |
239 av_abort(); | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
240 n = 0; |
0 | 241 while (size > 0) { |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
242 s->buf_ptr = s->buf; |
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
243 len = FFMIN(max_packet_size, size); |
0 | 244 |
245 /* copy data */ | |
246 memcpy(s->buf_ptr, buf1, len); | |
247 s->buf_ptr += len; | |
248 buf1 += len; | |
249 size -= len; | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
250 s->timestamp = s->cur_timestamp + n / sample_size; |
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
251 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0); |
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
252 n += (s->buf_ptr - s->buf); |
0 | 253 } |
885 | 254 } |
0 | 255 |
256 static void rtp_send_mpegaudio(AVFormatContext *s1, | |
241 | 257 const uint8_t *buf1, int size) |
0 | 258 { |
4388 | 259 RTPMuxContext *s = s1->priv_data; |
0 | 260 int len, count, max_packet_size; |
261 | |
262 max_packet_size = s->max_payload_size; | |
263 | |
264 /* test if we must flush because not enough space */ | |
265 len = (s->buf_ptr - s->buf); | |
266 if ((len + size) > max_packet_size) { | |
267 if (len > 4) { | |
2406
18e94e5989d8
Move the RTP packetization code for MPEG12 video in its own file (rtp_mpv.c)
lucabe
parents:
2274
diff
changeset
|
268 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0); |
0 | 269 s->buf_ptr = s->buf + 4; |
270 } | |
271 } | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
272 if (s->buf_ptr == s->buf + 4) { |
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
273 s->timestamp = s->cur_timestamp; |
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
274 } |
0 | 275 |
276 /* add the packet */ | |
277 if (size > max_packet_size) { | |
278 /* big packet: fragment */ | |
279 count = 0; | |
280 while (size > 0) { | |
281 len = max_packet_size - 4; | |
282 if (len > size) | |
283 len = size; | |
284 /* build fragmented packet */ | |
285 s->buf[0] = 0; | |
286 s->buf[1] = 0; | |
287 s->buf[2] = count >> 8; | |
288 s->buf[3] = count; | |
289 memcpy(s->buf + 4, buf1, len); | |
2406
18e94e5989d8
Move the RTP packetization code for MPEG12 video in its own file (rtp_mpv.c)
lucabe
parents:
2274
diff
changeset
|
290 ff_rtp_send_data(s1, s->buf, len + 4, 0); |
0 | 291 size -= len; |
292 buf1 += len; | |
293 count += len; | |
294 } | |
295 } else { | |
296 if (s->buf_ptr == s->buf + 4) { | |
297 /* no fragmentation possible */ | |
298 s->buf[0] = 0; | |
299 s->buf[1] = 0; | |
300 s->buf[2] = 0; | |
301 s->buf[3] = 0; | |
302 } | |
303 memcpy(s->buf_ptr, buf1, size); | |
304 s->buf_ptr += size; | |
305 } | |
306 } | |
307 | |
308 static void rtp_send_raw(AVFormatContext *s1, | |
241 | 309 const uint8_t *buf1, int size) |
0 | 310 { |
4388 | 311 RTPMuxContext *s = s1->priv_data; |
0 | 312 int len, max_packet_size; |
313 | |
314 max_packet_size = s->max_payload_size; | |
315 | |
316 while (size > 0) { | |
317 len = max_packet_size; | |
318 if (len > size) | |
319 len = size; | |
320 | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
321 s->timestamp = s->cur_timestamp; |
2406
18e94e5989d8
Move the RTP packetization code for MPEG12 video in its own file (rtp_mpv.c)
lucabe
parents:
2274
diff
changeset
|
322 ff_rtp_send_data(s1, buf1, len, (len == size)); |
0 | 323 |
324 buf1 += len; | |
325 size -= len; | |
326 } | |
327 } | |
328 | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
329 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */ |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
330 static void rtp_send_mpegts_raw(AVFormatContext *s1, |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
331 const uint8_t *buf1, int size) |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
332 { |
4388 | 333 RTPMuxContext *s = s1->priv_data; |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
334 int len, out_len; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
335 |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
336 while (size >= TS_PACKET_SIZE) { |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
337 len = s->max_payload_size - (s->buf_ptr - s->buf); |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
338 if (len > size) |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
339 len = size; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
340 memcpy(s->buf_ptr, buf1, len); |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
341 buf1 += len; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
342 size -= len; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
343 s->buf_ptr += len; |
885 | 344 |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
345 out_len = s->buf_ptr - s->buf; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
346 if (out_len >= s->max_payload_size) { |
2406
18e94e5989d8
Move the RTP packetization code for MPEG12 video in its own file (rtp_mpv.c)
lucabe
parents:
2274
diff
changeset
|
347 ff_rtp_send_data(s1, s->buf, out_len, 0); |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
348 s->buf_ptr = s->buf; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
349 } |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
350 } |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
351 } |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
352 |
468 | 353 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt) |
0 | 354 { |
4388 | 355 RTPMuxContext *s = s1->priv_data; |
0 | 356 AVStream *st = s1->streams[0]; |
357 int rtcp_bytes; | |
468 | 358 int size= pkt->size; |
885 | 359 |
3579 | 360 dprintf(s1, "%d: write len=%d\n", pkt->stream_index, size); |
0 | 361 |
885 | 362 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / |
0 | 363 RTCP_TX_RATIO_DEN; |
2706
b1723b8da595
Do not send too many RTCP packets (according to RFC 3550, the minimum
lucabe
parents:
2705
diff
changeset
|
364 if (s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) && |
5807
f4ca0041b4f4
Make the ntp_time function available to other parts of libavformat, as ff_ntp_time
mstorsjo
parents:
5646
diff
changeset
|
365 (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) { |
f4ca0041b4f4
Make the ntp_time function available to other parts of libavformat, as ff_ntp_time
mstorsjo
parents:
5646
diff
changeset
|
366 rtcp_send_sr(s1, ff_ntp_time()); |
0 | 367 s->last_octet_count = s->octet_count; |
368 s->first_packet = 0; | |
369 } | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
370 s->cur_timestamp = s->base_timestamp + pkt->pts; |
0 | 371 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
777
diff
changeset
|
372 switch(st->codec->codec_id) { |
0 | 373 case CODEC_ID_PCM_MULAW: |
374 case CODEC_ID_PCM_ALAW: | |
375 case CODEC_ID_PCM_U8: | |
376 case CODEC_ID_PCM_S8: | |
5479 | 377 rtp_send_samples(s1, pkt->data, size, 1 * st->codec->channels); |
0 | 378 break; |
379 case CODEC_ID_PCM_U16BE: | |
380 case CODEC_ID_PCM_U16LE: | |
381 case CODEC_ID_PCM_S16BE: | |
382 case CODEC_ID_PCM_S16LE: | |
5479 | 383 rtp_send_samples(s1, pkt->data, size, 2 * st->codec->channels); |
0 | 384 break; |
385 case CODEC_ID_MP2: | |
232 | 386 case CODEC_ID_MP3: |
5479 | 387 rtp_send_mpegaudio(s1, pkt->data, size); |
0 | 388 break; |
389 case CODEC_ID_MPEG1VIDEO: | |
2760 | 390 case CODEC_ID_MPEG2VIDEO: |
5479 | 391 ff_rtp_send_mpegvideo(s1, pkt->data, size); |
0 | 392 break; |
2550
e9c34ec665c6
Support for AAC streaming over RTP. Fragmentation is not implemented yet
lucabe
parents:
2540
diff
changeset
|
393 case CODEC_ID_AAC: |
5479 | 394 ff_rtp_send_aac(s1, pkt->data, size); |
2550
e9c34ec665c6
Support for AAC streaming over RTP. Fragmentation is not implemented yet
lucabe
parents:
2540
diff
changeset
|
395 break; |
4836 | 396 case CODEC_ID_AMR_NB: |
397 case CODEC_ID_AMR_WB: | |
5479 | 398 ff_rtp_send_amr(s1, pkt->data, size); |
4836 | 399 break; |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
400 case CODEC_ID_MPEG2TS: |
5479 | 401 rtp_send_mpegts_raw(s1, pkt->data, size); |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
402 break; |
2960 | 403 case CODEC_ID_H264: |
5479 | 404 ff_rtp_send_h264(s1, pkt->data, size); |
2960 | 405 break; |
4814 | 406 case CODEC_ID_H263: |
407 case CODEC_ID_H263P: | |
5479 | 408 ff_rtp_send_h263(s1, pkt->data, size); |
4814 | 409 break; |
6349 | 410 case CODEC_ID_VORBIS: |
411 case CODEC_ID_THEORA: | |
412 ff_rtp_send_xiph(s1, pkt->data, size); | |
413 break; | |
6379 | 414 case CODEC_ID_VP8: |
415 ff_rtp_send_vp8(s1, pkt->data, size); | |
416 break; | |
0 | 417 default: |
418 /* better than nothing : send the codec raw data */ | |
5479 | 419 rtp_send_raw(s1, pkt->data, size); |
0 | 420 break; |
421 } | |
422 return 0; | |
423 } | |
424 | |
4391 | 425 static int rtp_write_trailer(AVFormatContext *s1) |
426 { | |
427 RTPMuxContext *s = s1->priv_data; | |
428 | |
429 av_freep(&s->buf); | |
430 | |
431 return 0; | |
432 } | |
433 | |
1167 | 434 AVOutputFormat rtp_muxer = { |
0 | 435 "rtp", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
436 NULL_IF_CONFIG_SMALL("RTP output format"), |
0 | 437 NULL, |
438 NULL, | |
4388 | 439 sizeof(RTPMuxContext), |
0 | 440 CODEC_ID_PCM_MULAW, |
441 CODEC_ID_NONE, | |
442 rtp_write_header, | |
443 rtp_write_packet, | |
4391 | 444 rtp_write_trailer, |
0 | 445 }; |