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