Mercurial > libavformat.hg
annotate rtpdec_h264.c @ 6435:67433b0c29d5 libavformat
move h264 demuxer to its own file
author | aurel |
---|---|
date | Sun, 29 Aug 2010 21:28:51 +0000 |
parents | 491eea5c52d6 |
children |
rev | line source |
---|---|
1460 | 1 /* |
2 * RTP H264 Protocol (RFC3984) | |
4251
77e0c7511d41
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
4067
diff
changeset
|
3 * Copyright (c) 2006 Ryan Martell |
1460 | 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 /** | |
5969
178de7695c6c
Remove explicit filename from Doxygen @file commands.
diego
parents:
5910
diff
changeset
|
23 * @file |
1460 | 24 * @brief H.264 / RTP Code (RFC3984) |
25 * @author Ryan Martell <rdm4@martellventures.com> | |
26 * | |
27 * @note Notes: | |
28 * Notes: | |
29 * This currently supports packetization mode: | |
30 * Single Nal Unit Mode (0), or | |
31 * Non-Interleaved Mode (1). It currently does not support | |
32 * Interleaved Mode (2). (This requires implementing STAP-B, MTAP16, MTAP24, FU-B packet types) | |
33 * | |
34 * @note TODO: | |
35 * 1) RTCP sender reports for udp streams are required.. | |
36 * | |
37 */ | |
38 | |
3286 | 39 #include "libavutil/base64.h" |
40 #include "libavutil/avstring.h" | |
4872 | 41 #include "libavcodec/get_bits.h" |
1460 | 42 #include "avformat.h" |
43 #include "mpegts.h" | |
44 | |
45 #include <unistd.h> | |
1754 | 46 #include "network.h" |
1460 | 47 #include <assert.h> |
48 | |
4388 | 49 #include "rtpdec.h" |
6339
491eea5c52d6
Remove mostly unnecessary rtpdec_*.h files, store the declarations in one file
mstorsjo
parents:
6251
diff
changeset
|
50 #include "rtpdec_formats.h" |
1460 | 51 |
52 /** | |
53 RTP/H264 specific private data. | |
54 */ | |
3975
44561554cb7e
Rename RTP payload contexts to PayloadContext, suggested by Luca in
rbultje
parents:
3292
diff
changeset
|
55 struct PayloadContext { |
1460 | 56 unsigned long cookie; ///< sanity check, to make sure we get the pointer we're expecting. |
57 | |
58 //sdp setup parameters | |
59 uint8_t profile_idc; ///< from the sdp setup parameters. | |
60 uint8_t profile_iop; ///< from the sdp setup parameters. | |
61 uint8_t level_idc; ///< from the sdp setup parameters. | |
62 int packetization_mode; ///< from the sdp setup parameters. | |
63 #ifdef DEBUG | |
64 int packet_types_received[32]; | |
65 #endif | |
3975
44561554cb7e
Rename RTP payload contexts to PayloadContext, suggested by Luca in
rbultje
parents:
3292
diff
changeset
|
66 }; |
1460 | 67 |
68 #define MAGIC_COOKIE (0xdeadbeef) ///< Cookie for the extradata; to verify we are what we think we are, and that we haven't been freed. | |
69 #define DEAD_COOKIE (0xdeaddead) ///< Cookie for the extradata; once it is freed. | |
70 | |
71 /* ---------------- private code */ | |
6188
34f4b569637f
rtpdec: Return ENOMEM if H.264 RTP fails to allocate memory for SDP extradata
mstorsjo
parents:
6076
diff
changeset
|
72 static int sdp_parse_fmtp_config_h264(AVStream * stream, |
6189 | 73 PayloadContext * h264_data, |
74 char *attr, char *value) | |
1460 | 75 { |
76 AVCodecContext *codec = stream->codec; | |
77 assert(codec->codec_id == CODEC_ID_H264); | |
78 assert(h264_data != NULL); | |
79 | |
80 if (!strcmp(attr, "packetization-mode")) { | |
4628 | 81 av_log(codec, AV_LOG_DEBUG, "RTP Packetization Mode: %d\n", atoi(value)); |
2362 | 82 h264_data->packetization_mode = atoi(value); |
1460 | 83 /* |
84 Packetization Mode: | |
85 0 or not present: Single NAL mode (Only nals from 1-23 are allowed) | |
86 1: Non-interleaved Mode: 1-23, 24 (STAP-A), 28 (FU-A) are allowed. | |
87 2: Interleaved Mode: 25 (STAP-B), 26 (MTAP16), 27 (MTAP24), 28 (FU-A), and 29 (FU-B) are allowed. | |
88 */ | |
89 if (h264_data->packetization_mode > 1) | |
4628 | 90 av_log(codec, AV_LOG_ERROR, |
91 "Interleaved RTP mode is not supported yet."); | |
1460 | 92 } else if (!strcmp(attr, "profile-level-id")) { |
93 if (strlen(value) == 6) { | |
94 char buffer[3]; | |
95 // 6 characters=3 bytes, in hex. | |
96 uint8_t profile_idc; | |
97 uint8_t profile_iop; | |
98 uint8_t level_idc; | |
99 | |
100 buffer[0] = value[0]; buffer[1] = value[1]; buffer[2] = '\0'; | |
101 profile_idc = strtol(buffer, NULL, 16); | |
102 buffer[0] = value[2]; buffer[1] = value[3]; | |
103 profile_iop = strtol(buffer, NULL, 16); | |
104 buffer[0] = value[4]; buffer[1] = value[5]; | |
105 level_idc = strtol(buffer, NULL, 16); | |
106 | |
107 // set the parameters... | |
4628 | 108 av_log(codec, AV_LOG_DEBUG, |
109 "RTP Profile IDC: %x Profile IOP: %x Level: %x\n", | |
1460 | 110 profile_idc, profile_iop, level_idc); |
111 h264_data->profile_idc = profile_idc; | |
112 h264_data->profile_iop = profile_iop; | |
113 h264_data->level_idc = level_idc; | |
114 } | |
115 } else if (!strcmp(attr, "sprop-parameter-sets")) { | |
116 uint8_t start_sequence[]= { 0, 0, 1 }; | |
117 codec->extradata_size= 0; | |
118 codec->extradata= NULL; | |
119 | |
120 while (*value) { | |
121 char base64packet[1024]; | |
122 uint8_t decoded_packet[1024]; | |
6251 | 123 int packet_size; |
1460 | 124 char *dst = base64packet; |
125 | |
126 while (*value && *value != ',' | |
127 && (dst - base64packet) < sizeof(base64packet) - 1) { | |
128 *dst++ = *value++; | |
129 } | |
130 *dst++ = '\0'; | |
131 | |
132 if (*value == ',') | |
133 value++; | |
134 | |
135 packet_size= av_base64_decode(decoded_packet, base64packet, sizeof(decoded_packet)); | |
6251 | 136 if (packet_size > 0) { |
5739
84bfac703b3a
Properly pad H.264 extradata when taken from fmtp SDP attributes
mstorsjo
parents:
5726
diff
changeset
|
137 uint8_t *dest = av_malloc(packet_size + sizeof(start_sequence) + |
84bfac703b3a
Properly pad H.264 extradata when taken from fmtp SDP attributes
mstorsjo
parents:
5726
diff
changeset
|
138 codec->extradata_size + |
84bfac703b3a
Properly pad H.264 extradata when taken from fmtp SDP attributes
mstorsjo
parents:
5726
diff
changeset
|
139 FF_INPUT_BUFFER_PADDING_SIZE); |
1460 | 140 if(dest) |
141 { | |
142 if(codec->extradata_size) | |
143 { | |
144 // av_realloc? | |
145 memcpy(dest, codec->extradata, codec->extradata_size); | |
146 av_free(codec->extradata); | |
147 } | |
148 | |
149 memcpy(dest+codec->extradata_size, start_sequence, sizeof(start_sequence)); | |
150 memcpy(dest+codec->extradata_size+sizeof(start_sequence), decoded_packet, packet_size); | |
5739
84bfac703b3a
Properly pad H.264 extradata when taken from fmtp SDP attributes
mstorsjo
parents:
5726
diff
changeset
|
151 memset(dest+codec->extradata_size+sizeof(start_sequence)+ |
84bfac703b3a
Properly pad H.264 extradata when taken from fmtp SDP attributes
mstorsjo
parents:
5726
diff
changeset
|
152 packet_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); |
1460 | 153 |
154 codec->extradata= dest; | |
155 codec->extradata_size+= sizeof(start_sequence)+packet_size; | |
156 } else { | |
4628 | 157 av_log(codec, AV_LOG_ERROR, "Unable to allocate memory for extradata!"); |
6188
34f4b569637f
rtpdec: Return ENOMEM if H.264 RTP fails to allocate memory for SDP extradata
mstorsjo
parents:
6076
diff
changeset
|
158 return AVERROR(ENOMEM); |
1460 | 159 } |
160 } | |
161 } | |
4628 | 162 av_log(codec, AV_LOG_DEBUG, "Extradata set to %p (size: %d)!", codec->extradata, codec->extradata_size); |
1460 | 163 } |
6188
34f4b569637f
rtpdec: Return ENOMEM if H.264 RTP fails to allocate memory for SDP extradata
mstorsjo
parents:
6076
diff
changeset
|
164 return 0; |
1460 | 165 } |
166 | |
167 // return 0 on packet, no more left, 1 on packet, 1 on partial packet... | |
4387
5c42816e12c6
Add "AVFormatContext *ctx" (that being the RTSP demuxer's) as first argument
rbultje
parents:
4331
diff
changeset
|
168 static int h264_handle_packet(AVFormatContext *ctx, |
5c42816e12c6
Add "AVFormatContext *ctx" (that being the RTSP demuxer's) as first argument
rbultje
parents:
4331
diff
changeset
|
169 PayloadContext *data, |
3976
64056a0c38ce
Change function prototype of RTPDynamicPayloadHandler.parse_packet() to
rbultje
parents:
3975
diff
changeset
|
170 AVStream *st, |
1460 | 171 AVPacket * pkt, |
172 uint32_t * timestamp, | |
173 const uint8_t * buf, | |
2941
6da0564c9d02
Add a flags field to the RTPDynamicPayloadPacketHandlerProc (PKT_FLAG_*).
rbultje
parents:
2702
diff
changeset
|
174 int len, int flags) |
1460 | 175 { |
176 uint8_t nal = buf[0]; | |
177 uint8_t type = (nal & 0x1f); | |
178 int result= 0; | |
179 uint8_t start_sequence[]= {0, 0, 1}; | |
180 | |
3292 | 181 #ifdef DEBUG |
1460 | 182 assert(data); |
183 assert(data->cookie == MAGIC_COOKIE); | |
3292 | 184 #endif |
1460 | 185 assert(buf); |
186 | |
187 if (type >= 1 && type <= 23) | |
188 type = 1; // simplify the case. (these are all the nal types used internally by the h264 codec) | |
189 switch (type) { | |
190 case 0: // undefined; | |
191 result= -1; | |
192 break; | |
193 | |
194 case 1: | |
195 av_new_packet(pkt, len+sizeof(start_sequence)); | |
196 memcpy(pkt->data, start_sequence, sizeof(start_sequence)); | |
197 memcpy(pkt->data+sizeof(start_sequence), buf, len); | |
198 #ifdef DEBUG | |
199 data->packet_types_received[nal & 0x1f]++; | |
200 #endif | |
201 break; | |
202 | |
203 case 24: // STAP-A (one packet, multiple nals) | |
204 // consume the STAP-A NAL | |
205 buf++; | |
206 len--; | |
207 // first we are going to figure out the total size.... | |
208 { | |
209 int pass= 0; | |
210 int total_length= 0; | |
211 uint8_t *dst= NULL; | |
212 | |
213 for(pass= 0; pass<2; pass++) { | |
214 const uint8_t *src= buf; | |
215 int src_len= len; | |
216 | |
217 do { | |
1673 | 218 uint16_t nal_size = AV_RB16(src); // this going to be a problem if unaligned (can it be?) |
1460 | 219 |
220 // consume the length of the aggregate... | |
221 src += 2; | |
222 src_len -= 2; | |
223 | |
224 if (nal_size <= src_len) { | |
225 if(pass==0) { | |
226 // counting... | |
227 total_length+= sizeof(start_sequence)+nal_size; | |
228 } else { | |
229 // copying | |
230 assert(dst); | |
231 memcpy(dst, start_sequence, sizeof(start_sequence)); | |
232 dst+= sizeof(start_sequence); | |
233 memcpy(dst, src, nal_size); | |
234 #ifdef DEBUG | |
235 data->packet_types_received[*src & 0x1f]++; | |
236 #endif | |
237 dst+= nal_size; | |
238 } | |
239 } else { | |
4628 | 240 av_log(ctx, AV_LOG_ERROR, |
1460 | 241 "nal size exceeds length: %d %d\n", nal_size, src_len); |
242 } | |
243 | |
244 // eat what we handled... | |
245 src += nal_size; | |
246 src_len -= nal_size; | |
247 | |
248 if (src_len < 0) | |
4628 | 249 av_log(ctx, AV_LOG_ERROR, |
1460 | 250 "Consumed more bytes than we got! (%d)\n", src_len); |
251 } while (src_len > 2); // because there could be rtp padding.. | |
252 | |
253 if(pass==0) { | |
254 // now we know the total size of the packet (with the start sequences added) | |
255 av_new_packet(pkt, total_length); | |
256 dst= pkt->data; | |
257 } else { | |
258 assert(dst-pkt->data==total_length); | |
259 } | |
260 } | |
261 } | |
262 break; | |
263 | |
264 case 25: // STAP-B | |
265 case 26: // MTAP-16 | |
266 case 27: // MTAP-24 | |
267 case 29: // FU-B | |
4628 | 268 av_log(ctx, AV_LOG_ERROR, |
1460 | 269 "Unhandled type (%d) (See RFC for implementation details\n", |
270 type); | |
271 result= -1; | |
272 break; | |
273 | |
274 case 28: // FU-A (fragmented nal) | |
275 buf++; | |
276 len--; // skip the fu_indicator | |
277 { | |
278 // these are the same as above, we just redo them here for clarity... | |
279 uint8_t fu_indicator = nal; | |
280 uint8_t fu_header = *buf; // read the fu_header. | |
2154
b849507913da
Remove the unnecessary masking when extracting the start bit in the H.264 RTP
takis
parents:
1983
diff
changeset
|
281 uint8_t start_bit = fu_header >> 7; |
1460 | 282 // uint8_t end_bit = (fu_header & 0x40) >> 6; |
283 uint8_t nal_type = (fu_header & 0x1f); | |
284 uint8_t reconstructed_nal; | |
285 | |
286 // reconstruct this packet's true nal; only the data follows.. | |
287 reconstructed_nal = fu_indicator & (0xe0); // the original nal forbidden bit and NRI are stored in this packet's nal; | |
2155
a661d4e7cab2
Remove the unnecessary masking when reconstructing the NAL unit header in the
takis
parents:
2154
diff
changeset
|
288 reconstructed_nal |= nal_type; |
1460 | 289 |
290 // skip the fu_header... | |
291 buf++; | |
292 len--; | |
293 | |
294 #ifdef DEBUG | |
295 if (start_bit) | |
2156
cfd57cd5252b
Remove the unnecessary masking when counting received packet types in the H.264
takis
parents:
2155
diff
changeset
|
296 data->packet_types_received[nal_type]++; |
1460 | 297 #endif |
298 if(start_bit) { | |
299 // copy in the start sequence, and the reconstructed nal.... | |
300 av_new_packet(pkt, sizeof(start_sequence)+sizeof(nal)+len); | |
301 memcpy(pkt->data, start_sequence, sizeof(start_sequence)); | |
302 pkt->data[sizeof(start_sequence)]= reconstructed_nal; | |
303 memcpy(pkt->data+sizeof(start_sequence)+sizeof(nal), buf, len); | |
304 } else { | |
305 av_new_packet(pkt, len); | |
306 memcpy(pkt->data, buf, len); | |
307 } | |
308 } | |
309 break; | |
310 | |
311 case 30: // undefined | |
312 case 31: // undefined | |
313 default: | |
4628 | 314 av_log(ctx, AV_LOG_ERROR, "Undefined type (%d)", type); |
1460 | 315 result= -1; |
316 break; | |
317 } | |
318 | |
4633
0c69b895a01f
Don't let finalize_packet() touch pkt->stream_index. Instead, let individual
rbultje
parents:
4628
diff
changeset
|
319 pkt->stream_index = st->index; |
0c69b895a01f
Don't let finalize_packet() touch pkt->stream_index. Instead, let individual
rbultje
parents:
4628
diff
changeset
|
320 |
1460 | 321 return result; |
322 } | |
323 | |
324 /* ---------------- public code */ | |
5113
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
325 static PayloadContext *h264_new_context(void) |
1460 | 326 { |
3975
44561554cb7e
Rename RTP payload contexts to PayloadContext, suggested by Luca in
rbultje
parents:
3292
diff
changeset
|
327 PayloadContext *data = |
44561554cb7e
Rename RTP payload contexts to PayloadContext, suggested by Luca in
rbultje
parents:
3292
diff
changeset
|
328 av_mallocz(sizeof(PayloadContext) + |
1460 | 329 FF_INPUT_BUFFER_PADDING_SIZE); |
330 | |
331 if (data) { | |
332 data->cookie = MAGIC_COOKIE; | |
333 } | |
334 | |
335 return data; | |
336 } | |
337 | |
5113
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
338 static void h264_free_context(PayloadContext *data) |
1460 | 339 { |
340 #ifdef DEBUG | |
341 int ii; | |
342 | |
343 for (ii = 0; ii < 32; ii++) { | |
344 if (data->packet_types_received[ii]) | |
345 av_log(NULL, AV_LOG_DEBUG, "Received %d packets of type %d\n", | |
346 data->packet_types_received[ii], ii); | |
347 } | |
348 #endif | |
349 | |
350 assert(data); | |
351 assert(data->cookie == MAGIC_COOKIE); | |
352 | |
353 // avoid stale pointers (assert) | |
354 data->cookie = DEAD_COOKIE; | |
355 | |
356 // and clear out this... | |
357 av_free(data); | |
358 } | |
359 | |
4067
8adccfc01be3
Change function prototype of the sdp_parse_a_line in DynamicProtocolHandler.
rbultje
parents:
3976
diff
changeset
|
360 static int parse_h264_sdp_line(AVFormatContext *s, int st_index, |
8adccfc01be3
Change function prototype of the sdp_parse_a_line in DynamicProtocolHandler.
rbultje
parents:
3976
diff
changeset
|
361 PayloadContext *h264_data, const char *line) |
1460 | 362 { |
4067
8adccfc01be3
Change function prototype of the sdp_parse_a_line in DynamicProtocolHandler.
rbultje
parents:
3976
diff
changeset
|
363 AVStream *stream = s->streams[st_index]; |
1460 | 364 AVCodecContext *codec = stream->codec; |
365 const char *p = line; | |
366 | |
367 assert(h264_data->cookie == MAGIC_COOKIE); | |
368 | |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2156
diff
changeset
|
369 if (av_strstart(p, "framesize:", &p)) { |
1460 | 370 char buf1[50]; |
371 char *dst = buf1; | |
372 | |
373 // remove the protocol identifier.. | |
374 while (*p && *p == ' ') p++; // strip spaces. | |
375 while (*p && *p != ' ') p++; // eat protocol identifier | |
376 while (*p && *p == ' ') p++; // strip trailing spaces. | |
5352
c8a47f9a36a8
Fix a typo in rtp_h264.c:parse_h264_sdp_line(). Patch by Gordon Irlam
lucabe
parents:
5113
diff
changeset
|
377 while (*p && *p != '-' && (dst - buf1) < sizeof(buf1) - 1) { |
1460 | 378 *dst++ = *p++; |
379 } | |
380 *dst = '\0'; | |
381 | |
382 // a='framesize:96 320-240' | |
383 // set our parameters.. | |
384 codec->width = atoi(buf1); | |
385 codec->height = atoi(p + 1); // skip the - | |
386 codec->pix_fmt = PIX_FMT_YUV420P; | |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2156
diff
changeset
|
387 } else if (av_strstart(p, "fmtp:", &p)) { |
6190
8ee715d46f99
rtpdec: Clean up FMTP parsing code in H.264 RTP depacketizer
mstorsjo
parents:
6189
diff
changeset
|
388 return ff_parse_fmtp(stream, h264_data, p, sdp_parse_fmtp_config_h264); |
2193
5ce5fad0dfac
replace the uses of old string functions that Reimar missed
mru
parents:
2156
diff
changeset
|
389 } else if (av_strstart(p, "cliprect:", &p)) { |
1460 | 390 // could use this if we wanted. |
391 } | |
392 | |
393 return 0; // keep processing it the normal way... | |
394 } | |
395 | |
396 /** | |
397 This is the structure for expanding on the dynamic rtp protocols (makes everything static. yay!) | |
398 */ | |
399 RTPDynamicProtocolHandler ff_h264_dynamic_handler = { | |
5113
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
400 .enc_name = "H264", |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5739
diff
changeset
|
401 .codec_type = AVMEDIA_TYPE_VIDEO, |
5113
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
402 .codec_id = CODEC_ID_H264, |
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
403 .parse_sdp_a_line = parse_h264_sdp_line, |
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
404 .open = h264_new_context, |
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
405 .close = h264_free_context, |
75e51cba276e
Use named initializers and use new/free_context() instead of extradata()
rbultje
parents:
4872
diff
changeset
|
406 .parse_packet = h264_handle_packet |
1460 | 407 }; |