FFmpeg
h264_parser.c
Go to the documentation of this file.
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 <stdint.h>
31 
32 #include "libavutil/avutil.h"
33 #include "libavutil/error.h"
34 #include "libavutil/log.h"
35 #include "libavutil/mem.h"
36 #include "libavutil/pixfmt.h"
37 
38 #include "avcodec.h"
39 #include "get_bits.h"
40 #include "golomb.h"
41 #include "h264.h"
42 #include "h264dsp.h"
43 #include "h264_parse.h"
44 #include "h264_sei.h"
45 #include "h264_ps.h"
46 #include "h2645_parse.h"
47 #include "h264data.h"
48 #include "mpegutils.h"
49 #include "parser.h"
50 #include "refstruct.h"
51 #include "startcode.h"
52 
53 typedef struct H264ParseContext {
59  int is_avc;
61  int got_first;
63  uint8_t parse_history[6];
66  int64_t reference_dts;
69 
70 static int find_start_code(const uint8_t *buf, int buf_size,
71  int buf_index, int next_avc)
72 {
73  uint32_t state = -1;
74 
75  buf_index = avpriv_find_start_code(buf + buf_index, buf + next_avc + 1, &state) - buf - 1;
76 
77  return FFMIN(buf_index, buf_size);
78 }
79 
80 static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf,
81  int buf_size, void *logctx)
82 {
83  int i, j;
84  uint32_t state;
85  ParseContext *pc = &p->pc;
86 
87  int next_avc = p->is_avc ? 0 : buf_size;
88 // mb_addr= pc->mb_addr - 1;
89  state = pc->state;
90  if (state > 13)
91  state = 7;
92 
93  if (p->is_avc && !p->nal_length_size)
94  av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n");
95 
96  for (i = 0; i < buf_size; i++) {
97  if (i >= next_avc) {
98  int64_t nalsize = 0;
99  i = next_avc;
100  for (j = 0; j < p->nal_length_size; j++)
101  nalsize = (nalsize << 8) | buf[i++];
102  if (!nalsize || nalsize > buf_size - i) {
103  av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal size %"PRId64" "
104  "remaining %d\n", nalsize, buf_size - i);
105  return buf_size;
106  }
107  next_avc = i + nalsize;
108  state = 5;
109  }
110 
111  if (state == 7) {
112  i += p->h264dsp.startcode_find_candidate(buf + i, next_avc - i);
113  if (i < next_avc)
114  state = 2;
115  } else if (state <= 2) {
116  if (buf[i] == 1)
117  state ^= 5; // 2->7, 1->4, 0->5
118  else if (buf[i])
119  state = 7;
120  else
121  state >>= 1; // 2->1, 1->0, 0->0
122  } else if (state <= 5) {
123  int nalu_type = buf[i] & 0x1F;
124  if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS ||
125  nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) {
126  if (pc->frame_start_found) {
127  i++;
128  goto found;
129  }
130  } else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA ||
131  nalu_type == H264_NAL_IDR_SLICE) {
132  state += 8;
133  continue;
134  }
135  state = 7;
136  } else {
137  unsigned int mb, last_mb = p->parse_last_mb;
138  GetBitContext gb;
139  p->parse_history[p->parse_history_count++] = buf[i];
140 
142  mb= get_ue_golomb_long(&gb);
143  if (get_bits_left(&gb) > 0 || p->parse_history_count > 5) {
144  p->parse_last_mb = mb;
145  if (pc->frame_start_found) {
146  if (mb <= last_mb) {
147  i -= p->parse_history_count - 1;
148  p->parse_history_count = 0;
149  goto found;
150  }
151  } else
152  pc->frame_start_found = 1;
153  p->parse_history_count = 0;
154  state = 7;
155  }
156  }
157  }
158  pc->state = state;
159  if (p->is_avc)
160  return next_avc;
161  return END_NOT_FOUND;
162 
163 found:
164  pc->state = 7;
165  pc->frame_start_found = 0;
166  if (p->is_avc)
167  return next_avc;
168  return i - (state & 5);
169 }
170 
172  void *logctx)
173 {
175  int slice_type_nos = s->pict_type & 3;
176  H264ParseContext *p = s->priv_data;
177  int list_count, ref_count[2];
178 
179 
181  get_ue_golomb(gb); // redundant_pic_count
182 
183  if (slice_type_nos == AV_PICTURE_TYPE_B)
184  get_bits1(gb); // direct_spatial_mv_pred
185 
186  if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps,
187  slice_type_nos, p->picture_structure, logctx) < 0)
188  return AVERROR_INVALIDDATA;
189 
190  if (slice_type_nos != AV_PICTURE_TYPE_I) {
191  int list;
192  for (list = 0; list < list_count; list++) {
193  if (get_bits1(gb)) {
194  int index;
195  for (index = 0; ; index++) {
196  unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb);
197 
198  if (reordering_of_pic_nums_idc < 3)
199  get_ue_golomb_long(gb);
200  else if (reordering_of_pic_nums_idc > 3) {
201  av_log(logctx, AV_LOG_ERROR,
202  "illegal reordering_of_pic_nums_idc %d\n",
203  reordering_of_pic_nums_idc);
204  return AVERROR_INVALIDDATA;
205  } else
206  break;
207 
208  if (index >= ref_count[list]) {
209  av_log(logctx, AV_LOG_ERROR,
210  "reference count %d overflow\n", index);
211  return AVERROR_INVALIDDATA;
212  }
213  }
214  }
215  }
216  }
217 
218  if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
219  (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))
220  ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,
221  &pwt, p->picture_structure, logctx);
222 
223  if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
224  int i;
225  for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {
226  MMCOOpcode opcode = get_ue_golomb_31(gb);
227  if (opcode > (unsigned) MMCO_LONG) {
228  av_log(logctx, AV_LOG_ERROR,
229  "illegal memory management control operation %d\n",
230  opcode);
231  return AVERROR_INVALIDDATA;
232  }
233  if (opcode == MMCO_END)
234  return 0;
235  else if (opcode == MMCO_RESET)
236  return 1;
237 
238  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)
239  get_ue_golomb_long(gb); // difference_of_pic_nums_minus1
240  if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
241  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)
242  get_ue_golomb_31(gb);
243  }
244  }
245 
246  return 0;
247 }
248 
249 /**
250  * Parse NAL units of found picture and decode some basic information.
251  *
252  * @param s parser context.
253  * @param avctx codec context.
254  * @param buf buffer with field/frame data.
255  * @param buf_size size of the buffer.
256  */
258  AVCodecContext *avctx,
259  const uint8_t * const buf, int buf_size)
260 {
261  H264ParseContext *p = s->priv_data;
262  H2645RBSP rbsp = { NULL };
263  H2645NAL nal = { NULL };
264  int buf_index, next_avc;
265  unsigned int pps_id;
266  unsigned int slice_type;
267  int state = -1, got_reset = 0;
268  int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
269  int field_poc[2];
270  int ret;
271 
272  /* set some sane default values */
273  s->pict_type = AV_PICTURE_TYPE_I;
274  s->key_frame = 0;
275  s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
276 
277  ff_h264_sei_uninit(&p->sei);
280 
281  if (!buf_size)
282  return 0;
283 
285  if (!rbsp.rbsp_buffer)
286  return AVERROR(ENOMEM);
287 
288  buf_index = 0;
289  next_avc = p->is_avc ? 0 : buf_size;
290  for (;;) {
291  const SPS *sps;
292  int src_length, consumed, nalsize = 0;
293 
294  if (buf_index >= next_avc) {
295  nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);
296  if (nalsize < 0)
297  break;
298  next_avc = buf_index + nalsize;
299  } else {
300  buf_index = find_start_code(buf, buf_size, buf_index, next_avc);
301  if (buf_index >= buf_size)
302  break;
303  if (buf_index >= next_avc)
304  continue;
305  }
306  src_length = next_avc - buf_index;
307 
308  state = buf[buf_index];
309  switch (state & 0x1f) {
310  case H264_NAL_SLICE:
311  case H264_NAL_IDR_SLICE:
312  // Do not walk the whole buffer just to decode slice header
313  if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {
314  /* IDR or disposable slice
315  * No need to decode many bytes because MMCOs shall not be present. */
316  if (src_length > 60)
317  src_length = 60;
318  } else {
319  /* To decode up to MMCOs */
320  if (src_length > 1000)
321  src_length = 1000;
322  }
323  break;
324  }
325  consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &rbsp, &nal, 1);
326  if (consumed < 0)
327  break;
328 
329  buf_index += consumed;
330 
331  ret = init_get_bits8(&nal.gb, nal.data, nal.size);
332  if (ret < 0)
333  goto fail;
334  get_bits1(&nal.gb);
335  nal.ref_idc = get_bits(&nal.gb, 2);
336  nal.type = get_bits(&nal.gb, 5);
337 
338  switch (nal.type) {
339  case H264_NAL_SPS:
340  ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);
341  break;
342  case H264_NAL_PPS:
343  ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,
344  nal.size_bits);
345  break;
346  case H264_NAL_SEI:
347  ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);
348  break;
349  case H264_NAL_IDR_SLICE:
350  s->key_frame = 1;
351 
352  p->poc.prev_frame_num = 0;
353  p->poc.prev_frame_num_offset = 0;
354  p->poc.prev_poc_msb =
355  p->poc.prev_poc_lsb = 0;
356  /* fall through */
357  case H264_NAL_SLICE:
358  get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice
359  slice_type = get_ue_golomb_31(&nal.gb);
360  s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
361  if (p->sei.recovery_point.recovery_frame_cnt >= 0) {
362  /* key frame, since recovery_frame_cnt is set */
363  s->key_frame = 1;
364  }
365  pps_id = get_ue_golomb(&nal.gb);
366  if (pps_id >= MAX_PPS_COUNT) {
367  av_log(avctx, AV_LOG_ERROR,
368  "pps_id %u out of range\n", pps_id);
369  goto fail;
370  }
371  if (!p->ps.pps_list[pps_id]) {
372  av_log(avctx, AV_LOG_ERROR,
373  "non-existing PPS %u referenced\n", pps_id);
374  goto fail;
375  }
376 
377  ff_refstruct_replace(&p->ps.pps, p->ps.pps_list[pps_id]);
378  p->ps.sps = p->ps.pps->sps;
379  sps = p->ps.sps;
380 
381  // heuristic to detect non marked keyframes
382  if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
383  s->key_frame = 1;
384 
385  p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
386 
387  s->coded_width = 16 * sps->mb_width;
388  s->coded_height = 16 * sps->mb_height;
389  s->width = s->coded_width - (sps->crop_right + sps->crop_left);
390  s->height = s->coded_height - (sps->crop_top + sps->crop_bottom);
391  if (s->width <= 0 || s->height <= 0) {
392  s->width = s->coded_width;
393  s->height = s->coded_height;
394  }
395 
396  switch (sps->bit_depth_luma) {
397  case 9:
398  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9;
399  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;
400  else s->format = AV_PIX_FMT_YUV420P9;
401  break;
402  case 10:
403  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10;
404  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;
405  else s->format = AV_PIX_FMT_YUV420P10;
406  break;
407  case 8:
408  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P;
409  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;
410  else s->format = AV_PIX_FMT_YUV420P;
411  break;
412  default:
413  s->format = AV_PIX_FMT_NONE;
414  }
415 
416  avctx->profile = ff_h264_get_profile(sps);
417  avctx->level = sps->level_idc;
418 
419  if (sps->frame_mbs_only_flag) {
421  } else {
422  if (get_bits1(&nal.gb)) { // field_pic_flag
423  p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag
424  } else {
426  }
427  }
428 
429  if (nal.type == H264_NAL_IDR_SLICE)
430  get_ue_golomb_long(&nal.gb); /* idr_pic_id */
431  if (sps->poc_type == 0) {
432  p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
433 
434  if (p->ps.pps->pic_order_present == 1 &&
437  }
438 
439  if (sps->poc_type == 1 &&
440  !sps->delta_pic_order_always_zero_flag) {
441  p->poc.delta_poc[0] = get_se_golomb(&nal.gb);
442 
443  if (p->ps.pps->pic_order_present == 1 &&
445  p->poc.delta_poc[1] = get_se_golomb(&nal.gb);
446  }
447 
448  /* Decode POC of this picture.
449  * The prev_ values needed for decoding POC of the next picture are not set here. */
450  field_poc[0] = field_poc[1] = INT_MAX;
451  ret = ff_h264_init_poc(field_poc, &s->output_picture_number, sps,
452  &p->poc, p->picture_structure, nal.ref_idc);
453  if (ret < 0)
454  goto fail;
455 
456  /* Continue parsing to check if MMCO_RESET is present.
457  * FIXME: MMCO_RESET could appear in non-first slice.
458  * Maybe, we should parse all undisposable non-IDR slice of this
459  * picture until encountering MMCO_RESET in a slice of it. */
460  if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {
461  got_reset = scan_mmco_reset(s, &nal.gb, avctx);
462  if (got_reset < 0)
463  goto fail;
464  }
465 
466  /* Set up the prev_ values for decoding POC of the next picture. */
467  p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num;
468  p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;
469  if (nal.ref_idc != 0) {
470  if (!got_reset) {
471  p->poc.prev_poc_msb = p->poc.poc_msb;
472  p->poc.prev_poc_lsb = p->poc.poc_lsb;
473  } else {
474  p->poc.prev_poc_msb = 0;
475  p->poc.prev_poc_lsb =
476  p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];
477  }
478  }
479 
480  if (p->sei.picture_timing.present) {
482  sps, avctx);
483  if (ret < 0) {
484  av_log(avctx, AV_LOG_ERROR, "Error processing the picture timing SEI\n");
485  p->sei.picture_timing.present = 0;
486  }
487  }
488 
489  if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
490  switch (p->sei.picture_timing.pic_struct) {
493  s->repeat_pict = 0;
494  break;
498  s->repeat_pict = 1;
499  break;
502  s->repeat_pict = 2;
503  break;
505  s->repeat_pict = 3;
506  break;
508  s->repeat_pict = 5;
509  break;
510  default:
511  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
512  break;
513  }
514  } else {
515  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
516  }
517 
518  if (p->picture_structure == PICT_FRAME) {
519  s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
520  if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
521  switch (p->sei.picture_timing.pic_struct) {
524  s->field_order = AV_FIELD_TT;
525  break;
528  s->field_order = AV_FIELD_BB;
529  break;
530  default:
531  s->field_order = AV_FIELD_PROGRESSIVE;
532  break;
533  }
534  } else {
535  if (field_poc[0] < field_poc[1])
536  s->field_order = AV_FIELD_TT;
537  else if (field_poc[0] > field_poc[1])
538  s->field_order = AV_FIELD_BB;
539  else
540  s->field_order = AV_FIELD_PROGRESSIVE;
541  }
542  } else {
544  s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;
545  else
546  s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
547  if (p->poc.frame_num == p->last_frame_num &&
550  p->last_picture_structure != s->picture_structure) {
552  s->field_order = AV_FIELD_TT;
553  else
554  s->field_order = AV_FIELD_BB;
555  } else {
556  s->field_order = AV_FIELD_UNKNOWN;
557  }
558  p->last_picture_structure = s->picture_structure;
559  p->last_frame_num = p->poc.frame_num;
560  }
561  if (sps->timing_info_present_flag) {
562  int64_t den = sps->time_scale;
563  if (p->sei.common.unregistered.x264_build < 44U)
564  den *= 2;
565  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
566  sps->num_units_in_tick * 2, den, 1 << 30);
567  }
568 
569  av_freep(&rbsp.rbsp_buffer);
570  return 0; /* no need to evaluate the rest */
571  }
572  }
573  if (q264) {
574  av_freep(&rbsp.rbsp_buffer);
575  return 0;
576  }
577  /* didn't find a picture! */
578  av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
579 fail:
580  av_freep(&rbsp.rbsp_buffer);
581  return -1;
582 }
583 
585  AVCodecContext *avctx,
586  const uint8_t **poutbuf, int *poutbuf_size,
587  const uint8_t *buf, int buf_size)
588 {
589  H264ParseContext *p = s->priv_data;
590  ParseContext *pc = &p->pc;
591  AVRational time_base = { 0, 1 };
592  int next;
593 
594  if (!p->got_first) {
595  p->got_first = 1;
596  if (avctx->extradata_size) {
598  &p->ps, &p->is_avc, &p->nal_length_size,
599  avctx->err_recognition, avctx);
600  }
601  }
602 
603  if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
604  next = buf_size;
605  } else {
606  next = h264_find_frame_end(p, buf, buf_size, avctx);
607 
608  if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
609  *poutbuf = NULL;
610  *poutbuf_size = 0;
611  return buf_size;
612  }
613 
614  if (next < 0 && next != END_NOT_FOUND) {
615  av_assert1(pc->last_index + next >= 0);
616  h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state
617  }
618  }
619 
620  parse_nal_units(s, avctx, buf, buf_size);
621 
622  if (avctx->framerate.num)
623  time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){2, 1}));
624  if (p->sei.picture_timing.cpb_removal_delay >= 0) {
625  s->dts_sync_point = p->sei.buffering_period.present;
626  s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay;
627  s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay;
628  } else {
629  s->dts_sync_point = INT_MIN;
630  s->dts_ref_dts_delta = INT_MIN;
631  s->pts_dts_delta = INT_MIN;
632  }
633 
634  if (s->flags & PARSER_FLAG_ONCE) {
635  s->flags &= PARSER_FLAG_COMPLETE_FRAMES;
636  }
637 
638  if (s->dts_sync_point >= 0) {
639  int64_t den = time_base.den * (int64_t)avctx->pkt_timebase.num;
640  if (den > 0) {
641  int64_t num = time_base.num * (int64_t)avctx->pkt_timebase.den;
642  if (s->dts != AV_NOPTS_VALUE) {
643  // got DTS from the stream, update reference timestamp
644  p->reference_dts = av_sat_sub64(s->dts, av_rescale(s->dts_ref_dts_delta, num, den));
645  } else if (p->reference_dts != AV_NOPTS_VALUE) {
646  // compute DTS based on reference timestamp
647  s->dts = av_sat_add64(p->reference_dts, av_rescale(s->dts_ref_dts_delta, num, den));
648  }
649 
650  if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE)
651  s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den);
652 
653  if (s->dts_sync_point > 0)
654  p->reference_dts = s->dts; // new reference
655  }
656  }
657 
658  *poutbuf = buf;
659  *poutbuf_size = buf_size;
660  return next;
661 }
662 
664 {
665  H264ParseContext *p = s->priv_data;
666  ParseContext *pc = &p->pc;
667 
668  av_freep(&pc->buffer);
669 
670  ff_h264_sei_uninit(&p->sei);
671  ff_h264_ps_uninit(&p->ps);
672 }
673 
675 {
676  H264ParseContext *p = s->priv_data;
677 
679  p->last_frame_num = INT_MAX;
680  ff_h264dsp_init(&p->h264dsp, 8, 1);
681  return 0;
682 }
683 
686  .priv_data_size = sizeof(H264ParseContext),
687  .parser_init = init,
688  .parser_parse = h264_parse,
689  .parser_close = h264_close,
690 };
MMCO_LONG2UNUSED
@ MMCO_LONG2UNUSED
Definition: h264_parse.h:62
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
H264SEIPictureTiming::pic_struct
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:60
H264ParseContext
Definition: h264_parser.c:53
MMCO_LONG
@ MMCO_LONG
Definition: h264_parse.h:66
H264ParamSets::sps
const SPS * sps
ordinary pointer, no RefStruct reference
Definition: h264_ps.h:150
ff_h264_sei_uninit
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:48
h2645_parse.h
H264POCContext::frame_num_offset
int frame_num_offset
for POC type 2
Definition: h264_parse.h:90
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
H264ParseContext::sei
H264SEIContext sei
Definition: h264_parser.c:58
ff_h264_ps_uninit
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:270
H264POCContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264_parse.h:85
H264ParseContext::parse_last_mb
int parse_last_mb
Definition: h264_parser.c:65
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:200
AV_PICTURE_STRUCTURE_UNKNOWN
@ AV_PICTURE_STRUCTURE_UNKNOWN
unknown
Definition: avcodec.h:2702
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
H264ParseContext::is_avc
int is_avc
Definition: h264_parser.c:59
H264SEIRecoveryPoint::recovery_frame_cnt
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:98
H264_SEI_PIC_STRUCT_TOP_BOTTOM
@ H264_SEI_PIC_STRUCT_TOP_BOTTOM
3: top field, bottom field, in that order
Definition: h264_sei.h:35
H264ParamSets::pps_list
const PPS * pps_list[MAX_PPS_COUNT]
RefStruct references.
Definition: h264_ps.h:146
H2645NAL::ref_idc
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:57
scan_mmco_reset
static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb, void *logctx)
Definition: h264_parser.c:171
h264_parse.h
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
H264ParseContext::parse_history
uint8_t parse_history[6]
Definition: h264_parser.c:63
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:32
ff_h264_pred_weight_table
int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, const int *ref_count, int slice_type_nos, H264PredWeightTable *pwt, int picture_structure, void *logctx)
Definition: h264_parse.c:30
H264ParseContext::picture_structure
int picture_structure
Definition: h264_parser.c:62
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
mpegutils.h
MMCOOpcode
MMCOOpcode
Memory management control operation opcode.
Definition: h264_parse.h:59
ParseContext::state
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
ParseContext::last_index
int last_index
Definition: parser.h:31
H264POCContext::prev_poc_lsb
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
Definition: h264_parse.h:89
H264ParseContext::got_first
int got_first
Definition: h264_parser.c:61
H264POCContext::delta_poc
int delta_poc[2]
Definition: h264_parse.h:86
H2645NAL::size_bits
int size_bits
Size, in bits, of just the data, excluding the stop bit and any trailing padding.
Definition: h2645_parse.h:42
ff_h264_decode_picture_parameter_set
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
Definition: h264_ps.c:696
MMCO_SET_MAX_LONG
@ MMCO_SET_MAX_LONG
Definition: h264_parse.h:64
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:201
ParseContext
Definition: parser.h:28
H264POCContext::prev_frame_num
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264_parse.h:92
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
H264ParseContext::h264dsp
H264DSPContext h264dsp
Definition: h264_parser.c:56
PPS::redundant_pic_cnt_present
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264_ps.h:125
fail
#define fail()
Definition: checkasm.h:183
PPS::weighted_bipred_idc
int weighted_bipred_idc
Definition: h264_ps.h:119
ff_h264_sei_decode
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:231
GetBitContext
Definition: get_bits.h:108
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:476
h264_close
static void h264_close(AVCodecParserContext *s)
Definition: h264_parser.c:663
H264SEIPictureTiming::present
int present
Definition: h264_sei.h:59
PPS::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264_ps.h:117
ff_h264_sei_process_picture_timing
int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, void *logctx)
Parse the contents of a picture timing message given an active SPS.
Definition: h264_sei.c:65
ff_h264_golomb_to_pict_type
const uint8_t ff_h264_golomb_to_pict_type[5]
Definition: h264data.c:37
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
parse_nal_units
static int parse_nal_units(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t *const buf, int buf_size)
Parse NAL units of found picture and decode some basic information.
Definition: h264_parser.c:257
refstruct.h
h264_parse
static int h264_parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
Definition: h264_parser.c:584
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
ParseContext::buffer
uint8_t * buffer
Definition: parser.h:29
AV_PICTURE_STRUCTURE_FRAME
@ AV_PICTURE_STRUCTURE_FRAME
coded as frame
Definition: avcodec.h:2705
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: defs.h:199
H2645NAL::size
int size
Definition: h2645_parse.h:36
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
H2645SEIFramePacking::arrangement_cancel_flag
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received (currently H.264 only)
Definition: h2645_sei.h:62
s
#define s(width, name)
Definition: cbs_vp9.c:198
H264POCContext::prev_frame_num_offset
int prev_frame_num_offset
for POC type 2
Definition: h264_parse.h:91
H264SEIBufferingPeriod::present
int present
Buffering period SEI flag.
Definition: h264_sei.h:102
ff_h264_decode_extradata
int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)
Definition: h264_parse.c:465
h264data.h
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:475
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:31
get_bits.h
H2645NAL::data
const uint8_t * data
Definition: h2645_parse.h:35
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
SPS::ref_frame_count
int ref_frame_count
num_ref_frames
Definition: h264_ps.h:57
if
if(ret)
Definition: filter_design.txt:179
AV_PICTURE_STRUCTURE_BOTTOM_FIELD
@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD
coded as bottom field
Definition: avcodec.h:2704
H264DSPContext::startcode_find_candidate
int(* startcode_find_candidate)(const uint8_t *buf, int size)
Search buf from the start for up to size bytes.
Definition: h264dsp.h:117
NULL
#define NULL
Definition: coverity.c:32
PPS::pic_order_present
int pic_order_present
bottom_field_pic_order_in_frame_present_flag
Definition: h264_ps.h:114
H264SEIPictureTiming::dpb_output_delay
int dpb_output_delay
dpb_output_delay in picture timing SEI message, see H.264 C.2.2
Definition: h264_sei.h:72
H264SEIContext::recovery_point
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:122
H264SEIContext
Definition: h264_sei.h:119
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
SPS
Sequence parameter set.
Definition: h264_ps.h:44
AV_PICTURE_STRUCTURE_TOP_FIELD
@ AV_PICTURE_STRUCTURE_TOP_FIELD
coded as top field
Definition: avcodec.h:2703
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
h264dsp.h
ParseContext::frame_start_found
int frame_start_found
Definition: parser.h:34
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
MAX_PPS_COUNT
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1784
h264_find_frame_end
static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf, int buf_size, void *logctx)
Definition: h264_parser.c:80
h264_ps.h
index
int index
Definition: gxfenc.c:90
error.h
H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM
@ H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM
6: bottom field, top field, bottom field repeated, in that order
Definition: h264_sei.h:38
H2645RBSP::rbsp_buffer
uint8_t * rbsp_buffer
Definition: h2645_parse.h:75
startcode.h
H264DSPContext
Context for storing H.264 DSP functions.
Definition: h264dsp.h:42
av_sat_sub64
#define av_sat_sub64
Definition: common.h:144
MMCO_END
@ MMCO_END
Definition: h264_parse.h:60
H2645SEI::frame_packing
H2645SEIFramePacking frame_packing
Definition: h2645_sei.h:130
AVCodecParser::codec_ids
int codec_ids[7]
Definition: avcodec.h:2868
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:551
PPS::weighted_pred
int weighted_pred
weighted_pred_flag
Definition: h264_ps.h:118
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
H264_SEI_PIC_STRUCT_BOTTOM_TOP
@ H264_SEI_PIC_STRUCT_BOTTOM_TOP
4: bottom field, top field, in that order
Definition: h264_sei.h:36
H2645NAL::gb
GetBitContext gb
Definition: h2645_parse.h:47
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
MMCO_SHORT2UNUSED
@ MMCO_SHORT2UNUSED
Definition: h264_parse.h:61
H264_MAX_MMCO_COUNT
@ H264_MAX_MMCO_COUNT
Definition: h264.h:92
H2645NAL
Definition: h2645_parse.h:34
MMCO_RESET
@ MMCO_RESET
Definition: h264_parse.h:65
H264ParseContext::parse_history_count
int parse_history_count
Definition: h264_parser.c:64
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
ff_h264_parser
const AVCodecParser ff_h264_parser
Definition: h264_parser.c:684
H264ParseContext::last_frame_num
int last_frame_num
Definition: h264_parser.c:67
mb
#define mb
Definition: vf_colormatrix.c:99
H264POCContext::frame_num
int frame_num
Definition: h264_parse.h:87
ff_combine_frame
int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
Combine the (truncated) bitstream to a complete frame.
Definition: parser.c:203
H264_SEI_PIC_STRUCT_FRAME
@ H264_SEI_PIC_STRUCT_FRAME
0: frame
Definition: h264_sei.h:32
H264_SEI_PIC_STRUCT_FRAME_TRIPLING
@ H264_SEI_PIC_STRUCT_FRAME_TRIPLING
8: frame tripling
Definition: h264_sei.h:40
h264_sei.h
ff_h264_decode_seq_parameter_set
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:284
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
log.h
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2742
MMCO_SHORT2LONG
@ MMCO_SHORT2LONG
Definition: h264_parse.h:63
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
H264_SEI_PIC_STRUCT_FRAME_DOUBLING
@ H264_SEI_PIC_STRUCT_FRAME_DOUBLING
7: frame doubling
Definition: h264_sei.h:39
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
ff_h2645_extract_rbsp
int ff_h2645_extract_rbsp(const uint8_t *src, int length, H2645RBSP *rbsp, H2645NAL *nal, int small_padding)
Extract the raw (unescaped) bitstream.
Definition: h2645_parse.c:35
H264POCContext
Definition: h264_parse.h:82
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:202
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:52
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
state
static struct @416 state
H2645SEIUnregistered::x264_build
int x264_build
Definition: h2645_sei.h:56
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
parser.h
ff_h264_parse_ref_count
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], GetBitContext *gb, const PPS *pps, int slice_type_nos, int picture_structure, void *logctx)
Definition: h264_parse.c:222
H264SEIContext::buffering_period
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:123
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
H264ParseContext::last_picture_structure
int last_picture_structure
Definition: h264_parser.c:67
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:477
H2645RBSP::rbsp_buffer_alloc_size
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:77
avcodec.h
H264SEIContext::common
H2645SEI common
Definition: h264_sei.h:120
AVCodecParserContext
Definition: avcodec.h:2708
ff_h264dsp_init
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
Definition: h264dsp.c:66
ret
ret
Definition: filter_design.txt:187
ff_h264_init_poc
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)
Definition: h264_parse.c:280
PPS::sps
const SPS * sps
RefStruct reference.
Definition: h264_ps.h:141
pixfmt.h
ff_h264_get_profile
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
Definition: h264_parse.c:532
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
av_sat_add64
#define av_sat_add64
Definition: common.h:141
U
#define U(x)
Definition: vpx_arith.h:37
H264_NAL_DPA
@ H264_NAL_DPA
Definition: h264.h:36
H2645SEI::unregistered
H2645SEIUnregistered unregistered
Definition: h2645_sei.h:129
AVCodecContext
main external API structure.
Definition: avcodec.h:445
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
find_start_code
static int find_start_code(const uint8_t *buf, int buf_size, int buf_index, int next_avc)
Definition: h264_parser.c:70
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
H264ParseContext::nal_length_size
int nal_length_size
Definition: h264_parser.c:60
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1640
H264ParamSets
Definition: h264_ps.h:144
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
H264PredWeightTable
Definition: h264_parse.h:69
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
avutil.h
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
init
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:674
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
H264_SEI_PIC_STRUCT_BOTTOM_FIELD
@ H264_SEI_PIC_STRUCT_BOTTOM_FIELD
2: bottom field
Definition: h264_sei.h:34
H264POCContext::poc_lsb
int poc_lsb
Definition: h264_parse.h:83
H264ParseContext::ps
H264ParamSets ps
Definition: h264_parser.c:55
H264ParseContext::poc
H264POCContext poc
Definition: h264_parser.c:57
END_NOT_FOUND
#define END_NOT_FOUND
Definition: parser.h:40
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecParser
Definition: avcodec.h:2867
H264SEIPictureTiming::cpb_removal_delay
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:77
h264.h
get_nalsize
static int get_nalsize(int nal_length_size, const uint8_t *buf, int buf_size, int *buf_index, void *logctx)
Definition: h2645_parse.h:119
H264ParseContext::reference_dts
int64_t reference_dts
Definition: h264_parser.c:66
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
H264POCContext::poc_msb
int poc_msb
Definition: h264_parse.h:84
H264ParamSets::pps
const PPS * pps
RefStruct reference.
Definition: h264_ps.h:149
PARSER_FLAG_ONCE
#define PARSER_FLAG_ONCE
Definition: avcodec.h:2743
H264POCContext::prev_poc_msb
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:88
H2645RBSP
Definition: h2645_parse.h:74
H264_SEI_PIC_STRUCT_TOP_FIELD
@ H264_SEI_PIC_STRUCT_TOP_FIELD
1: top field
Definition: h264_sei.h:33
H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP
@ H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP
5: top field, bottom field, top field repeated, in that order
Definition: h264_sei.h:37
H264ParseContext::pc
ParseContext pc
Definition: h264_parser.c:54
H264SEIContext::picture_timing
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:121
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40