Commit | Line | Data |
---|---|---|
26b4fe82 AJ |
1 | /* |
2 | * H.26L/H.264/AVC/JVT/14496-10/... parser | |
3 | * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 | * | |
2912e87a | 5 | * This file is part of Libav. |
26b4fe82 | 6 | * |
2912e87a | 7 | * Libav is free software; you can redistribute it and/or |
26b4fe82 AJ |
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 | * | |
2912e87a | 12 | * Libav is distributed in the hope that it will be useful, |
26b4fe82 AJ |
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 | |
2912e87a | 18 | * License along with Libav; if not, write to the Free Software |
26b4fe82 | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
26b4fe82 AJ |
20 | */ |
21 | ||
22 | /** | |
ba87f080 | 23 | * @file |
26b4fe82 AJ |
24 | * H.264 / AVC / MPEG4 part10 parser. |
25 | * @author Michael Niedermayer <michaelni@gmx.at> | |
26 | */ | |
27 | ||
6fee1b90 | 28 | #include "libavutil/attributes.h" |
26b4fe82 | 29 | #include "parser.h" |
ff6474dd IS |
30 | #include "h264data.h" |
31 | #include "golomb.h" | |
f1e93986 | 32 | #include "internal.h" |
26b4fe82 AJ |
33 | |
34 | #include <assert.h> | |
35 | ||
36 | ||
088f38a4 | 37 | static int h264_find_frame_end(H264Context *h, const uint8_t *buf, int buf_size) |
26b4fe82 AJ |
38 | { |
39 | int i; | |
40 | uint32_t state; | |
2c541554 | 41 | ParseContext *pc = &h->parse_context; |
26b4fe82 AJ |
42 | // mb_addr= pc->mb_addr - 1; |
43 | state= pc->state; | |
44 | if(state>13) | |
45 | state= 7; | |
46 | ||
47 | for(i=0; i<buf_size; i++){ | |
48 | if(state==7){ | |
b250f9c6 | 49 | #if HAVE_FAST_UNALIGNED |
e4f1ec3a MN |
50 | /* we check i<buf_size instead of i+3/7 because its simpler |
51 | * and there should be FF_INPUT_BUFFER_PADDING_SIZE bytes at the end | |
52 | */ | |
b250f9c6 | 53 | # if HAVE_FAST_64BIT |
4d8eb2e8 | 54 | while(i<buf_size && !((~*(const uint64_t*)(buf+i) & (*(const uint64_t*)(buf+i) - 0x0101010101010101ULL)) & 0x8080808080808080ULL)) |
5cb5023c MN |
55 | i+=8; |
56 | # else | |
4d8eb2e8 | 57 | while(i<buf_size && !((~*(const uint32_t*)(buf+i) & (*(const uint32_t*)(buf+i) - 0x01010101U)) & 0x80808080U)) |
5cb5023c MN |
58 | i+=4; |
59 | # endif | |
60 | #endif | |
26b4fe82 AJ |
61 | for(; i<buf_size; i++){ |
62 | if(!buf[i]){ | |
63 | state=2; | |
64 | break; | |
65 | } | |
66 | } | |
67 | }else if(state<=2){ | |
68 | if(buf[i]==1) state^= 5; //2->7, 1->4, 0->5 | |
69 | else if(buf[i]) state = 7; | |
70 | else state>>=1; //2->1, 1->0, 0->0 | |
71 | }else if(state<=5){ | |
72 | int v= buf[i] & 0x1F; | |
9e85f9c5 | 73 | if(v==6 || v==7 || v==8 || v==9){ |
26b4fe82 AJ |
74 | if(pc->frame_start_found){ |
75 | i++; | |
9aa1cfec | 76 | goto found; |
26b4fe82 AJ |
77 | } |
78 | }else if(v==1 || v==2 || v==5){ | |
79 | if(pc->frame_start_found){ | |
80 | state+=8; | |
81 | continue; | |
82 | }else | |
83 | pc->frame_start_found = 1; | |
84 | } | |
85 | state= 7; | |
86 | }else{ | |
87 | if(buf[i] & 0x80) | |
88 | goto found; | |
89 | state= 7; | |
90 | } | |
91 | } | |
92 | pc->state= state; | |
93 | return END_NOT_FOUND; | |
9aa1cfec DP |
94 | |
95 | found: | |
96 | pc->state=7; | |
97 | pc->frame_start_found= 0; | |
98 | return i-(state&5); | |
26b4fe82 AJ |
99 | } |
100 | ||
adbfc605 | 101 | /** |
ff6474dd IS |
102 | * Parse NAL units of found picture and decode some basic information. |
103 | * | |
104 | * @param s parser context. | |
105 | * @param avctx codec context. | |
106 | * @param buf buffer with field/frame data. | |
107 | * @param buf_size size of the buffer. | |
108 | */ | |
109 | static inline int parse_nal_units(AVCodecParserContext *s, | |
110 | AVCodecContext *avctx, | |
111 | const uint8_t *buf, int buf_size) | |
112 | { | |
113 | H264Context *h = s->priv_data; | |
114 | const uint8_t *buf_end = buf + buf_size; | |
96c3da93 | 115 | unsigned int pps_id; |
ff6474dd | 116 | unsigned int slice_type; |
8fa0ae06 | 117 | int state = -1; |
ff6474dd IS |
118 | const uint8_t *ptr; |
119 | ||
120 | /* set some sane default values */ | |
975a1447 | 121 | s->pict_type = AV_PICTURE_TYPE_I; |
0ed260c7 | 122 | s->key_frame = 0; |
ff6474dd | 123 | |
2c541554 | 124 | h->avctx= avctx; |
0ed260c7 | 125 | h->sei_recovery_frame_cnt = -1; |
c733922e IS |
126 | h->sei_dpb_output_delay = 0; |
127 | h->sei_cpb_removal_delay = -1; | |
128 | h->sei_buffering_period_present = 0; | |
ff6474dd | 129 | |
9479415e BC |
130 | if (!buf_size) |
131 | return 0; | |
132 | ||
ff6474dd IS |
133 | for(;;) { |
134 | int src_length, dst_length, consumed; | |
f1e93986 | 135 | buf = avpriv_find_start_code(buf, buf_end, &state); |
ff6474dd IS |
136 | if(buf >= buf_end) |
137 | break; | |
138 | --buf; | |
139 | src_length = buf_end - buf; | |
140 | switch (state & 0x1f) { | |
141 | case NAL_SLICE: | |
142 | case NAL_IDR_SLICE: | |
143 | // Do not walk the whole buffer just to decode slice header | |
144 | if (src_length > 20) | |
145 | src_length = 20; | |
146 | break; | |
147 | } | |
358ea75e | 148 | ptr= ff_h264_decode_nal(h, buf, &dst_length, &consumed, src_length); |
ff6474dd IS |
149 | if (ptr==NULL || dst_length < 0) |
150 | break; | |
151 | ||
2c541554 | 152 | init_get_bits(&h->gb, ptr, 8*dst_length); |
ff6474dd IS |
153 | switch(h->nal_unit_type) { |
154 | case NAL_SPS: | |
155 | ff_h264_decode_seq_parameter_set(h); | |
156 | break; | |
157 | case NAL_PPS: | |
2c541554 | 158 | ff_h264_decode_picture_parameter_set(h, h->gb.size_in_bits); |
ff6474dd IS |
159 | break; |
160 | case NAL_SEI: | |
161 | ff_h264_decode_sei(h); | |
162 | break; | |
163 | case NAL_IDR_SLICE: | |
0ed260c7 IS |
164 | s->key_frame = 1; |
165 | /* fall through */ | |
ff6474dd | 166 | case NAL_SLICE: |
2c541554 AK |
167 | get_ue_golomb(&h->gb); // skip first_mb_in_slice |
168 | slice_type = get_ue_golomb_31(&h->gb); | |
ff6474dd | 169 | s->pict_type = golomb_to_pict_type[slice_type % 5]; |
0ed260c7 IS |
170 | if (h->sei_recovery_frame_cnt >= 0) { |
171 | /* key frame, since recovery_frame_cnt is set */ | |
172 | s->key_frame = 1; | |
173 | } | |
2c541554 | 174 | pps_id= get_ue_golomb(&h->gb); |
96c3da93 | 175 | if(pps_id>=MAX_PPS_COUNT) { |
2c541554 | 176 | av_log(h->avctx, AV_LOG_ERROR, "pps_id out of range\n"); |
96c3da93 IS |
177 | return -1; |
178 | } | |
179 | if(!h->pps_buffers[pps_id]) { | |
2c541554 | 180 | av_log(h->avctx, AV_LOG_ERROR, "non-existing PPS referenced\n"); |
96c3da93 IS |
181 | return -1; |
182 | } | |
183 | h->pps= *h->pps_buffers[pps_id]; | |
184 | if(!h->sps_buffers[h->pps.sps_id]) { | |
2c541554 | 185 | av_log(h->avctx, AV_LOG_ERROR, "non-existing SPS referenced\n"); |
96c3da93 IS |
186 | return -1; |
187 | } | |
188 | h->sps = *h->sps_buffers[h->pps.sps_id]; | |
2c541554 | 189 | h->frame_num = get_bits(&h->gb, h->sps.log2_max_frame_num); |
96c3da93 | 190 | |
fe9a3fbe | 191 | avctx->profile = ff_h264_get_profile(&h->sps); |
dd0cd3d2 RC |
192 | avctx->level = h->sps.level_idc; |
193 | ||
96c3da93 | 194 | if(h->sps.frame_mbs_only_flag){ |
2c541554 | 195 | h->picture_structure= PICT_FRAME; |
96c3da93 | 196 | }else{ |
2c541554 AK |
197 | if(get_bits1(&h->gb)) { //field_pic_flag |
198 | h->picture_structure= PICT_TOP_FIELD + get_bits1(&h->gb); //bottom_field_flag | |
96c3da93 | 199 | } else { |
2c541554 | 200 | h->picture_structure= PICT_FRAME; |
96c3da93 IS |
201 | } |
202 | } | |
203 | ||
346db3ef IS |
204 | if(h->sps.pic_struct_present_flag) { |
205 | switch (h->sei_pic_struct) { | |
206 | case SEI_PIC_STRUCT_TOP_FIELD: | |
207 | case SEI_PIC_STRUCT_BOTTOM_FIELD: | |
fc9fe428 | 208 | s->repeat_pict = 0; |
346db3ef IS |
209 | break; |
210 | case SEI_PIC_STRUCT_FRAME: | |
211 | case SEI_PIC_STRUCT_TOP_BOTTOM: | |
212 | case SEI_PIC_STRUCT_BOTTOM_TOP: | |
fc9fe428 | 213 | s->repeat_pict = 1; |
346db3ef IS |
214 | break; |
215 | case SEI_PIC_STRUCT_TOP_BOTTOM_TOP: | |
216 | case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: | |
fc9fe428 | 217 | s->repeat_pict = 2; |
346db3ef IS |
218 | break; |
219 | case SEI_PIC_STRUCT_FRAME_DOUBLING: | |
fc9fe428 | 220 | s->repeat_pict = 3; |
346db3ef IS |
221 | break; |
222 | case SEI_PIC_STRUCT_FRAME_TRIPLING: | |
fc9fe428 | 223 | s->repeat_pict = 5; |
346db3ef IS |
224 | break; |
225 | default: | |
2c541554 | 226 | s->repeat_pict = h->picture_structure == PICT_FRAME ? 1 : 0; |
346db3ef IS |
227 | break; |
228 | } | |
229 | } else { | |
2c541554 | 230 | s->repeat_pict = h->picture_structure == PICT_FRAME ? 1 : 0; |
346db3ef IS |
231 | } |
232 | ||
ff6474dd IS |
233 | return 0; /* no need to evaluate the rest */ |
234 | } | |
235 | buf += consumed; | |
236 | } | |
237 | /* didn't find a picture! */ | |
2c541554 | 238 | av_log(h->avctx, AV_LOG_ERROR, "missing picture in access unit\n"); |
ff6474dd IS |
239 | return -1; |
240 | } | |
241 | ||
26b4fe82 AJ |
242 | static int h264_parse(AVCodecParserContext *s, |
243 | AVCodecContext *avctx, | |
244 | const uint8_t **poutbuf, int *poutbuf_size, | |
245 | const uint8_t *buf, int buf_size) | |
246 | { | |
247 | H264Context *h = s->priv_data; | |
2c541554 | 248 | ParseContext *pc = &h->parse_context; |
26b4fe82 AJ |
249 | int next; |
250 | ||
82f1ffc7 HC |
251 | if (!h->got_first) { |
252 | h->got_first = 1; | |
23584bec | 253 | if (avctx->extradata_size) { |
2c541554 | 254 | h->avctx = avctx; |
790a367d RT |
255 | // must be done like in the decoder. |
256 | // otherwise opening the parser, creating extradata, | |
257 | // and then closing and opening again | |
258 | // will cause has_b_frames to be always set. | |
259 | // NB: estimate_timings_from_pts behaves exactly like this. | |
260 | if (!avctx->has_b_frames) | |
2c541554 | 261 | h->low_delay = 1; |
23584bec HC |
262 | ff_h264_decode_extradata(h); |
263 | } | |
264 | } | |
265 | ||
26b4fe82 AJ |
266 | if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){ |
267 | next= buf_size; | |
268 | }else{ | |
088f38a4 | 269 | next = h264_find_frame_end(h, buf, buf_size); |
26b4fe82 AJ |
270 | |
271 | if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { | |
272 | *poutbuf = NULL; | |
273 | *poutbuf_size = 0; | |
274 | return buf_size; | |
275 | } | |
276 | ||
277 | if(next<0 && next != END_NOT_FOUND){ | |
278 | assert(pc->last_index + next >= 0 ); | |
088f38a4 | 279 | h264_find_frame_end(h, &pc->buffer[pc->last_index + next], -next); // update state |
26b4fe82 | 280 | } |
a26ce1e2 | 281 | } |
ff6474dd | 282 | |
25f05ddb | 283 | parse_nal_units(s, avctx, buf, buf_size); |
c733922e | 284 | |
25f05ddb PL |
285 | if (h->sei_cpb_removal_delay >= 0) { |
286 | s->dts_sync_point = h->sei_buffering_period_present; | |
287 | s->dts_ref_dts_delta = h->sei_cpb_removal_delay; | |
288 | s->pts_dts_delta = h->sei_dpb_output_delay; | |
289 | } else { | |
290 | s->dts_sync_point = INT_MIN; | |
291 | s->dts_ref_dts_delta = INT_MIN; | |
292 | s->pts_dts_delta = INT_MIN; | |
293 | } | |
294 | ||
295 | if (s->flags & PARSER_FLAG_ONCE) { | |
296 | s->flags &= PARSER_FLAG_COMPLETE_FRAMES; | |
297 | } | |
26b4fe82 AJ |
298 | |
299 | *poutbuf = buf; | |
300 | *poutbuf_size = buf_size; | |
301 | return next; | |
302 | } | |
303 | ||
304 | static int h264_split(AVCodecContext *avctx, | |
305 | const uint8_t *buf, int buf_size) | |
306 | { | |
307 | int i; | |
308 | uint32_t state = -1; | |
309 | int has_sps= 0; | |
310 | ||
311 | for(i=0; i<=buf_size; i++){ | |
312 | if((state&0xFFFFFF1F) == 0x107) | |
313 | has_sps=1; | |
314 | /* if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){ | |
315 | }*/ | |
316 | if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){ | |
317 | if(has_sps){ | |
318 | while(i>4 && buf[i-5]==0) i--; | |
319 | return i-4; | |
320 | } | |
321 | } | |
322 | if (i<buf_size) | |
323 | state= (state<<8) | buf[i]; | |
324 | } | |
325 | return 0; | |
326 | } | |
327 | ||
dd990075 | 328 | static void close(AVCodecParserContext *s) |
3ee4f5e4 MN |
329 | { |
330 | H264Context *h = s->priv_data; | |
2c541554 | 331 | ParseContext *pc = &h->parse_context; |
3ee4f5e4 MN |
332 | |
333 | av_free(pc->buffer); | |
15861962 | 334 | ff_h264_free_context(h); |
3ee4f5e4 MN |
335 | } |
336 | ||
6fee1b90 | 337 | static av_cold int init(AVCodecParserContext *s) |
e9ca315d RC |
338 | { |
339 | H264Context *h = s->priv_data; | |
340 | h->thread_context[0] = h; | |
2c541554 | 341 | h->slice_context_count = 1; |
e9ca315d RC |
342 | return 0; |
343 | } | |
26b4fe82 | 344 | |
d36beb3f | 345 | AVCodecParser ff_h264_parser = { |
36ef5369 | 346 | .codec_ids = { AV_CODEC_ID_H264 }, |
5511ad14 AK |
347 | .priv_data_size = sizeof(H264Context), |
348 | .parser_init = init, | |
349 | .parser_parse = h264_parse, | |
350 | .parser_close = close, | |
351 | .split = h264_split, | |
26b4fe82 | 352 | }; |