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