Mercurial > libavformat.hg
annotate rtpenc.c @ 6136:6c0e0ad77315 libavformat
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
the RTP muxer context (it will be used later for splitting frames in NALs)
author | lucabe |
---|---|
date | Wed, 16 Jun 2010 12:59:47 +0000 |
parents | 201152a121b5 |
children | 397ef451b549 |
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 |
27 #include <unistd.h> | |
28 | |
4388 | 29 #include "rtpenc.h" |
1419 | 30 |
0 | 31 //#define DEBUG |
32 | |
2705
cc693f9e80ee
Use a symbolic name for the payload size of an RTCP Sender Report packet
lucabe
parents:
2587
diff
changeset
|
33 #define RTCP_SR_SIZE 28 |
0 | 34 |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
35 static int is_supported(enum CodecID id) |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
36 { |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
37 switch(id) { |
4814 | 38 case CODEC_ID_H263: |
39 case CODEC_ID_H263P: | |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
40 case CODEC_ID_H264: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
41 case CODEC_ID_MPEG1VIDEO: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
42 case CODEC_ID_MPEG2VIDEO: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
43 case CODEC_ID_MPEG4: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
44 case CODEC_ID_AAC: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
45 case CODEC_ID_MP2: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
46 case CODEC_ID_MP3: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
47 case CODEC_ID_PCM_ALAW: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
48 case CODEC_ID_PCM_MULAW: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
49 case CODEC_ID_PCM_S8: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
50 case CODEC_ID_PCM_S16BE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
51 case CODEC_ID_PCM_S16LE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
52 case CODEC_ID_PCM_U16BE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
53 case CODEC_ID_PCM_U16LE: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
54 case CODEC_ID_PCM_U8: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
55 case CODEC_ID_MPEG2TS: |
4836 | 56 case CODEC_ID_AMR_NB: |
57 case CODEC_ID_AMR_WB: | |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
58 return 1; |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
59 default: |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
60 return 0; |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
61 } |
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 |
0 | 64 static int rtp_write_header(AVFormatContext *s1) |
65 { | |
4388 | 66 RTPMuxContext *s = s1->priv_data; |
5477 | 67 int max_packet_size, n; |
0 | 68 AVStream *st; |
69 | |
70 if (s1->nb_streams != 1) | |
71 return -1; | |
72 st = s1->streams[0]; | |
4796
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
73 if (!is_supported(st->codec->codec_id)) { |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
74 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
|
75 |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
76 return -1; |
f48c56ac46c2
Make rtp_write_header() fail in case of unsupported payload type
lucabe
parents:
4502
diff
changeset
|
77 } |
0 | 78 |
5477 | 79 s->payload_type = ff_rtp_get_payload_type(st->codec); |
80 if (s->payload_type < 0) | |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
81 s->payload_type = RTP_PT_PRIVATE + (st->codec->codec_type == AVMEDIA_TYPE_AUDIO); |
0 | 82 |
6036
201152a121b5
Make ff_random_get_seed public, rename to av_get_random_seed, export the header
mstorsjo
parents:
5910
diff
changeset
|
83 s->base_timestamp = av_get_random_seed(); |
0 | 84 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
|
85 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
|
86 s->ssrc = av_get_random_seed(); |
0 | 87 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
|
88 s->first_rtcp_ntp_time = ff_ntp_time(); |
5842
cc35562d3747
Use AVFormatContext.start_time_realtime in the RTP muxer
mstorsjo
parents:
5807
diff
changeset
|
89 if (s1->start_time_realtime) |
cc35562d3747
Use AVFormatContext.start_time_realtime in the RTP muxer
mstorsjo
parents:
5807
diff
changeset
|
90 /* Round the NTP time to whole milliseconds. */ |
cc35562d3747
Use AVFormatContext.start_time_realtime in the RTP muxer
mstorsjo
parents:
5807
diff
changeset
|
91 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
|
92 NTP_OFFSET_US; |
0 | 93 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
94 max_packet_size = url_fget_max_packet_size(s1->pb); |
0 | 95 if (max_packet_size <= 12) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2222
diff
changeset
|
96 return AVERROR(EIO); |
4391 | 97 s->buf = av_malloc(max_packet_size); |
98 if (s->buf == NULL) { | |
99 return AVERROR(ENOMEM); | |
100 } | |
0 | 101 s->max_payload_size = max_packet_size - 12; |
102 | |
2587
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
103 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
|
104 if (s1->max_delay) { |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
105 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
|
106 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
|
107 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
|
108 } else { |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
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); |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
110 } |
d751acab2622
Allow to set the maximum number of frames per RTP packet (and add support for
lucabe
parents:
2569
diff
changeset
|
111 } |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
112 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
|
113 /* FIXME: We should round down here... */ |
3500 | 114 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
|
115 } |
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 |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
118 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
|
119 switch(st->codec->codec_id) { |
0 | 120 case CODEC_ID_MP2: |
232 | 121 case CODEC_ID_MP3: |
0 | 122 s->buf_ptr = s->buf + 4; |
123 break; | |
124 case CODEC_ID_MPEG1VIDEO: | |
2760 | 125 case CODEC_ID_MPEG2VIDEO: |
0 | 126 break; |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
127 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
|
128 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
|
129 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
|
130 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 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
|
132 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
|
133 break; |
6136
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
134 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
|
135 /* check for H.264 MP4 syntax */ |
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
136 if (st->codec->extradata_size > 0 && st->codec->extradata && |
6c0e0ad77315
If the video stream is H.264 with MP4 syntax, store the NAL lenght size in
lucabe
parents:
6036
diff
changeset
|
137 st->codec->extradata[0] == 1) { |
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; |
4836 | 141 case CODEC_ID_AMR_NB: |
142 case CODEC_ID_AMR_WB: | |
143 if (!s->max_frames_per_packet) | |
144 s->max_frames_per_packet = 12; | |
145 if (st->codec->codec_id == CODEC_ID_AMR_NB) | |
146 n = 31; | |
147 else | |
148 n = 61; | |
149 /* max_header_toc_size + the largest AMR payload must fit */ | |
150 if (1 + s->max_frames_per_packet + n > s->max_payload_size) { | |
151 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n"); | |
152 return -1; | |
153 } | |
154 if (st->codec->channels != 1) { | |
155 av_log(s1, AV_LOG_ERROR, "Only mono is supported\n"); | |
156 return -1; | |
157 } | |
2550
e9c34ec665c6
Support for AAC streaming over RTP. Fragmentation is not implemented yet
lucabe
parents:
2540
diff
changeset
|
158 case CODEC_ID_AAC: |
4380
1b695f013cd3
Introduce a new num_frames field in RTPDemuxContext so that rtp_aac.c
lucabe
parents:
4291
diff
changeset
|
159 s->num_frames = 0; |
0 | 160 default: |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5901
diff
changeset
|
161 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
|
162 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
|
163 } |
0 | 164 s->buf_ptr = s->buf; |
165 break; | |
166 } | |
167 | |
168 return 0; | |
169 } | |
170 | |
171 /* send an rtcp sender report packet */ | |
65 | 172 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time) |
0 | 173 { |
4388 | 174 RTPMuxContext *s = s1->priv_data; |
2539
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
175 uint32_t rtp_ts; |
ba933dfa4833
Properly set RTP and NTP timestamps in RTCP SR packets
lucabe
parents:
2406
diff
changeset
|
176 |
3579 | 177 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
|
178 |
2706
b1723b8da595
Do not send too many RTCP packets (according to RFC 3550, the minimum
lucabe
parents:
2705
diff
changeset
|
179 s->last_rtcp_ntp_time = ntp_time; |
3500 | 180 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
|
181 s1->streams[0]->time_base) + s->base_timestamp; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
182 put_byte(s1->pb, (RTP_VERSION << 6)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
183 put_byte(s1->pb, 200); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
184 put_be16(s1->pb, 6); /* length in words - 1 */ |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
185 put_be32(s1->pb, s->ssrc); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
186 put_be32(s1->pb, ntp_time / 1000000); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
187 put_be32(s1->pb, ((ntp_time % 1000000) << 32) / 1000000); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
188 put_be32(s1->pb, rtp_ts); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
189 put_be32(s1->pb, s->packet_count); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
190 put_be32(s1->pb, s->octet_count); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
191 put_flush_packet(s1->pb); |
0 | 192 } |
193 | |
194 /* send an rtp packet. sequence number is incremented, but the caller | |
195 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
|
196 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m) |
0 | 197 { |
4388 | 198 RTPMuxContext *s = s1->priv_data; |
0 | 199 |
3579 | 200 dprintf(s1, "rtp_send_data size=%d\n", len); |
0 | 201 |
202 /* build the RTP header */ | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
203 put_byte(s1->pb, (RTP_VERSION << 6)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
204 put_byte(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7)); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
205 put_be16(s1->pb, s->seq); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
206 put_be32(s1->pb, s->timestamp); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
207 put_be32(s1->pb, s->ssrc); |
885 | 208 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
209 put_buffer(s1->pb, buf1, len); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2760
diff
changeset
|
210 put_flush_packet(s1->pb); |
885 | 211 |
0 | 212 s->seq++; |
213 s->octet_count += len; | |
214 s->packet_count++; | |
215 } | |
216 | |
217 /* send an integer number of samples and compute time stamp and fill | |
218 the rtp send buffer before sending. */ | |
219 static void rtp_send_samples(AVFormatContext *s1, | |
241 | 220 const uint8_t *buf1, int size, int sample_size) |
0 | 221 { |
4388 | 222 RTPMuxContext *s = s1->priv_data; |
0 | 223 int len, max_packet_size, n; |
224 | |
225 max_packet_size = (s->max_payload_size / sample_size) * sample_size; | |
226 /* not needed, but who nows */ | |
227 if ((size % sample_size) != 0) | |
228 av_abort(); | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
229 n = 0; |
0 | 230 while (size > 0) { |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
231 s->buf_ptr = s->buf; |
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
232 len = FFMIN(max_packet_size, size); |
0 | 233 |
234 /* copy data */ | |
235 memcpy(s->buf_ptr, buf1, len); | |
236 s->buf_ptr += len; | |
237 buf1 += len; | |
238 size -= len; | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
239 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
|
240 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
|
241 n += (s->buf_ptr - s->buf); |
0 | 242 } |
885 | 243 } |
0 | 244 |
245 static void rtp_send_mpegaudio(AVFormatContext *s1, | |
241 | 246 const uint8_t *buf1, int size) |
0 | 247 { |
4388 | 248 RTPMuxContext *s = s1->priv_data; |
0 | 249 int len, count, max_packet_size; |
250 | |
251 max_packet_size = s->max_payload_size; | |
252 | |
253 /* test if we must flush because not enough space */ | |
254 len = (s->buf_ptr - s->buf); | |
255 if ((len + size) > max_packet_size) { | |
256 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
|
257 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0); |
0 | 258 s->buf_ptr = s->buf + 4; |
259 } | |
260 } | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
261 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
|
262 s->timestamp = s->cur_timestamp; |
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
263 } |
0 | 264 |
265 /* add the packet */ | |
266 if (size > max_packet_size) { | |
267 /* big packet: fragment */ | |
268 count = 0; | |
269 while (size > 0) { | |
270 len = max_packet_size - 4; | |
271 if (len > size) | |
272 len = size; | |
273 /* build fragmented packet */ | |
274 s->buf[0] = 0; | |
275 s->buf[1] = 0; | |
276 s->buf[2] = count >> 8; | |
277 s->buf[3] = count; | |
278 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
|
279 ff_rtp_send_data(s1, s->buf, len + 4, 0); |
0 | 280 size -= len; |
281 buf1 += len; | |
282 count += len; | |
283 } | |
284 } else { | |
285 if (s->buf_ptr == s->buf + 4) { | |
286 /* no fragmentation possible */ | |
287 s->buf[0] = 0; | |
288 s->buf[1] = 0; | |
289 s->buf[2] = 0; | |
290 s->buf[3] = 0; | |
291 } | |
292 memcpy(s->buf_ptr, buf1, size); | |
293 s->buf_ptr += size; | |
294 } | |
295 } | |
296 | |
297 static void rtp_send_raw(AVFormatContext *s1, | |
241 | 298 const uint8_t *buf1, int size) |
0 | 299 { |
4388 | 300 RTPMuxContext *s = s1->priv_data; |
0 | 301 int len, max_packet_size; |
302 | |
303 max_packet_size = s->max_payload_size; | |
304 | |
305 while (size > 0) { | |
306 len = max_packet_size; | |
307 if (len > size) | |
308 len = size; | |
309 | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
310 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
|
311 ff_rtp_send_data(s1, buf1, len, (len == size)); |
0 | 312 |
313 buf1 += len; | |
314 size -= len; | |
315 } | |
316 } | |
317 | |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
318 /* 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
|
319 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
|
320 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
|
321 { |
4388 | 322 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
|
323 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
|
324 |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
325 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
|
326 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
|
327 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
|
328 len = size; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
329 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
|
330 buf1 += len; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
331 size -= len; |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
332 s->buf_ptr += len; |
885 | 333 |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
334 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
|
335 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
|
336 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
|
337 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 } |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
339 } |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
340 } |
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
341 |
468 | 342 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt) |
0 | 343 { |
4388 | 344 RTPMuxContext *s = s1->priv_data; |
0 | 345 AVStream *st = s1->streams[0]; |
346 int rtcp_bytes; | |
468 | 347 int size= pkt->size; |
885 | 348 |
3579 | 349 dprintf(s1, "%d: write len=%d\n", pkt->stream_index, size); |
0 | 350 |
885 | 351 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / |
0 | 352 RTCP_TX_RATIO_DEN; |
2706
b1723b8da595
Do not send too many RTCP packets (according to RFC 3550, the minimum
lucabe
parents:
2705
diff
changeset
|
353 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
|
354 (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
|
355 rtcp_send_sr(s1, ff_ntp_time()); |
0 | 356 s->last_octet_count = s->octet_count; |
357 s->first_packet = 0; | |
358 } | |
2540
ca3cba9c641f
Fix timestamps in RTP packets (now, MPEG1 video with B frames works correctly)
lucabe
parents:
2539
diff
changeset
|
359 s->cur_timestamp = s->base_timestamp + pkt->pts; |
0 | 360 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
777
diff
changeset
|
361 switch(st->codec->codec_id) { |
0 | 362 case CODEC_ID_PCM_MULAW: |
363 case CODEC_ID_PCM_ALAW: | |
364 case CODEC_ID_PCM_U8: | |
365 case CODEC_ID_PCM_S8: | |
5479 | 366 rtp_send_samples(s1, pkt->data, size, 1 * st->codec->channels); |
0 | 367 break; |
368 case CODEC_ID_PCM_U16BE: | |
369 case CODEC_ID_PCM_U16LE: | |
370 case CODEC_ID_PCM_S16BE: | |
371 case CODEC_ID_PCM_S16LE: | |
5479 | 372 rtp_send_samples(s1, pkt->data, size, 2 * st->codec->channels); |
0 | 373 break; |
374 case CODEC_ID_MP2: | |
232 | 375 case CODEC_ID_MP3: |
5479 | 376 rtp_send_mpegaudio(s1, pkt->data, size); |
0 | 377 break; |
378 case CODEC_ID_MPEG1VIDEO: | |
2760 | 379 case CODEC_ID_MPEG2VIDEO: |
5479 | 380 ff_rtp_send_mpegvideo(s1, pkt->data, size); |
0 | 381 break; |
2550
e9c34ec665c6
Support for AAC streaming over RTP. Fragmentation is not implemented yet
lucabe
parents:
2540
diff
changeset
|
382 case CODEC_ID_AAC: |
5479 | 383 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
|
384 break; |
4836 | 385 case CODEC_ID_AMR_NB: |
386 case CODEC_ID_AMR_WB: | |
5479 | 387 ff_rtp_send_amr(s1, pkt->data, size); |
4836 | 388 break; |
294
6091b76cfc2a
added MPEG2TS support in RTP, SDP and RTSP - replaced fake RTP demux by a specific API
bellard
parents:
241
diff
changeset
|
389 case CODEC_ID_MPEG2TS: |
5479 | 390 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
|
391 break; |
2960 | 392 case CODEC_ID_H264: |
5479 | 393 ff_rtp_send_h264(s1, pkt->data, size); |
2960 | 394 break; |
4814 | 395 case CODEC_ID_H263: |
396 case CODEC_ID_H263P: | |
5479 | 397 ff_rtp_send_h263(s1, pkt->data, size); |
4814 | 398 break; |
0 | 399 default: |
400 /* better than nothing : send the codec raw data */ | |
5479 | 401 rtp_send_raw(s1, pkt->data, size); |
0 | 402 break; |
403 } | |
404 return 0; | |
405 } | |
406 | |
4391 | 407 static int rtp_write_trailer(AVFormatContext *s1) |
408 { | |
409 RTPMuxContext *s = s1->priv_data; | |
410 | |
411 av_freep(&s->buf); | |
412 | |
413 return 0; | |
414 } | |
415 | |
1167 | 416 AVOutputFormat rtp_muxer = { |
0 | 417 "rtp", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
418 NULL_IF_CONFIG_SMALL("RTP output format"), |
0 | 419 NULL, |
420 NULL, | |
4388 | 421 sizeof(RTPMuxContext), |
0 | 422 CODEC_ID_PCM_MULAW, |
423 CODEC_ID_NONE, | |
424 rtp_write_header, | |
425 rtp_write_packet, | |
4391 | 426 rtp_write_trailer, |
0 | 427 }; |