blob: aed0793b5162939e2205c3c89fcbf7e2ad566f91
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: |
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_IDR_SLICE: |
335 | s->key_frame = 1; |
336 | |
337 | p->poc.prev_frame_num = 0; |
338 | p->poc.prev_frame_num_offset = 0; |
339 | p->poc.prev_poc_msb = |
340 | p->poc.prev_poc_lsb = 0; |
341 | /* fall through */ |
342 | case H264_NAL_SLICE: |
343 | get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice |
344 | slice_type = get_ue_golomb_31(&nal.gb); |
345 | s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5]; |
346 | if (p->sei.recovery_point.recovery_frame_cnt >= 0) { |
347 | /* key frame, since recovery_frame_cnt is set */ |
348 | s->key_frame = 1; |
349 | } |
350 | pps_id = get_ue_golomb(&nal.gb); |
351 | if (pps_id >= MAX_PPS_COUNT) { |
352 | av_log(avctx, AV_LOG_ERROR, |
353 | "pps_id %u out of range\n", pps_id); |
354 | goto fail; |
355 | } |
356 | if (!p->ps.pps_list[pps_id]) { |
357 | av_log(avctx, AV_LOG_ERROR, |
358 | "non-existing PPS %u referenced\n", pps_id); |
359 | goto fail; |
360 | } |
361 | |
362 | av_buffer_unref(&p->ps.pps_ref); |
363 | av_buffer_unref(&p->ps.sps_ref); |
364 | p->ps.pps = NULL; |
365 | p->ps.sps = NULL; |
366 | p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]); |
367 | if (!p->ps.pps_ref) |
368 | goto fail; |
369 | p->ps.pps = (const PPS*)p->ps.pps_ref->data; |
370 | |
371 | if (!p->ps.sps_list[p->ps.pps->sps_id]) { |
372 | av_log(avctx, AV_LOG_ERROR, |
373 | "non-existing SPS %u referenced\n", p->ps.pps->sps_id); |
374 | goto fail; |
375 | } |
376 | |
377 | p->ps.sps_ref = av_buffer_ref(p->ps.sps_list[p->ps.pps->sps_id]); |
378 | if (!p->ps.sps_ref) |
379 | goto fail; |
380 | p->ps.sps = (const SPS*)p->ps.sps_ref->data; |
381 | |
382 | sps = p->ps.sps; |
383 | |
384 | // heuristic to detect non marked keyframes |
385 | if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I) |
386 | s->key_frame = 1; |
387 | |
388 | p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num); |
389 | |
390 | s->coded_width = 16 * sps->mb_width; |
391 | s->coded_height = 16 * sps->mb_height; |
392 | s->width = s->coded_width - (sps->crop_right + sps->crop_left); |
393 | s->height = s->coded_height - (sps->crop_top + sps->crop_bottom); |
394 | if (s->width <= 0 || s->height <= 0) { |
395 | s->width = s->coded_width; |
396 | s->height = s->coded_height; |
397 | } |
398 | |
399 | switch (sps->bit_depth_luma) { |
400 | case 9: |
401 | if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9; |
402 | else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9; |
403 | else s->format = AV_PIX_FMT_YUV420P9; |
404 | break; |
405 | case 10: |
406 | if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10; |
407 | else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10; |
408 | else s->format = AV_PIX_FMT_YUV420P10; |
409 | break; |
410 | case 8: |
411 | if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P; |
412 | else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P; |
413 | else s->format = AV_PIX_FMT_YUV420P; |
414 | break; |
415 | default: |
416 | s->format = AV_PIX_FMT_NONE; |
417 | } |
418 | |
419 | avctx->profile = ff_h264_get_profile(sps); |
420 | avctx->level = sps->level_idc; |
421 | |
422 | if (sps->frame_mbs_only_flag) { |
423 | p->picture_structure = PICT_FRAME; |
424 | } else { |
425 | if (get_bits1(&nal.gb)) { // field_pic_flag |
426 | p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag |
427 | } else { |
428 | p->picture_structure = PICT_FRAME; |
429 | } |
430 | } |
431 | |
432 | if (nal.type == H264_NAL_IDR_SLICE) |
433 | get_ue_golomb_long(&nal.gb); /* idr_pic_id */ |
434 | if (sps->poc_type == 0) { |
435 | p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb); |
436 | |
437 | if (p->ps.pps->pic_order_present == 1 && |
438 | p->picture_structure == PICT_FRAME) |
439 | p->poc.delta_poc_bottom = get_se_golomb(&nal.gb); |
440 | } |
441 | |
442 | if (sps->poc_type == 1 && |
443 | !sps->delta_pic_order_always_zero_flag) { |
444 | p->poc.delta_poc[0] = get_se_golomb(&nal.gb); |
445 | |
446 | if (p->ps.pps->pic_order_present == 1 && |
447 | p->picture_structure == PICT_FRAME) |
448 | p->poc.delta_poc[1] = get_se_golomb(&nal.gb); |
449 | } |
450 | |
451 | /* Decode POC of this picture. |
452 | * The prev_ values needed for decoding POC of the next picture are not set here. */ |
453 | field_poc[0] = field_poc[1] = INT_MAX; |
454 | ff_h264_init_poc(field_poc, &s->output_picture_number, sps, |
455 | &p->poc, p->picture_structure, nal.ref_idc); |
456 | |
457 | /* Continue parsing to check if MMCO_RESET is present. |
458 | * FIXME: MMCO_RESET could appear in non-first slice. |
459 | * Maybe, we should parse all undisposable non-IDR slice of this |
460 | * picture until encountering MMCO_RESET in a slice of it. */ |
461 | if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) { |
462 | got_reset = scan_mmco_reset(s, &nal.gb, avctx); |
463 | if (got_reset < 0) |
464 | goto fail; |
465 | } |
466 | |
467 | /* Set up the prev_ values for decoding POC of the next picture. */ |
468 | p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num; |
469 | p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset; |
470 | if (nal.ref_idc != 0) { |
471 | if (!got_reset) { |
472 | p->poc.prev_poc_msb = p->poc.poc_msb; |
473 | p->poc.prev_poc_lsb = p->poc.poc_lsb; |
474 | } else { |
475 | p->poc.prev_poc_msb = 0; |
476 | p->poc.prev_poc_lsb = |
477 | p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0]; |
478 | } |
479 | } |
480 | |
481 | if (sps->pic_struct_present_flag && p->sei.picture_timing.present) { |
482 | switch (p->sei.picture_timing.pic_struct) { |
483 | case SEI_PIC_STRUCT_TOP_FIELD: |
484 | case SEI_PIC_STRUCT_BOTTOM_FIELD: |
485 | s->repeat_pict = 0; |
486 | break; |
487 | case SEI_PIC_STRUCT_FRAME: |
488 | case SEI_PIC_STRUCT_TOP_BOTTOM: |
489 | case SEI_PIC_STRUCT_BOTTOM_TOP: |
490 | s->repeat_pict = 1; |
491 | break; |
492 | case SEI_PIC_STRUCT_TOP_BOTTOM_TOP: |
493 | case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: |
494 | s->repeat_pict = 2; |
495 | break; |
496 | case SEI_PIC_STRUCT_FRAME_DOUBLING: |
497 | s->repeat_pict = 3; |
498 | break; |
499 | case SEI_PIC_STRUCT_FRAME_TRIPLING: |
500 | s->repeat_pict = 5; |
501 | break; |
502 | default: |
503 | s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0; |
504 | break; |
505 | } |
506 | } else { |
507 | s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0; |
508 | } |
509 | |
510 | if (p->picture_structure == PICT_FRAME) { |
511 | s->picture_structure = AV_PICTURE_STRUCTURE_FRAME; |
512 | if (sps->pic_struct_present_flag && p->sei.picture_timing.present) { |
513 | switch (p->sei.picture_timing.pic_struct) { |
514 | case SEI_PIC_STRUCT_TOP_BOTTOM: |
515 | case SEI_PIC_STRUCT_TOP_BOTTOM_TOP: |
516 | s->field_order = AV_FIELD_TT; |
517 | break; |
518 | case SEI_PIC_STRUCT_BOTTOM_TOP: |
519 | case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: |
520 | s->field_order = AV_FIELD_BB; |
521 | break; |
522 | default: |
523 | s->field_order = AV_FIELD_PROGRESSIVE; |
524 | break; |
525 | } |
526 | } else { |
527 | if (field_poc[0] < field_poc[1]) |
528 | s->field_order = AV_FIELD_TT; |
529 | else if (field_poc[0] > field_poc[1]) |
530 | s->field_order = AV_FIELD_BB; |
531 | else |
532 | s->field_order = AV_FIELD_PROGRESSIVE; |
533 | } |
534 | } else { |
535 | if (p->picture_structure == PICT_TOP_FIELD) |
536 | s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD; |
537 | else |
538 | s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD; |
539 | if (p->poc.frame_num == p->last_frame_num && |
540 | p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN && |
541 | p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME && |
542 | p->last_picture_structure != s->picture_structure) { |
543 | if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD) |
544 | s->field_order = AV_FIELD_TT; |
545 | else |
546 | s->field_order = AV_FIELD_BB; |
547 | } else { |
548 | s->field_order = AV_FIELD_UNKNOWN; |
549 | } |
550 | p->last_picture_structure = s->picture_structure; |
551 | p->last_frame_num = p->poc.frame_num; |
552 | } |
553 | |
554 | av_freep(&nal.rbsp_buffer); |
555 | return 0; /* no need to evaluate the rest */ |
556 | } |
557 | } |
558 | if (q264) { |
559 | av_freep(&nal.rbsp_buffer); |
560 | return 0; |
561 | } |
562 | /* didn't find a picture! */ |
563 | av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size); |
564 | fail: |
565 | av_freep(&nal.rbsp_buffer); |
566 | return -1; |
567 | } |
568 | |
569 | static int h264_parse(AVCodecParserContext *s, |
570 | AVCodecContext *avctx, |
571 | const uint8_t **poutbuf, int *poutbuf_size, |
572 | const uint8_t *buf, int buf_size) |
573 | { |
574 | H264ParseContext *p = s->priv_data; |
575 | ParseContext *pc = &p->pc; |
576 | int next; |
577 | |
578 | if (!p->got_first) { |
579 | p->got_first = 1; |
580 | if (avctx->extradata_size) { |
581 | ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size, |
582 | &p->ps, &p->is_avc, &p->nal_length_size, |
583 | avctx->err_recognition, avctx); |
584 | } |
585 | } |
586 | |
587 | if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) { |
588 | next = buf_size; |
589 | } else { |
590 | next = h264_find_frame_end(p, buf, buf_size, avctx); |
591 | |
592 | if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) { |
593 | *poutbuf = NULL; |
594 | *poutbuf_size = 0; |
595 | return buf_size; |
596 | } |
597 | |
598 | if (next < 0 && next != END_NOT_FOUND) { |
599 | av_assert1(pc->last_index + next >= 0); |
600 | h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state |
601 | } |
602 | } |
603 | |
604 | parse_nal_units(s, avctx, buf, buf_size); |
605 | |
606 | if (avctx->framerate.num) |
607 | avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1})); |
608 | if (p->sei.picture_timing.cpb_removal_delay >= 0) { |
609 | s->dts_sync_point = p->sei.buffering_period.present; |
610 | s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay; |
611 | s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay; |
612 | } else { |
613 | s->dts_sync_point = INT_MIN; |
614 | s->dts_ref_dts_delta = INT_MIN; |
615 | s->pts_dts_delta = INT_MIN; |
616 | } |
617 | |
618 | if (s->flags & PARSER_FLAG_ONCE) { |
619 | s->flags &= PARSER_FLAG_COMPLETE_FRAMES; |
620 | } |
621 | |
622 | if (s->dts_sync_point >= 0) { |
623 | int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num; |
624 | if (den > 0) { |
625 | int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den; |
626 | if (s->dts != AV_NOPTS_VALUE) { |
627 | // got DTS from the stream, update reference timestamp |
628 | p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den); |
629 | } else if (p->reference_dts != AV_NOPTS_VALUE) { |
630 | // compute DTS based on reference timestamp |
631 | s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den); |
632 | } |
633 | |
634 | if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE) |
635 | s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den); |
636 | |
637 | if (s->dts_sync_point > 0) |
638 | p->reference_dts = s->dts; // new reference |
639 | } |
640 | } |
641 | |
642 | *poutbuf = buf; |
643 | *poutbuf_size = buf_size; |
644 | return next; |
645 | } |
646 | |
647 | static int h264_split(AVCodecContext *avctx, |
648 | const uint8_t *buf, int buf_size) |
649 | { |
650 | uint32_t state = -1; |
651 | int has_sps = 0; |
652 | int has_pps = 0; |
653 | const uint8_t *ptr = buf, *end = buf + buf_size; |
654 | int nalu_type; |
655 | |
656 | while (ptr < end) { |
657 | ptr = avpriv_find_start_code(ptr, end, &state); |
658 | if ((state & 0xFFFFFF00) != 0x100) |
659 | break; |
660 | nalu_type = state & 0x1F; |
661 | if (nalu_type == H264_NAL_SPS) { |
662 | has_sps = 1; |
663 | } else if (nalu_type == H264_NAL_PPS) |
664 | has_pps = 1; |
665 | /* else if (nalu_type == 0x01 || |
666 | * nalu_type == 0x02 || |
667 | * nalu_type == 0x05) { |
668 | * } |
669 | */ |
670 | else if ((nalu_type != H264_NAL_SEI || has_pps) && |
671 | nalu_type != H264_NAL_AUD && nalu_type != H264_NAL_SPS_EXT && |
672 | nalu_type != 0x0f) { |
673 | if (has_sps) { |
674 | while (ptr - 4 > buf && ptr[-5] == 0) |
675 | ptr--; |
676 | return ptr - 4 - buf; |
677 | } |
678 | } |
679 | } |
680 | |
681 | return 0; |
682 | } |
683 | |
684 | static void h264_close(AVCodecParserContext *s) |
685 | { |
686 | H264ParseContext *p = s->priv_data; |
687 | ParseContext *pc = &p->pc; |
688 | |
689 | av_freep(&pc->buffer); |
690 | |
691 | ff_h264_sei_uninit(&p->sei); |
692 | ff_h264_ps_uninit(&p->ps); |
693 | } |
694 | |
695 | static av_cold int init(AVCodecParserContext *s) |
696 | { |
697 | H264ParseContext *p = s->priv_data; |
698 | |
699 | p->reference_dts = AV_NOPTS_VALUE; |
700 | p->last_frame_num = INT_MAX; |
701 | ff_h264dsp_init(&p->h264dsp, 8, 1); |
702 | return 0; |
703 | } |
704 | |
705 | AVCodecParser ff_h264_parser = { |
706 | .codec_ids = { AV_CODEC_ID_H264 }, |
707 | .priv_data_size = sizeof(H264ParseContext), |
708 | .parser_init = init, |
709 | .parser_parse = h264_parse, |
710 | .parser_close = h264_close, |
711 | .split = h264_split, |
712 | }; |
713 |