blob: d22103cbdaaaa0d589123135f9a2747a03230232
1 | /* |
2 | * H.26L/H.264/AVC/JVT/14496-10/... parser |
3 | * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> |
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 | /** |
23 | * @file |
24 | * H.264 / AVC / MPEG-4 part10 parser. |
25 | * @author Michael Niedermayer <michaelni@gmx.at> |
26 | */ |
27 | |
28 | #define UNCHECKED_BITSTREAM_READER 1 |
29 | |
30 | #include <assert.h> |
31 | #include <stdint.h> |
32 | |
33 | #include "libavutil/avutil.h" |
34 | #include "libavutil/error.h" |
35 | #include "libavutil/log.h" |
36 | #include "libavutil/mem.h" |
37 | #include "libavutil/pixfmt.h" |
38 | |
39 | #include "avcodec.h" |
40 | #include "get_bits.h" |
41 | #include "golomb.h" |
42 | #include "h264.h" |
43 | #include "h264_sei.h" |
44 | #include "h264_ps.h" |
45 | #include "h264data.h" |
46 | #include "internal.h" |
47 | #include "mpegutils.h" |
48 | #include "parser.h" |
49 | |
50 | typedef struct H264ParseContext { |
51 | ParseContext pc; |
52 | H264ParamSets ps; |
53 | H264DSPContext h264dsp; |
54 | H264POCContext poc; |
55 | H264SEIContext sei; |
56 | int is_avc; |
57 | int nal_length_size; |
58 | int got_first; |
59 | int picture_structure; |
60 | uint8_t parse_history[6]; |
61 | int parse_history_count; |
62 | int parse_last_mb; |
63 | int64_t reference_dts; |
64 | int last_frame_num, last_picture_structure; |
65 | } H264ParseContext; |
66 | |
67 | |
68 | static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf, |
69 | int buf_size, void *logctx) |
70 | { |
71 | int i, j; |
72 | uint32_t state; |
73 | ParseContext *pc = &p->pc; |
74 | |
75 | int next_avc = p->is_avc ? 0 : buf_size; |
76 | // mb_addr= pc->mb_addr - 1; |
77 | state = pc->state; |
78 | if (state > 13) |
79 | state = 7; |
80 | |
81 | if (p->is_avc && !p->nal_length_size) |
82 | av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n"); |
83 | |
84 | for (i = 0; i < buf_size; i++) { |
85 | if (i >= next_avc) { |
86 | int nalsize = 0; |
87 | i = next_avc; |
88 | for (j = 0; j < p->nal_length_size; j++) |
89 | nalsize = (nalsize << 8) | buf[i++]; |
90 | if (nalsize <= 0 || nalsize > buf_size - i) { |
91 | av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal size %d remaining %d\n", nalsize, buf_size - i); |
92 | return buf_size; |
93 | } |
94 | next_avc = i + nalsize; |
95 | state = 5; |
96 | } |
97 | |
98 | if (state == 7) { |
99 | i += p->h264dsp.startcode_find_candidate(buf + i, next_avc - i); |
100 | if (i < next_avc) |
101 | state = 2; |
102 | } else if (state <= 2) { |
103 | if (buf[i] == 1) |
104 | state ^= 5; // 2->7, 1->4, 0->5 |
105 | else if (buf[i]) |
106 | state = 7; |
107 | else |
108 | state >>= 1; // 2->1, 1->0, 0->0 |
109 | } else if (state <= 5) { |
110 | int nalu_type = buf[i] & 0x1F; |
111 | if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS || |
112 | nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) { |
113 | if (pc->frame_start_found) { |
114 | i++; |
115 | goto found; |
116 | } |
117 | } else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA || |
118 | nalu_type == H264_NAL_IDR_SLICE) { |
119 | state += 8; |
120 | continue; |
121 | } |
122 | state = 7; |
123 | } else { |
124 | p->parse_history[p->parse_history_count++] = buf[i]; |
125 | if (p->parse_history_count > 5) { |
126 | unsigned int mb, last_mb = p->parse_last_mb; |
127 | GetBitContext gb; |
128 | |
129 | init_get_bits(&gb, p->parse_history, 8*p->parse_history_count); |
130 | p->parse_history_count = 0; |
131 | mb= get_ue_golomb_long(&gb); |
132 | p->parse_last_mb = mb; |
133 | if (pc->frame_start_found) { |
134 | if (mb <= last_mb) |
135 | goto found; |
136 | } else |
137 | pc->frame_start_found = 1; |
138 | state = 7; |
139 | } |
140 | } |
141 | } |
142 | pc->state = state; |
143 | if (p->is_avc) |
144 | return next_avc; |
145 | return END_NOT_FOUND; |
146 | |
147 | found: |
148 | pc->state = 7; |
149 | pc->frame_start_found = 0; |
150 | if (p->is_avc) |
151 | return next_avc; |
152 | return i - (state & 5) - 5 * (state > 7); |
153 | } |
154 | |
155 | static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb, |
156 | void *logctx) |
157 | { |
158 | H264PredWeightTable pwt; |
159 | int slice_type_nos = s->pict_type & 3; |
160 | H264ParseContext *p = s->priv_data; |
161 | int list_count, ref_count[2]; |
162 | |
163 | |
164 | if (p->ps.pps->redundant_pic_cnt_present) |
165 | get_ue_golomb(gb); // redundant_pic_count |
166 | |
167 | if (slice_type_nos == AV_PICTURE_TYPE_B) |
168 | get_bits1(gb); // direct_spatial_mv_pred |
169 | |
170 | if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps, |
171 | slice_type_nos, p->picture_structure, logctx) < 0) |
172 | return AVERROR_INVALIDDATA; |
173 | |
174 | if (slice_type_nos != AV_PICTURE_TYPE_I) { |
175 | int list; |
176 | for (list = 0; list < list_count; list++) { |
177 | if (get_bits1(gb)) { |
178 | int index; |
179 | for (index = 0; ; index++) { |
180 | unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb); |
181 | |
182 | if (reordering_of_pic_nums_idc < 3) |
183 | get_ue_golomb_long(gb); |
184 | else if (reordering_of_pic_nums_idc > 3) { |
185 | av_log(logctx, AV_LOG_ERROR, |
186 | "illegal reordering_of_pic_nums_idc %d\n", |
187 | reordering_of_pic_nums_idc); |
188 | return AVERROR_INVALIDDATA; |
189 | } else |
190 | break; |
191 | |
192 | if (index >= ref_count[list]) { |
193 | av_log(logctx, AV_LOG_ERROR, |
194 | "reference count %d overflow\n", index); |
195 | return AVERROR_INVALIDDATA; |
196 | } |
197 | } |
198 | } |
199 | } |
200 | } |
201 | |
202 | if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) || |
203 | (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B)) |
204 | ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos, |
205 | &pwt, logctx); |
206 | |
207 | if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag |
208 | int i; |
209 | for (i = 0; i < MAX_MMCO_COUNT; i++) { |
210 | MMCOOpcode opcode = get_ue_golomb_31(gb); |
211 | if (opcode > (unsigned) MMCO_LONG) { |
212 | av_log(logctx, AV_LOG_ERROR, |
213 | "illegal memory management control operation %d\n", |
214 | opcode); |
215 | return AVERROR_INVALIDDATA; |
216 | } |
217 | if (opcode == MMCO_END) |
218 | return 0; |
219 | else if (opcode == MMCO_RESET) |
220 | return 1; |
221 | |
222 | if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) |
223 | get_ue_golomb_long(gb); // difference_of_pic_nums_minus1 |
224 | if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED || |
225 | opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) |
226 | get_ue_golomb_31(gb); |
227 | } |
228 | } |
229 | |
230 | return 0; |
231 | } |
232 | |
233 | /** |
234 | * Parse NAL units of found picture and decode some basic information. |
235 | * |
236 | * @param s parser context. |
237 | * @param avctx codec context. |
238 | * @param buf buffer with field/frame data. |
239 | * @param buf_size size of the buffer. |
240 | */ |
241 | static inline int parse_nal_units(AVCodecParserContext *s, |
242 | AVCodecContext *avctx, |
243 | const uint8_t * const buf, int buf_size) |
244 | { |
245 | H264ParseContext *p = s->priv_data; |
246 | H2645NAL nal = { NULL }; |
247 | int buf_index, next_avc; |
248 | unsigned int pps_id; |
249 | unsigned int slice_type; |
250 | int state = -1, got_reset = 0; |
251 | int q264 = buf_size >=4 && !memcmp("Q264", buf, 4); |
252 | int field_poc[2]; |
253 | int ret; |
254 | |
255 | /* set some sane default values */ |
256 | s->pict_type = AV_PICTURE_TYPE_I; |
257 | s->key_frame = 0; |
258 | s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN; |
259 | |
260 | ff_h264_sei_uninit(&p->sei); |
261 | p->sei.frame_packing.frame_packing_arrangement_cancel_flag = -1; |
262 | |
263 | if (!buf_size) |
264 | return 0; |
265 | |
266 | buf_index = 0; |
267 | next_avc = p->is_avc ? 0 : buf_size; |
268 | for (;;) { |
269 | const SPS *sps; |
270 | int src_length, consumed, nalsize = 0; |
271 | |
272 | if (buf_index >= next_avc) { |
273 | nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx); |
274 | if (nalsize < 0) |
275 | break; |
276 | next_avc = buf_index + nalsize; |
277 | } else { |
278 | buf_index = find_start_code(buf, buf_size, buf_index, next_avc); |
279 | if (buf_index >= buf_size) |
280 | break; |
281 | if (buf_index >= next_avc) |
282 | continue; |
283 | } |
284 | src_length = next_avc - buf_index; |
285 | |
286 | state = buf[buf_index]; |
287 | switch (state & 0x1f) { |
288 | case H264_NAL_SLICE: |
289 | case H264_NAL_IDR_SLICE: |
290 | // Do not walk the whole buffer just to decode slice header |
291 | if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) { |
292 | /* IDR or disposable slice |
293 | * No need to decode many bytes because MMCOs shall not be present. */ |
294 | if (src_length > 60) |
295 | src_length = 60; |
296 | } else { |
297 | /* To decode up to MMCOs */ |
298 | if (src_length > 1000) |
299 | src_length = 1000; |
300 | } |
301 | break; |
302 | } |
303 | consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &nal, 1); |
304 | if (consumed < 0) |
305 | break; |
306 | |
307 | buf_index += consumed; |
308 | |
309 | ret = init_get_bits8(&nal.gb, nal.data, nal.size); |
310 | if (ret < 0) |
311 | goto fail; |
312 | get_bits1(&nal.gb); |
313 | nal.ref_idc = get_bits(&nal.gb, 2); |
314 | nal.type = get_bits(&nal.gb, 5); |
315 | |
316 | switch (nal.type) { |
317 | case H264_NAL_SPS: |
318 | ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0); |
319 | break; |
320 | case H264_NAL_PPS: |
321 | ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps, |
322 | nal.size_bits); |
323 | break; |
324 | case H264_NAL_SEI: |
325 | ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx); |
326 | break; |
327 | case H264_NAL_264_DV_META: |
328 | /*00 00 00 01 7c 01 19 08 |
329 | nal type = 0x7c & 0x1f; |
330 | any conflict? |
331 | */ |
332 | avctx->has_dolby_vision_meta = 1; |
333 | break; |
334 | case H264_NAL_264_DV_EL: |
335 | /*00 00 00 01 7e |
336 | nal type = 0x7e & 0x1f; |
337 | any conflict? |
338 | */ |
339 | avctx->has_dolby_vision_el = 1; |
340 | break; |
341 | case H264_NAL_IDR_SLICE: |
342 | s->key_frame = 1; |
343 | |
344 | p->poc.prev_frame_num = 0; |
345 | p->poc.prev_frame_num_offset = 0; |
346 | p->poc.prev_poc_msb = |
347 | p->poc.prev_poc_lsb = 0; |
348 | /* fall through */ |
349 | case H264_NAL_SLICE: |
350 | get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice |
351 | slice_type = get_ue_golomb_31(&nal.gb); |
352 | s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5]; |
353 | if (p->sei.recovery_point.recovery_frame_cnt >= 0) { |
354 | /* key frame, since recovery_frame_cnt is set */ |
355 | s->key_frame = 1; |
356 | } |
357 | /* set key_frame for I frame*/ |
358 | if (s->pict_type == AV_PICTURE_TYPE_I) |
359 | s->key_frame = 1; |
360 | pps_id = get_ue_golomb(&nal.gb); |
361 | if (pps_id >= MAX_PPS_COUNT) { |
362 | av_log(avctx, AV_LOG_ERROR, |
363 | "pps_id %u out of range\n", pps_id); |
364 | goto fail; |
365 | } |
366 | if (!p->ps.pps_list[pps_id]) { |
367 | av_log(avctx, AV_LOG_ERROR, |
368 | "non-existing PPS %u referenced\n", pps_id); |
369 | goto fail; |
370 | } |
371 | |
372 | av_buffer_unref(&p->ps.pps_ref); |
373 | av_buffer_unref(&p->ps.sps_ref); |
374 | p->ps.pps = NULL; |
375 | p->ps.sps = NULL; |
376 | p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]); |
377 | if (!p->ps.pps_ref) |
378 | goto fail; |
379 | p->ps.pps = (const PPS*)p->ps.pps_ref->data; |
380 | |
381 | if (!p->ps.sps_list[p->ps.pps->sps_id]) { |
382 | av_log(avctx, AV_LOG_ERROR, |
383 | "non-existing SPS %u referenced\n", p->ps.pps->sps_id); |
384 | goto fail; |
385 | } |
386 | |
387 | p->ps.sps_ref = av_buffer_ref(p->ps.sps_list[p->ps.pps->sps_id]); |
388 | if (!p->ps.sps_ref) |
389 | goto fail; |
390 | p->ps.sps = (const SPS*)p->ps.sps_ref->data; |
391 | |
392 | sps = p->ps.sps; |
393 | |
394 | // heuristic to detect non marked keyframes |
395 | if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I) |
396 | s->key_frame = 1; |
397 | |
398 | p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num); |
399 | |
400 | s->coded_width = 16 * sps->mb_width; |
401 | s->coded_height = 16 * sps->mb_height; |
402 | s->width = s->coded_width - (sps->crop_right + sps->crop_left); |
403 | s->height = s->coded_height - (sps->crop_top + sps->crop_bottom); |
404 | if (s->width <= 0 || s->height <= 0) { |
405 | s->width = s->coded_width; |
406 | s->height = s->coded_height; |
407 | } |
408 | |
409 | switch (sps->bit_depth_luma) { |
410 | case 9: |
411 | if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9; |
412 | else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9; |
413 | else s->format = AV_PIX_FMT_YUV420P9; |
414 | break; |
415 | case 10: |
416 | if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10; |
417 | else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10; |
418 | else s->format = AV_PIX_FMT_YUV420P10; |
419 | break; |
420 | case 8: |
421 | if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P; |
422 | else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P; |
423 | else s->format = AV_PIX_FMT_YUV420P; |
424 | break; |
425 | default: |
426 | s->format = AV_PIX_FMT_NONE; |
427 | } |
428 | |
429 | avctx->profile = ff_h264_get_profile(sps); |
430 | avctx->level = sps->level_idc; |
431 | |
432 | if (sps->frame_mbs_only_flag) { |
433 | p->picture_structure = PICT_FRAME; |
434 | } else { |
435 | if (get_bits1(&nal.gb)) { // field_pic_flag |
436 | p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag |
437 | } else { |
438 | p->picture_structure = PICT_FRAME; |
439 | } |
440 | } |
441 | |
442 | if (nal.type == H264_NAL_IDR_SLICE) |
443 | get_ue_golomb_long(&nal.gb); /* idr_pic_id */ |
444 | if (sps->poc_type == 0) { |
445 | p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb); |
446 | |
447 | if (p->ps.pps->pic_order_present == 1 && |
448 | p->picture_structure == PICT_FRAME) |
449 | p->poc.delta_poc_bottom = get_se_golomb(&nal.gb); |
450 | } |
451 | |
452 | if (sps->poc_type == 1 && |
453 | !sps->delta_pic_order_always_zero_flag) { |
454 | p->poc.delta_poc[0] = get_se_golomb(&nal.gb); |
455 | |
456 | if (p->ps.pps->pic_order_present == 1 && |
457 | p->picture_structure == PICT_FRAME) |
458 | p->poc.delta_poc[1] = get_se_golomb(&nal.gb); |
459 | } |
460 | |
461 | /* Decode POC of this picture. |
462 | * The prev_ values needed for decoding POC of the next picture are not set here. */ |
463 | field_poc[0] = field_poc[1] = INT_MAX; |
464 | ff_h264_init_poc(field_poc, &s->output_picture_number, sps, |
465 | &p->poc, p->picture_structure, nal.ref_idc); |
466 | |
467 | /* Continue parsing to check if MMCO_RESET is present. |
468 | * FIXME: MMCO_RESET could appear in non-first slice. |
469 | * Maybe, we should parse all undisposable non-IDR slice of this |
470 | * picture until encountering MMCO_RESET in a slice of it. */ |
471 | if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) { |
472 | got_reset = scan_mmco_reset(s, &nal.gb, avctx); |
473 | if (got_reset < 0) |
474 | goto fail; |
475 | } |
476 | |
477 | /* Set up the prev_ values for decoding POC of the next picture. */ |
478 | p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num; |
479 | p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset; |
480 | if (nal.ref_idc != 0) { |
481 | if (!got_reset) { |
482 | p->poc.prev_poc_msb = p->poc.poc_msb; |
483 | p->poc.prev_poc_lsb = p->poc.poc_lsb; |
484 | } else { |
485 | p->poc.prev_poc_msb = 0; |
486 | p->poc.prev_poc_lsb = |
487 | p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0]; |
488 | } |
489 | } |
490 | |
491 | if (sps->pic_struct_present_flag && p->sei.picture_timing.present) { |
492 | switch (p->sei.picture_timing.pic_struct) { |
493 | case SEI_PIC_STRUCT_TOP_FIELD: |
494 | case SEI_PIC_STRUCT_BOTTOM_FIELD: |
495 | s->repeat_pict = 0; |
496 | break; |
497 | case SEI_PIC_STRUCT_FRAME: |
498 | case SEI_PIC_STRUCT_TOP_BOTTOM: |
499 | case SEI_PIC_STRUCT_BOTTOM_TOP: |
500 | s->repeat_pict = 1; |
501 | break; |
502 | case SEI_PIC_STRUCT_TOP_BOTTOM_TOP: |
503 | case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: |
504 | s->repeat_pict = 2; |
505 | break; |
506 | case SEI_PIC_STRUCT_FRAME_DOUBLING: |
507 | s->repeat_pict = 3; |
508 | break; |
509 | case SEI_PIC_STRUCT_FRAME_TRIPLING: |
510 | s->repeat_pict = 5; |
511 | break; |
512 | default: |
513 | s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0; |
514 | break; |
515 | } |
516 | } else { |
517 | s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0; |
518 | } |
519 | |
520 | if (p->picture_structure == PICT_FRAME) { |
521 | s->picture_structure = AV_PICTURE_STRUCTURE_FRAME; |
522 | if (sps->pic_struct_present_flag && p->sei.picture_timing.present) { |
523 | switch (p->sei.picture_timing.pic_struct) { |
524 | case SEI_PIC_STRUCT_TOP_BOTTOM: |
525 | case SEI_PIC_STRUCT_TOP_BOTTOM_TOP: |
526 | s->field_order = AV_FIELD_TT; |
527 | break; |
528 | case SEI_PIC_STRUCT_BOTTOM_TOP: |
529 | case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: |
530 | s->field_order = AV_FIELD_BB; |
531 | break; |
532 | default: |
533 | s->field_order = AV_FIELD_PROGRESSIVE; |
534 | break; |
535 | } |
536 | } else { |
537 | if (field_poc[0] < field_poc[1]) |
538 | s->field_order = AV_FIELD_TT; |
539 | else if (field_poc[0] > field_poc[1]) |
540 | s->field_order = AV_FIELD_BB; |
541 | else |
542 | s->field_order = AV_FIELD_PROGRESSIVE; |
543 | } |
544 | } else { |
545 | if (p->picture_structure == PICT_TOP_FIELD) |
546 | s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD; |
547 | else |
548 | s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD; |
549 | if (p->poc.frame_num == p->last_frame_num && |
550 | p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN && |
551 | p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME && |
552 | p->last_picture_structure != s->picture_structure) { |
553 | if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD) |
554 | s->field_order = AV_FIELD_TT; |
555 | else |
556 | s->field_order = AV_FIELD_BB; |
557 | } else { |
558 | s->field_order = AV_FIELD_UNKNOWN; |
559 | } |
560 | p->last_picture_structure = s->picture_structure; |
561 | p->last_frame_num = p->poc.frame_num; |
562 | } |
563 | |
564 | av_freep(&nal.rbsp_buffer); |
565 | return 0; /* no need to evaluate the rest */ |
566 | } |
567 | } |
568 | if (q264) { |
569 | av_freep(&nal.rbsp_buffer); |
570 | return 0; |
571 | } |
572 | /* didn't find a picture! */ |
573 | av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size); |
574 | fail: |
575 | av_freep(&nal.rbsp_buffer); |
576 | return -1; |
577 | } |
578 | |
579 | static int h264_parse(AVCodecParserContext *s, |
580 | AVCodecContext *avctx, |
581 | const uint8_t **poutbuf, int *poutbuf_size, |
582 | const uint8_t *buf, int buf_size) |
583 | { |
584 | H264ParseContext *p = s->priv_data; |
585 | ParseContext *pc = &p->pc; |
586 | int next; |
587 | |
588 | if (!p->got_first) { |
589 | p->got_first = 1; |
590 | if (avctx->extradata_size) { |
591 | ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size, |
592 | &p->ps, &p->is_avc, &p->nal_length_size, |
593 | avctx->err_recognition, avctx); |
594 | } |
595 | } |
596 | |
597 | if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { |
598 | next = buf_size; |
599 | } else { |
600 | next = h264_find_frame_end(p, buf, buf_size, avctx); |
601 | |
602 | if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { |
603 | *poutbuf = NULL; |
604 | *poutbuf_size = 0; |
605 | return buf_size; |
606 | } |
607 | |
608 | if (next < 0 && next != END_NOT_FOUND) { |
609 | av_assert1(pc->last_index + next >= 0); |
610 | h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state |
611 | } |
612 | } |
613 | |
614 | parse_nal_units(s, avctx, buf, buf_size); |
615 | |
616 | if (avctx->framerate.num) |
617 | avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1})); |
618 | if (p->sei.picture_timing.cpb_removal_delay >= 0) { |
619 | s->dts_sync_point = p->sei.buffering_period.present; |
620 | s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay; |
621 | s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay; |
622 | } else { |
623 | s->dts_sync_point = INT_MIN; |
624 | s->dts_ref_dts_delta = INT_MIN; |
625 | s->pts_dts_delta = INT_MIN; |
626 | } |
627 | |
628 | if (s->flags & PARSER_FLAG_ONCE) { |
629 | s->flags &= PARSER_FLAG_COMPLETE_FRAMES; |
630 | } |
631 | |
632 | if (s->dts_sync_point >= 0) { |
633 | int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num; |
634 | if (den > 0) { |
635 | int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den; |
636 | if (s->dts != AV_NOPTS_VALUE) { |
637 | // got DTS from the stream, update reference timestamp |
638 | p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den); |
639 | } else if (p->reference_dts != AV_NOPTS_VALUE) { |
640 | // compute DTS based on reference timestamp |
641 | s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den); |
642 | } |
643 | |
644 | if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE) |
645 | s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den); |
646 | |
647 | if (s->dts_sync_point > 0) |
648 | p->reference_dts = s->dts; // new reference |
649 | } |
650 | } |
651 | |
652 | *poutbuf = buf; |
653 | *poutbuf_size = buf_size; |
654 | return next; |
655 | } |
656 | |
657 | static int h264_split(AVCodecContext *avctx, |
658 | const uint8_t *buf, int buf_size) |
659 | { |
660 | uint32_t state = -1; |
661 | int has_sps = 0; |
662 | int has_pps = 0; |
663 | const uint8_t *ptr = buf, *end = buf + buf_size; |
664 | int nalu_type; |
665 | |
666 | while (ptr < end) { |
667 | ptr = avpriv_find_start_code(ptr, end, &state); |
668 | if ((state & 0xFFFFFF00) != 0x100) |
669 | break; |
670 | nalu_type = state & 0x1F; |
671 | if (nalu_type == H264_NAL_SPS) { |
672 | has_sps = 1; |
673 | } else if (nalu_type == H264_NAL_PPS) |
674 | has_pps = 1; |
675 | /* else if (nalu_type == 0x01 || |
676 | * nalu_type == 0x02 || |
677 | * nalu_type == 0x05) { |
678 | * } |
679 | */ |
680 | else if ((nalu_type != H264_NAL_SEI || has_pps) && |
681 | nalu_type != H264_NAL_AUD && nalu_type != H264_NAL_SPS_EXT && |
682 | nalu_type != 0x0f) { |
683 | if (has_sps) { |
684 | while (ptr - 4 > buf && ptr[-5] == 0) |
685 | ptr--; |
686 | return ptr - 4 - buf; |
687 | } |
688 | } |
689 | } |
690 | |
691 | return 0; |
692 | } |
693 | |
694 | static void h264_close(AVCodecParserContext *s) |
695 | { |
696 | H264ParseContext *p = s->priv_data; |
697 | ParseContext *pc = &p->pc; |
698 | |
699 | av_freep(&pc->buffer); |
700 | |
701 | ff_h264_sei_uninit(&p->sei); |
702 | ff_h264_ps_uninit(&p->ps); |
703 | } |
704 | |
705 | static av_cold int init(AVCodecParserContext *s) |
706 | { |
707 | H264ParseContext *p = s->priv_data; |
708 | |
709 | p->reference_dts = AV_NOPTS_VALUE; |
710 | p->last_frame_num = INT_MAX; |
711 | ff_h264dsp_init(&p->h264dsp, 8, 1); |
712 | return 0; |
713 | } |
714 | |
715 | AVCodecParser ff_h264_parser = { |
716 | .codec_ids = { AV_CODEC_ID_H264 }, |
717 | .priv_data_size = sizeof(H264ParseContext), |
718 | .parser_init = init, |
719 | .parser_parse = h264_parse, |
720 | .parser_close = h264_close, |
721 | .split = h264_split, |
722 | }; |
723 |