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  H2645RBSP rbsp = { NULL };
251  H2645NAL nal = { NULL };
252  int buf_index, next_avc;
253  unsigned int pps_id;
254  unsigned int slice_type;
255  int state = -1, got_reset = 0;
256  int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
257  int field_poc[2];
258  int ret;
259 
260  /* set some sane default values */
261  s->pict_type = AV_PICTURE_TYPE_I;
262  s->key_frame = 0;
263  s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
264 
265  ff_h264_sei_uninit(&p->sei);
267  p->sei.unregistered.x264_build = -1;
268 
269  if (!buf_size)
270  return 0;
271 
273  if (!rbsp.rbsp_buffer)
274  return AVERROR(ENOMEM);
275 
276  buf_index = 0;
277  next_avc = p->is_avc ? 0 : buf_size;
278  for (;;) {
279  const SPS *sps;
280  int src_length, consumed, nalsize = 0;
281 
282  if (buf_index >= next_avc) {
283  nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);
284  if (nalsize < 0)
285  break;
286  next_avc = buf_index + nalsize;
287  } else {
288  buf_index = find_start_code(buf, buf_size, buf_index, next_avc);
289  if (buf_index >= buf_size)
290  break;
291  if (buf_index >= next_avc)
292  continue;
293  }
294  src_length = next_avc - buf_index;
295 
296  state = buf[buf_index];
297  switch (state & 0x1f) {
298  case H264_NAL_SLICE:
299  case H264_NAL_IDR_SLICE:
300  // Do not walk the whole buffer just to decode slice header
301  if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {
302  /* IDR or disposable slice
303  * No need to decode many bytes because MMCOs shall not be present. */
304  if (src_length > 60)
305  src_length = 60;
306  } else {
307  /* To decode up to MMCOs */
308  if (src_length > 1000)
309  src_length = 1000;
310  }
311  break;
312  }
313  consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &rbsp, &nal, 1);
314  if (consumed < 0)
315  break;
316 
317  buf_index += consumed;
318 
319  ret = init_get_bits8(&nal.gb, nal.data, nal.size);
320  if (ret < 0)
321  goto fail;
322  get_bits1(&nal.gb);
323  nal.ref_idc = get_bits(&nal.gb, 2);
324  nal.type = get_bits(&nal.gb, 5);
325 
326  switch (nal.type) {
327  case H264_NAL_SPS:
328  ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);
329  break;
330  case H264_NAL_PPS:
331  ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,
332  nal.size_bits);
333  break;
334  case H264_NAL_SEI:
335  ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);
336  break;
337  case H264_NAL_IDR_SLICE:
338  s->key_frame = 1;
339 
340  p->poc.prev_frame_num = 0;
341  p->poc.prev_frame_num_offset = 0;
342  p->poc.prev_poc_msb =
343  p->poc.prev_poc_lsb = 0;
344  /* fall through */
345  case H264_NAL_SLICE:
346  get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice
347  slice_type = get_ue_golomb_31(&nal.gb);
348  s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
349  if (p->sei.recovery_point.recovery_frame_cnt >= 0) {
350  /* key frame, since recovery_frame_cnt is set */
351  s->key_frame = 1;
352  }
353  pps_id = get_ue_golomb(&nal.gb);
354  if (pps_id >= MAX_PPS_COUNT) {
355  av_log(avctx, AV_LOG_ERROR,
356  "pps_id %u out of range\n", pps_id);
357  goto fail;
358  }
359  if (!p->ps.pps_list[pps_id]) {
360  av_log(avctx, AV_LOG_ERROR,
361  "non-existing PPS %u referenced\n", pps_id);
362  goto fail;
363  }
364 
366  p->ps.pps = NULL;
367  p->ps.sps = NULL;
368  p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);
369  if (!p->ps.pps_ref)
370  goto fail;
371  p->ps.pps = (const PPS*)p->ps.pps_ref->data;
372  p->ps.sps = p->ps.pps->sps;
373  sps = p->ps.sps;
374 
375  // heuristic to detect non marked keyframes
376  if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
377  s->key_frame = 1;
378 
379  p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
380 
381  s->coded_width = 16 * sps->mb_width;
382  s->coded_height = 16 * sps->mb_height;
383  s->width = s->coded_width - (sps->crop_right + sps->crop_left);
384  s->height = s->coded_height - (sps->crop_top + sps->crop_bottom);
385  if (s->width <= 0 || s->height <= 0) {
386  s->width = s->coded_width;
387  s->height = s->coded_height;
388  }
389 
390  switch (sps->bit_depth_luma) {
391  case 9:
392  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9;
393  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;
394  else s->format = AV_PIX_FMT_YUV420P9;
395  break;
396  case 10:
397  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10;
398  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;
399  else s->format = AV_PIX_FMT_YUV420P10;
400  break;
401  case 8:
402  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P;
403  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;
404  else s->format = AV_PIX_FMT_YUV420P;
405  break;
406  default:
407  s->format = AV_PIX_FMT_NONE;
408  }
409 
410  avctx->profile = ff_h264_get_profile(sps);
411  avctx->level = sps->level_idc;
412 
413  if (sps->frame_mbs_only_flag) {
415  } else {
416  if (get_bits1(&nal.gb)) { // field_pic_flag
417  p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag
418  } else {
420  }
421  }
422 
423  if (nal.type == H264_NAL_IDR_SLICE)
424  get_ue_golomb_long(&nal.gb); /* idr_pic_id */
425  if (sps->poc_type == 0) {
426  p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
427 
428  if (p->ps.pps->pic_order_present == 1 &&
431  }
432 
433  if (sps->poc_type == 1 &&
434  !sps->delta_pic_order_always_zero_flag) {
435  p->poc.delta_poc[0] = get_se_golomb(&nal.gb);
436 
437  if (p->ps.pps->pic_order_present == 1 &&
439  p->poc.delta_poc[1] = get_se_golomb(&nal.gb);
440  }
441 
442  /* Decode POC of this picture.
443  * The prev_ values needed for decoding POC of the next picture are not set here. */
444  field_poc[0] = field_poc[1] = INT_MAX;
445  ret = ff_h264_init_poc(field_poc, &s->output_picture_number, sps,
446  &p->poc, p->picture_structure, nal.ref_idc);
447  if (ret < 0)
448  goto fail;
449 
450  /* Continue parsing to check if MMCO_RESET is present.
451  * FIXME: MMCO_RESET could appear in non-first slice.
452  * Maybe, we should parse all undisposable non-IDR slice of this
453  * picture until encountering MMCO_RESET in a slice of it. */
454  if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {
455  got_reset = scan_mmco_reset(s, &nal.gb, avctx);
456  if (got_reset < 0)
457  goto fail;
458  }
459 
460  /* Set up the prev_ values for decoding POC of the next picture. */
461  p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num;
462  p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;
463  if (nal.ref_idc != 0) {
464  if (!got_reset) {
465  p->poc.prev_poc_msb = p->poc.poc_msb;
466  p->poc.prev_poc_lsb = p->poc.poc_lsb;
467  } else {
468  p->poc.prev_poc_msb = 0;
469  p->poc.prev_poc_lsb =
470  p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];
471  }
472  }
473 
474  if (p->sei.picture_timing.present) {
476  sps, avctx);
477  if (ret < 0) {
478  av_log(avctx, AV_LOG_ERROR, "Error processing the picture timing SEI\n");
479  p->sei.picture_timing.present = 0;
480  }
481  }
482 
483  if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
484  switch (p->sei.picture_timing.pic_struct) {
487  s->repeat_pict = 0;
488  break;
492  s->repeat_pict = 1;
493  break;
496  s->repeat_pict = 2;
497  break;
499  s->repeat_pict = 3;
500  break;
502  s->repeat_pict = 5;
503  break;
504  default:
505  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
506  break;
507  }
508  } else {
509  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
510  }
511 
512  if (p->picture_structure == PICT_FRAME) {
513  s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
514  if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
515  switch (p->sei.picture_timing.pic_struct) {
518  s->field_order = AV_FIELD_TT;
519  break;
522  s->field_order = AV_FIELD_BB;
523  break;
524  default:
525  s->field_order = AV_FIELD_PROGRESSIVE;
526  break;
527  }
528  } else {
529  if (field_poc[0] < field_poc[1])
530  s->field_order = AV_FIELD_TT;
531  else if (field_poc[0] > field_poc[1])
532  s->field_order = AV_FIELD_BB;
533  else
534  s->field_order = AV_FIELD_PROGRESSIVE;
535  }
536  } else {
538  s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;
539  else
540  s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
541  if (p->poc.frame_num == p->last_frame_num &&
544  p->last_picture_structure != s->picture_structure) {
546  s->field_order = AV_FIELD_TT;
547  else
548  s->field_order = AV_FIELD_BB;
549  } else {
550  s->field_order = AV_FIELD_UNKNOWN;
551  }
552  p->last_picture_structure = s->picture_structure;
553  p->last_frame_num = p->poc.frame_num;
554  }
555  if (sps->timing_info_present_flag) {
556  int64_t den = sps->time_scale;
557  if (p->sei.unregistered.x264_build < 44U)
558  den *= 2;
559  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
560  sps->num_units_in_tick * avctx->ticks_per_frame, den, 1 << 30);
561  }
562 
563  av_freep(&rbsp.rbsp_buffer);
564  return 0; /* no need to evaluate the rest */
565  }
566  }
567  if (q264) {
568  av_freep(&rbsp.rbsp_buffer);
569  return 0;
570  }
571  /* didn't find a picture! */
572  av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
573 fail:
574  av_freep(&rbsp.rbsp_buffer);
575  return -1;
576 }
577 
579  AVCodecContext *avctx,
580  const uint8_t **poutbuf, int *poutbuf_size,
581  const uint8_t *buf, int buf_size)
582 {
583  H264ParseContext *p = s->priv_data;
584  ParseContext *pc = &p->pc;
585  int next;
586 
587  if (!p->got_first) {
588  p->got_first = 1;
589  if (avctx->extradata_size) {
591  &p->ps, &p->is_avc, &p->nal_length_size,
592  avctx->err_recognition, avctx);
593  }
594  }
595 
596  if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
597  next = buf_size;
598  } else {
599  next = h264_find_frame_end(p, buf, buf_size, avctx);
600 
601  if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
602  *poutbuf = NULL;
603  *poutbuf_size = 0;
604  return buf_size;
605  }
606 
607  if (next < 0 && next != END_NOT_FOUND) {
608  av_assert1(pc->last_index + next >= 0);
609  h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state
610  }
611  }
612 
613  parse_nal_units(s, avctx, buf, buf_size);
614 
615  if (avctx->framerate.num)
616  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
617  if (p->sei.picture_timing.cpb_removal_delay >= 0) {
618  s->dts_sync_point = p->sei.buffering_period.present;
619  s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay;
620  s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay;
621  } else {
622  s->dts_sync_point = INT_MIN;
623  s->dts_ref_dts_delta = INT_MIN;
624  s->pts_dts_delta = INT_MIN;
625  }
626 
627  if (s->flags & PARSER_FLAG_ONCE) {
628  s->flags &= PARSER_FLAG_COMPLETE_FRAMES;
629  }
630 
631  if (s->dts_sync_point >= 0) {
632  int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num;
633  if (den > 0) {
634  int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den;
635  if (s->dts != AV_NOPTS_VALUE) {
636  // got DTS from the stream, update reference timestamp
637  p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den);
638  } else if (p->reference_dts != AV_NOPTS_VALUE) {
639  // compute DTS based on reference timestamp
640  s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den);
641  }
642 
643  if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE)
644  s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den);
645 
646  if (s->dts_sync_point > 0)
647  p->reference_dts = s->dts; // new reference
648  }
649  }
650 
651  *poutbuf = buf;
652  *poutbuf_size = buf_size;
653  return next;
654 }
655 
657 {
658  H264ParseContext *p = s->priv_data;
659  ParseContext *pc = &p->pc;
660 
661  av_freep(&pc->buffer);
662 
663  ff_h264_sei_uninit(&p->sei);
664  ff_h264_ps_uninit(&p->ps);
665 }
666 
668 {
669  H264ParseContext *p = s->priv_data;
670 
672  p->last_frame_num = INT_MAX;
673  ff_h264dsp_init(&p->h264dsp, 8, 1);
674  return 0;
675 }
676 
679  .priv_data_size = sizeof(H264ParseContext),
680  .parser_init = init,
681  .parser_parse = h264_parse,
682  .parser_close = h264_close,
683 };
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
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
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
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
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
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:57
H264_NAL_DPA
@ H264_NAL_DPA
Definition: h264.h:36
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:167
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:404
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
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: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:749
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:402
h264_close
static void h264_close(AVCodecParserContext *s)
Definition: h264_parser.c:656
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:578
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:407
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
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
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:36
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:401
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: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: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: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
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:405
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
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:75
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
state
static struct @320 state
AVCodecParser::codec_ids
int codec_ids[7]
Definition: avcodec.h:2935
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:47
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:677
H264ParseContext::last_frame_num
int last_frame_num
Definition: h264_parser.c:64
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
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
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_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
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
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
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
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:403
H2645RBSP::rbsp_buffer_alloc_size
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:77
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
mem.h
init
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:667
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
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
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:119
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
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:74
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