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 <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 {
56  int is_avc;
58  int got_first;
60  uint8_t parse_history[6];
63  int64_t reference_dts;
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  int64_t 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 || nalsize > buf_size - i) {
91  av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal size %"PRId64" "
92  "remaining %d\n", nalsize, buf_size - i);
93  return buf_size;
94  }
95  next_avc = i + nalsize;
96  state = 5;
97  }
98 
99  if (state == 7) {
100  i += p->h264dsp.startcode_find_candidate(buf + i, next_avc - i);
101  if (i < next_avc)
102  state = 2;
103  } else if (state <= 2) {
104  if (buf[i] == 1)
105  state ^= 5; // 2->7, 1->4, 0->5
106  else if (buf[i])
107  state = 7;
108  else
109  state >>= 1; // 2->1, 1->0, 0->0
110  } else if (state <= 5) {
111  int nalu_type = buf[i] & 0x1F;
112  if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS ||
113  nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) {
114  if (pc->frame_start_found) {
115  i++;
116  goto found;
117  }
118  } else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA ||
119  nalu_type == H264_NAL_IDR_SLICE) {
120  state += 8;
121  continue;
122  }
123  state = 7;
124  } else {
125  unsigned int mb, last_mb = p->parse_last_mb;
126  GetBitContext gb;
127  p->parse_history[p->parse_history_count++] = buf[i];
128 
130  mb= get_ue_golomb_long(&gb);
131  if (get_bits_left(&gb) > 0 || p->parse_history_count > 5) {
132  p->parse_last_mb = mb;
133  if (pc->frame_start_found) {
134  if (mb <= last_mb) {
135  i -= p->parse_history_count - 1;
136  p->parse_history_count = 0;
137  goto found;
138  }
139  } else
140  pc->frame_start_found = 1;
141  p->parse_history_count = 0;
142  state = 7;
143  }
144  }
145  }
146  pc->state = state;
147  if (p->is_avc)
148  return next_avc;
149  return END_NOT_FOUND;
150 
151 found:
152  pc->state = 7;
153  pc->frame_start_found = 0;
154  if (p->is_avc)
155  return next_avc;
156  return i - (state & 5);
157 }
158 
160  void *logctx)
161 {
163  int slice_type_nos = s->pict_type & 3;
164  H264ParseContext *p = s->priv_data;
165  int list_count, ref_count[2];
166 
167 
169  get_ue_golomb(gb); // redundant_pic_count
170 
171  if (slice_type_nos == AV_PICTURE_TYPE_B)
172  get_bits1(gb); // direct_spatial_mv_pred
173 
174  if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps,
175  slice_type_nos, p->picture_structure, logctx) < 0)
176  return AVERROR_INVALIDDATA;
177 
178  if (slice_type_nos != AV_PICTURE_TYPE_I) {
179  int list;
180  for (list = 0; list < list_count; list++) {
181  if (get_bits1(gb)) {
182  int index;
183  for (index = 0; ; index++) {
184  unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb);
185 
186  if (reordering_of_pic_nums_idc < 3)
187  get_ue_golomb_long(gb);
188  else if (reordering_of_pic_nums_idc > 3) {
189  av_log(logctx, AV_LOG_ERROR,
190  "illegal reordering_of_pic_nums_idc %d\n",
191  reordering_of_pic_nums_idc);
192  return AVERROR_INVALIDDATA;
193  } else
194  break;
195 
196  if (index >= ref_count[list]) {
197  av_log(logctx, AV_LOG_ERROR,
198  "reference count %d overflow\n", index);
199  return AVERROR_INVALIDDATA;
200  }
201  }
202  }
203  }
204  }
205 
206  if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
207  (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))
208  ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,
209  &pwt, p->picture_structure, logctx);
210 
211  if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
212  int i;
213  for (i = 0; i < MAX_MMCO_COUNT; i++) {
214  MMCOOpcode opcode = get_ue_golomb_31(gb);
215  if (opcode > (unsigned) MMCO_LONG) {
216  av_log(logctx, AV_LOG_ERROR,
217  "illegal memory management control operation %d\n",
218  opcode);
219  return AVERROR_INVALIDDATA;
220  }
221  if (opcode == MMCO_END)
222  return 0;
223  else if (opcode == MMCO_RESET)
224  return 1;
225 
226  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)
227  get_ue_golomb_long(gb); // difference_of_pic_nums_minus1
228  if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
229  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)
230  get_ue_golomb_31(gb);
231  }
232  }
233 
234  return 0;
235 }
236 
237 /**
238  * Parse NAL units of found picture and decode some basic information.
239  *
240  * @param s parser context.
241  * @param avctx codec context.
242  * @param buf buffer with field/frame data.
243  * @param buf_size size of the buffer.
244  */
246  AVCodecContext *avctx,
247  const uint8_t * const buf, int buf_size)
248 {
249  H264ParseContext *p = s->priv_data;
250  H264Context *h = avctx->priv_data;
251  H2645RBSP rbsp = { NULL };
252  H2645NAL nal = { NULL };
253  int buf_index, next_avc;
254  unsigned int pps_id;
255  unsigned int slice_type;
256  int state = -1, got_reset = 0;
257  int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
258  int field_poc[2];
259  int ret;
260 
261  /* set some sane default values */
262  s->pict_type = AV_PICTURE_TYPE_I;
263  s->key_frame = 0;
264  s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
265 
266  ff_h264_sei_uninit(&p->sei);
268  p->sei.unregistered.x264_build = -1;
269 
270  if (!buf_size)
271  return 0;
272 
274  if (!rbsp.rbsp_buffer)
275  return AVERROR(ENOMEM);
276 
277  buf_index = 0;
278  next_avc = p->is_avc ? 0 : buf_size;
279  for (;;) {
280  const SPS *sps;
281  int src_length, consumed, nalsize = 0;
282 
283  if (buf_index >= next_avc) {
284  nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);
285  if (nalsize < 0)
286  break;
287  next_avc = buf_index + nalsize;
288  } else {
289  buf_index = find_start_code(buf, buf_size, buf_index, next_avc);
290  if (buf_index >= buf_size)
291  break;
292  if (buf_index >= next_avc)
293  continue;
294  }
295  src_length = next_avc - buf_index;
296 
297  state = buf[buf_index];
298  switch (state & 0x1f) {
299  case H264_NAL_SLICE:
300  case H264_NAL_IDR_SLICE:
301  // Do not walk the whole buffer just to decode slice header
302  if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {
303  /* IDR or disposable slice
304  * No need to decode many bytes because MMCOs shall not be present. */
305  if (src_length > 60)
306  src_length = 60;
307  } else {
308  /* To decode up to MMCOs */
309  if (src_length > 1000)
310  src_length = 1000;
311  }
312  break;
313  }
314  consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &rbsp, &nal, 1);
315  if (consumed < 0)
316  break;
317 
318  buf_index += consumed;
319 
320  ret = init_get_bits8(&nal.gb, nal.data, nal.size);
321  if (ret < 0)
322  goto fail;
323  get_bits1(&nal.gb);
324  nal.ref_idc = get_bits(&nal.gb, 2);
325  nal.type = get_bits(&nal.gb, 5);
326 
327  switch (nal.type) {
328  case H264_NAL_SPS:
329  ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);
330  break;
331  case H264_NAL_PPS:
332  ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,
333  nal.size_bits);
334  break;
335  case H264_NAL_SEI:
336  ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);
337  break;
338  case H264_NAL_IDR_SLICE:
339  s->key_frame = 1;
340 
341  p->poc.prev_frame_num = 0;
342  p->poc.prev_frame_num_offset = 0;
343  p->poc.prev_poc_msb =
344  p->poc.prev_poc_lsb = 0;
345  /* fall through */
346  case H264_NAL_SLICE:
347  get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice
348  slice_type = get_ue_golomb_31(&nal.gb);
349  s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
350  if (p->sei.recovery_point.recovery_frame_cnt >= 0) {
351  /* key frame, since recovery_frame_cnt is set */
352  s->key_frame = 1;
353  }
354  pps_id = get_ue_golomb(&nal.gb);
355  if (pps_id >= MAX_PPS_COUNT) {
356  av_log(avctx, AV_LOG_ERROR,
357  "pps_id %u out of range\n", pps_id);
358  goto fail;
359  }
360  if (!p->ps.pps_list[pps_id]) {
361  av_log(avctx, AV_LOG_ERROR,
362  "non-existing PPS %u referenced\n", pps_id);
363  goto fail;
364  }
365 
367  p->ps.pps = NULL;
368  p->ps.sps = NULL;
369  p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);
370  if (!p->ps.pps_ref)
371  goto fail;
372  p->ps.pps = (const PPS*)p->ps.pps_ref->data;
373  p->ps.sps = p->ps.pps->sps;
374  sps = p->ps.sps;
375 
376  // heuristic to detect non marked keyframes
377  if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
378  s->key_frame = 1;
379 
380  p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
381 
382  s->coded_width = 16 * sps->mb_width;
383  s->coded_height = 16 * sps->mb_height;
384  s->width = s->coded_width - (sps->crop_right + sps->crop_left);
385  s->height = s->coded_height - (sps->crop_top + sps->crop_bottom);
386  if (s->width <= 0 || s->height <= 0) {
387  s->width = s->coded_width;
388  s->height = s->coded_height;
389  }
390 
391  switch (sps->bit_depth_luma) {
392  case 9:
393  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9;
394  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;
395  else s->format = AV_PIX_FMT_YUV420P9;
396  break;
397  case 10:
398  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10;
399  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;
400  else s->format = AV_PIX_FMT_YUV420P10;
401  break;
402  case 8:
403  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P;
404  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;
405  else s->format = AV_PIX_FMT_YUV420P;
406  break;
407  default:
408  s->format = AV_PIX_FMT_NONE;
409  }
410 
411  avctx->profile = ff_h264_get_profile(sps);
412  avctx->level = sps->level_idc;
413 
414  if (sps->frame_mbs_only_flag) {
416  } else {
417  if (get_bits1(&nal.gb)) { // field_pic_flag
418  p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag
419  } else {
421  }
422  }
423 
424  if (nal.type == H264_NAL_IDR_SLICE)
425  get_ue_golomb_long(&nal.gb); /* idr_pic_id */
426  if (sps->poc_type == 0) {
427  p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
428 
429  if (p->ps.pps->pic_order_present == 1 &&
432  }
433 
434  if (sps->poc_type == 1 &&
435  !sps->delta_pic_order_always_zero_flag) {
436  p->poc.delta_poc[0] = get_se_golomb(&nal.gb);
437 
438  if (p->ps.pps->pic_order_present == 1 &&
440  p->poc.delta_poc[1] = get_se_golomb(&nal.gb);
441  }
442 
443  /* Decode POC of this picture.
444  * The prev_ values needed for decoding POC of the next picture are not set here. */
445  field_poc[0] = field_poc[1] = INT_MAX;
446  ret = ff_h264_init_poc(field_poc, &s->output_picture_number, sps,
447  &p->poc, p->picture_structure, nal.ref_idc);
448  if (ret < 0)
449  goto fail;
450 
451  /* Continue parsing to check if MMCO_RESET is present.
452  * FIXME: MMCO_RESET could appear in non-first slice.
453  * Maybe, we should parse all undisposable non-IDR slice of this
454  * picture until encountering MMCO_RESET in a slice of it. */
455  if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {
456  got_reset = scan_mmco_reset(s, &nal.gb, avctx);
457  if (got_reset < 0)
458  goto fail;
459  }
460 
461  /* Set up the prev_ values for decoding POC of the next picture. */
462  p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num;
463  p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;
464  if (nal.ref_idc != 0) {
465  if (!got_reset) {
466  p->poc.prev_poc_msb = p->poc.poc_msb;
467  p->poc.prev_poc_lsb = p->poc.poc_lsb;
468  } else {
469  p->poc.prev_poc_msb = 0;
470  p->poc.prev_poc_lsb =
471  p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];
472  }
473  }
474 
475  if (p->sei.picture_timing.present) {
477  sps, avctx);
478  if (ret < 0) {
479  av_log(avctx, AV_LOG_ERROR, "Error processing the picture timing SEI\n");
480  p->sei.picture_timing.present = 0;
481  }
482  }
483 
484  if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
485  switch (p->sei.picture_timing.pic_struct) {
488  s->repeat_pict = 0;
489  break;
493  s->repeat_pict = 1;
494  break;
497  s->repeat_pict = 2;
498  break;
500  s->repeat_pict = 3;
501  break;
503  s->repeat_pict = 5;
504  break;
505  default:
506  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
507  break;
508  }
509  } else {
510  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
511  }
512 
513  if (p->picture_structure == PICT_FRAME) {
514  s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
515  if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
516  switch (p->sei.picture_timing.pic_struct) {
519  s->field_order = AV_FIELD_TT;
520  break;
523  s->field_order = AV_FIELD_BB;
524  break;
525  default:
526  s->field_order = AV_FIELD_PROGRESSIVE;
527  break;
528  }
529  } else {
530  if (field_poc[0] < field_poc[1])
531  s->field_order = AV_FIELD_TT;
532  else if (field_poc[0] > field_poc[1])
533  s->field_order = AV_FIELD_BB;
534  else
535  s->field_order = AV_FIELD_PROGRESSIVE;
536  }
537  } else {
539  s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;
540  else
541  s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
542  if (p->poc.frame_num == p->last_frame_num &&
545  p->last_picture_structure != s->picture_structure) {
547  s->field_order = AV_FIELD_TT;
548  else
549  s->field_order = AV_FIELD_BB;
550  } else {
551  s->field_order = AV_FIELD_UNKNOWN;
552  }
553  p->last_picture_structure = s->picture_structure;
554  p->last_frame_num = p->poc.frame_num;
555  }
556  if (h && sps->timing_info_present_flag) {
557  int64_t den = sps->time_scale;
558  if (p->sei.unregistered.x264_build >= 0)
559  h->x264_build = p->sei.unregistered.x264_build;
560  if (h->x264_build < 44U)
561  den *= 2;
562  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
563  sps->num_units_in_tick * avctx->ticks_per_frame, den, 1 << 30);
564  }
565 
566  av_freep(&rbsp.rbsp_buffer);
567  return 0; /* no need to evaluate the rest */
568  }
569  }
570  if (q264) {
571  av_freep(&rbsp.rbsp_buffer);
572  return 0;
573  }
574  /* didn't find a picture! */
575  av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
576 fail:
577  av_freep(&rbsp.rbsp_buffer);
578  return -1;
579 }
580 
582  AVCodecContext *avctx,
583  const uint8_t **poutbuf, int *poutbuf_size,
584  const uint8_t *buf, int buf_size)
585 {
586  H264ParseContext *p = s->priv_data;
587  ParseContext *pc = &p->pc;
588  int next;
589 
590  if (!p->got_first) {
591  p->got_first = 1;
592  if (avctx->extradata_size) {
594  &p->ps, &p->is_avc, &p->nal_length_size,
595  avctx->err_recognition, avctx);
596  }
597  }
598 
599  if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
600  next = buf_size;
601  } else {
602  next = h264_find_frame_end(p, buf, buf_size, avctx);
603 
604  if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
605  *poutbuf = NULL;
606  *poutbuf_size = 0;
607  return buf_size;
608  }
609 
610  if (next < 0 && next != END_NOT_FOUND) {
611  av_assert1(pc->last_index + next >= 0);
612  h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state
613  }
614  }
615 
616  parse_nal_units(s, avctx, buf, buf_size);
617 
618  if (avctx->framerate.num)
619  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
620  if (p->sei.picture_timing.cpb_removal_delay >= 0) {
621  s->dts_sync_point = p->sei.buffering_period.present;
622  s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay;
623  s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay;
624  } else {
625  s->dts_sync_point = INT_MIN;
626  s->dts_ref_dts_delta = INT_MIN;
627  s->pts_dts_delta = INT_MIN;
628  }
629 
630  if (s->flags & PARSER_FLAG_ONCE) {
631  s->flags &= PARSER_FLAG_COMPLETE_FRAMES;
632  }
633 
634  if (s->dts_sync_point >= 0) {
635  int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num;
636  if (den > 0) {
637  int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den;
638  if (s->dts != AV_NOPTS_VALUE) {
639  // got DTS from the stream, update reference timestamp
640  p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den);
641  } else if (p->reference_dts != AV_NOPTS_VALUE) {
642  // compute DTS based on reference timestamp
643  s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den);
644  }
645 
646  if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE)
647  s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den);
648 
649  if (s->dts_sync_point > 0)
650  p->reference_dts = s->dts; // new reference
651  }
652  }
653 
654  *poutbuf = buf;
655  *poutbuf_size = buf_size;
656  return next;
657 }
658 
660 {
661  H264ParseContext *p = s->priv_data;
662  ParseContext *pc = &p->pc;
663 
664  av_freep(&pc->buffer);
665 
666  ff_h264_sei_uninit(&p->sei);
667  ff_h264_ps_uninit(&p->ps);
668 }
669 
671 {
672  H264ParseContext *p = s->priv_data;
673 
675  p->last_frame_num = INT_MAX;
676  ff_h264dsp_init(&p->h264dsp, 8, 1);
677  return 0;
678 }
679 
682  .priv_data_size = sizeof(H264ParseContext),
683  .parser_init = init,
684  .parser_parse = h264_parse,
685  .parser_close = h264_close,
686 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
H264SEIPictureTiming::pic_struct
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:72
H264ParseContext
Definition: h264_parser.c:50
MMCO_RESET
@ MMCO_RESET
Definition: h264dec.h:117
H264ParamSets::sps
const SPS * sps
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
H264POCContext::frame_num_offset
int frame_num_offset
for POC type 2
Definition: h264_parse.h:51
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
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:55
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
ff_h264_ps_uninit
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:317
H264POCContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264_parse.h:46
H264ParseContext::parse_last_mb
int parse_last_mb
Definition: h264_parser.c:62
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_PICTURE_STRUCTURE_UNKNOWN
@ AV_PICTURE_STRUCTURE_UNKNOWN
Definition: avcodec.h:2769
find_start_code
static int find_start_code(const uint8_t *buf, int buf_size, int buf_index, int next_avc)
Definition: h264dec.h:836
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1324
H264ParseContext::is_avc
int is_avc
Definition: h264_parser.c:56
H264SEIRecoveryPoint::recovery_frame_cnt
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:125
H264_SEI_PIC_STRUCT_TOP_BOTTOM
@ H264_SEI_PIC_STRUCT_TOP_BOTTOM
3: top field, bottom field, in that order
Definition: h264_sei.h:34
H2645NAL::ref_idc
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:72
scan_mmco_reset
static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb, void *logctx)
Definition: h264_parser.c:159
index
fg index
Definition: ffmpeg_filter.c:168
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:55
internal.h
H264ParseContext::parse_history
uint8_t parse_history[6]
Definition: h264_parser.c:60
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:391
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
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:27
H264ParseContext::picture_structure
int picture_structure
Definition: h264_parser.c:59
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
mpegutils.h
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:660
ParseContext::last_index
int last_index
Definition: parser.h:31
MMCO_LONG
@ MMCO_LONG
Definition: h264dec.h:118
H264POCContext::prev_poc_lsb
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
Definition: h264_parse.h:50
H264ParseContext::got_first
int got_first
Definition: h264_parser.c:58
H264POCContext::delta_poc
int delta_poc[2]
Definition: h264_parse.h:47
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:44
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:749
state
static struct @319 state
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1710
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:380
ParseContext
Definition: parser.h:28
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:39
H264POCContext::prev_frame_num
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264_parse.h:53
H264ParseContext::h264dsp
H264DSPContext h264dsp
Definition: h264_parser.c:53
U
#define U(x)
Definition: vp56_arith.h:37
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:127
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:463
GetBitContext
Definition: get_bits.h:62
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:389
h264_close
static void h264_close(AVCodecParserContext *s)
Definition: h264_parser.c:659
H264SEIPictureTiming::present
int present
Definition: h264_sei.h:71
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:69
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:245
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:581
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:394
ParseContext::buffer
uint8_t * buffer
Definition: parser.h:29
AV_PICTURE_STRUCTURE_FRAME
@ AV_PICTURE_STRUCTURE_FRAME
Definition: avcodec.h:2772
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:678
H2645NAL::size
int size
Definition: h2645_parse.h:37
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
s
#define s(width, name)
Definition: cbs_vp9.c:257
H264SEIFramePacking::arrangement_cancel_flag
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:136
H264POCContext::prev_frame_num_offset
int prev_frame_num_offset
for POC type 2
Definition: h264_parse.h:52
H264SEIBufferingPeriod::present
int present
Buffering period SEI flag.
Definition: h264_sei.h:129
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:462
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:515
h264data.h
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:388
MMCO_SHORT2LONG
@ MMCO_SHORT2LONG
Definition: h264dec.h:115
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
get_bits.h
H2645NAL::data
const uint8_t * data
Definition: h2645_parse.h:38
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:66
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:241
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:54
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
Definition: avcodec.h:2771
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
pic_order_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:84
H264SEIContext::recovery_point
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:194
H264SEIContext
Definition: h264_sei.h:189
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
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
Definition: avcodec.h:2770
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
PPS
Picture parameter set.
Definition: h264_ps.h:111
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
MAX_PPS_COUNT
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:392
AVCodecContext::level
int level
level
Definition: avcodec.h:1651
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:68
h264_ps.h
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
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:37
H2645RBSP::rbsp_buffer
uint8_t * rbsp_buffer
Definition: h2645_parse.h:76
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:506
H264DSPContext
Context for storing H.264 DSP functions.
Definition: h264dsp.h:42
H264SEIContext::frame_packing
H264SEIFramePacking frame_packing
Definition: h264_sei.h:196
AVCodecParser::codec_ids
int codec_ids[7]
Definition: avcodec.h:2935
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
MMCO_LONG2UNUSED
@ MMCO_LONG2UNUSED
Definition: h264dec.h:114
H264SEIUnregistered::x264_build
int x264_build
Definition: h264_sei.h:112
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1724
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:35
H2645NAL::gb
GetBitContext gb
Definition: h2645_parse.h:49
MMCOOpcode
MMCOOpcode
Memory management control operation opcode.
Definition: h264dec.h:111
H2645NAL
Definition: h2645_parse.h:34
H264ParseContext::parse_history_count
int parse_history_count
Definition: h264_parser.c:61
ff_h264_parser
const AVCodecParser ff_h264_parser
Definition: h264_parser.c:680
H264ParseContext::last_frame_num
int last_frame_num
Definition: h264_parser.c:64
MMCO_SET_MAX_LONG
@ MMCO_SET_MAX_LONG
Definition: h264dec.h:116
mb
#define mb
Definition: vf_colormatrix.c:101
H264POCContext::frame_num
int frame_num
Definition: h264_parse.h:48
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:201
H264_SEI_PIC_STRUCT_FRAME
@ H264_SEI_PIC_STRUCT_FRAME
0: frame
Definition: h264_sei.h:31
H264_SEI_PIC_STRUCT_FRAME_TRIPLING
@ H264_SEI_PIC_STRUCT_FRAME_TRIPLING
8: frame tripling
Definition: h264_sei.h:39
AV_FIELD_BB
@ AV_FIELD_BB
Definition: codec_par.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:333
H264Context
H264Context.
Definition: h264dec.h:350
log.h
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2809
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
H264_SEI_PIC_STRUCT_FRAME_DOUBLING
@ H264_SEI_PIC_STRUCT_FRAME_DOUBLING
7: frame doubling
Definition: h264_sei.h:38
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:484
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:34
H264POCContext
Definition: h264_parse.h:43
H264_NAL_DPA
@ H264_NAL_DPA
Definition: h264.h:36
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
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:50
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:219
H264SEIContext::buffering_period
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:195
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:128
H264ParseContext::last_picture_structure
int last_picture_structure
Definition: h264_parser.c:64
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:390
H2645RBSP::rbsp_buffer_alloc_size
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:78
avcodec.h
AVCodecParserContext
Definition: avcodec.h:2775
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
MMCO_END
@ MMCO_END
Definition: h264dec.h:112
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:277
PPS::sps
const SPS * sps
Definition: h264_ps.h:140
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:529
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
AVCodecContext
main external API structure.
Definition: avcodec.h:383
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:122
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
H264ParamSets::pps_list
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:145
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
H264ParseContext::nal_length_size
int nal_length_size
Definition: h264_parser.c:57
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1525
H264ParamSets
Definition: h264_ps.h:143
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
H264PredWeightTable
Definition: h264_parse.h:30
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:71
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
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:70
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
mem.h
init
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:670
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:106
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
H264_SEI_PIC_STRUCT_BOTTOM_FIELD
@ H264_SEI_PIC_STRUCT_BOTTOM_FIELD
2: bottom field
Definition: h264_sei.h:33
H264POCContext::poc_lsb
int poc_lsb
Definition: h264_parse.h:44
H264ParseContext::ps
H264ParamSets ps
Definition: h264_parser.c:52
H264ParseContext::poc
H264POCContext poc
Definition: h264_parser.c:54
END_NOT_FOUND
#define END_NOT_FOUND
Definition: parser.h:40
MMCO_SHORT2UNUSED
@ MMCO_SHORT2UNUSED
Definition: h264dec.h:113
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecParser
Definition: avcodec.h:2934
H264SEIContext::unregistered
H264SEIUnregistered unregistered
Definition: h264_sei.h:193
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:89
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:120
H264ParseContext::reference_dts
int64_t reference_dts
Definition: h264_parser.c:63
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
H264POCContext::poc_msb
int poc_msb
Definition: h264_parse.h:45
H264ParamSets::pps
const PPS * pps
Definition: h264_ps.h:149
MAX_MMCO_COUNT
#define MAX_MMCO_COUNT
Definition: h264dec.h:56
PARSER_FLAG_ONCE
#define PARSER_FLAG_ONCE
Definition: avcodec.h:2810
H264POCContext::prev_poc_msb
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:49
H2645RBSP
Definition: h2645_parse.h:75
H264_SEI_PIC_STRUCT_TOP_FIELD
@ H264_SEI_PIC_STRUCT_TOP_FIELD
1: top field
Definition: h264_sei.h:32
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:36
H264ParseContext::pc
ParseContext pc
Definition: h264_parser.c:51
H264ParamSets::pps_ref
AVBufferRef * pps_ref
Definition: h264_ps.h:147
H264SEIContext::picture_timing
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:190