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;
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 */
261  s->key_frame = 0;
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 &&
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 
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) {
513  switch (p->sei.picture_timing.pic_struct) {
517  break;
521  break;
522  default:
524  break;
525  }
526  } else {
527  if (field_poc[0] < field_poc[1])
529  else if (field_poc[0] > field_poc[1])
531  else
533  }
534  } else {
537  else
539  if (p->poc.frame_num == p->last_frame_num &&
545  else
547  } else {
549  }
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 
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) {
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) {
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 
647 static int h264_split(AVCodecContext *avctx,
648  const uint8_t *buf, int buf_size)
649 {
650  uint32_t state = -1;
651  int has_sps = 0;
652  int has_pps = 0;
653  const uint8_t *ptr = buf, *end = buf + buf_size;
654  int nalu_type;
655 
656  while (ptr < end) {
657  ptr = avpriv_find_start_code(ptr, end, &state);
658  if ((state & 0xFFFFFF00) != 0x100)
659  break;
660  nalu_type = state & 0x1F;
661  if (nalu_type == H264_NAL_SPS) {
662  has_sps = 1;
663  } else if (nalu_type == H264_NAL_PPS)
664  has_pps = 1;
665  /* else if (nalu_type == 0x01 ||
666  * nalu_type == 0x02 ||
667  * nalu_type == 0x05) {
668  * }
669  */
670  else if ((nalu_type != H264_NAL_SEI || has_pps) &&
671  nalu_type != H264_NAL_AUD && nalu_type != H264_NAL_SPS_EXT &&
672  nalu_type != 0x0f) {
673  if (has_sps) {
674  while (ptr - 4 > buf && ptr[-5] == 0)
675  ptr--;
676  return ptr - 4 - buf;
677  }
678  }
679  }
680 
681  return 0;
682 }
683 
685 {
686  H264ParseContext *p = s->priv_data;
687  ParseContext *pc = &p->pc;
688 
689  av_freep(&pc->buffer);
690 
691  ff_h264_sei_uninit(&p->sei);
692  ff_h264_ps_uninit(&p->ps);
693 }
694 
696 {
697  H264ParseContext *p = s->priv_data;
698 
700  p->last_frame_num = INT_MAX;
701  ff_h264dsp_init(&p->h264dsp, 8, 1);
702  return 0;
703 }
704 
707  .priv_data_size = sizeof(H264ParseContext),
708  .parser_init = init,
709  .parser_parse = h264_parse,
710  .parser_close = h264_close,
711  .split = h264_split,
712 };
int chroma_format_idc
Definition: h264_ps.h:48
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
Definition: h264_ps.c:749
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2081
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:141
int size
Definition: h2645_parse.h:35
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:241
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
int weighted_bipred_idc
Definition: h264_ps.h:119
Memory handling functions.
int last_picture_structure
Definition: h264_parser.c:64
ParseContext pc
Definition: h264_parser.c:51
int width
Dimensions of the decoded video intended for presentation.
Definition: avcodec.h:3512
Sequence parameter set.
Definition: h264_ps.h:44
uint8_t parse_history[6]
Definition: h264_parser.c:60
enum AVFieldOrder field_order
Definition: avcodec.h:3489
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264_ps.h:117
int num
Numerator.
Definition: rational.h:59
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
int codec_ids[5]
Definition: avcodec.h:3533
Picture parameter set.
Definition: h264_ps.h:111
int coded_width
Dimensions of the coded video.
Definition: avcodec.h:3518
Convenience header that includes libavutil&#39;s core.
int frame_mbs_only_flag
Definition: h264_ps.h:62
static int find_start_code(const uint8_t *buf, int buf_size, int buf_index, int next_avc)
Definition: h264dec.h:822
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:72
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:42
H264DSPContext h264dsp
Definition: h264_parser.c:53
int dts_ref_dts_delta
Offset of the current timestamp against last timestamp sync point in units of AVCodecContext.time_base.
Definition: avcodec.h:3449
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
int profile
profile
Definition: avcodec.h:1871
int frame_start_found
Definition: parser.h:34
int size_bits
Size, in bits, of just the data, excluding the stop bit and any trailing padding. ...
Definition: h2645_parse.h:42
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:654
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
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264_ps.h:70
const PPS * pps
Definition: h264_ps.h:149
enum AVPictureStructure picture_structure
Indicate whether a picture is coded as a frame, top field or bottom field.
Definition: avcodec.h:3499
4: bottom field, top field, in that order
Definition: h264_sei.h:51
uint8_t
#define av_cold
Definition: attributes.h:88
#define mb
unsigned int crop_left
frame_cropping_rect_left_offset
Definition: h264_ps.h:68
int frame_num_offset
for POC type 2
Definition: h264_parse.h:51
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264_ps.h:69
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
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
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264_ps.h:125
bitstream reader API header.
int(* startcode_find_candidate)(const uint8_t *buf, int size)
Search buf from the start for up to size bytes.
Definition: h264dsp.h:117
#define av_log(a,...)
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
H.264 common definitions.
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2095
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
H.264 parameter set handling.
H264POCContext poc
Definition: h264_parser.c:54
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
error code definitions
int poc_type
pic_order_cnt_type
Definition: h264_ps.h:51
H264ParamSets ps
Definition: h264_parser.c:52
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:234
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
Definition: h264_parse.c:529
int present
Buffering period SEI flag.
Definition: h264_sei.h:145
int weighted_pred
weighted_pred_flag
Definition: h264_ps.h:118
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
const uint8_t ff_h264_golomb_to_pict_type[5]
Definition: h264data.c:37
MMCOOpcode
Memory management control operation opcode.
Definition: h264dec.h:109
#define fail()
Definition: checkasm.h:123
int delta_pic_order_always_zero_flag
Definition: h264_ps.h:53
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
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
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:49
Context for storing H.264 DSP functions.
Definition: h264dsp.h:42
int ref_frame_count
num_ref_frames
Definition: h264_ps.h:57
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:88
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1660
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
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
int last_index
Definition: parser.h:31
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:1994
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
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:105
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:70
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
int type
NAL unit type.
Definition: h2645_parse.h:52
AVCodecParser ff_h264_parser
Definition: h264_parser.c:705
if(ret)
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
int pic_order_present
pic_order_present_flag
Definition: h264_ps.h:114
static void h264_close(AVCodecParserContext *s)
Definition: h264_parser.c:684
int pts_dts_delta
Presentation delay of current frame in units of AVCodecContext.time_base.
Definition: avcodec.h:3463
uint8_t * buffer
Definition: parser.h:29
5: top field, bottom field, top field repeated, in that order
Definition: h264_sei.h:52
Libavcodec external API header.
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:145
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:122
int delta_poc_bottom
Definition: h264_parse.h:46
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:531
H264SEIContext sei
Definition: h264_parser.c:55
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
uint8_t * data
The data buffer.
Definition: buffer.h:89
const uint8_t * data
Definition: h2645_parse.h:36
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
int extradata_size
Definition: avcodec.h:633
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:76
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264_parse.h:53
static int h264_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: h264_parser.c:647
int index
Definition: gxfenc.c:89
Rational number (pair of numerator and denominator).
Definition: rational.h:58
uint8_t * rbsp_buffer
Definition: h2645_parse.h:74
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:190
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
const SPS * sps
Definition: h264_ps.h:150
#define END_NOT_FOUND
Definition: parser.h:40
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:185
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264_ps.h:52
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:189
3: top field, bottom field, in that order
Definition: h264_sei.h:50
int output_picture_number
Picture number incremented in presentation or output order.
Definition: avcodec.h:3507
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
int pic_struct_present_flag
Definition: h264_ps.h:94
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
Definition: h264_parse.h:50
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
#define PARSER_FLAG_ONCE
Definition: avcodec.h:3400
int mb_height
Definition: h264_ps.h:61
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
common internal api header.
static struct @323 state
int dpb_output_delay
dpb_output_delay in picture timing SEI message, see H.264 C.2.2
Definition: h264_sei.h:100
AVBufferRef * pps_ref
Definition: h264_ps.h:147
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
H264SEIFramePacking frame_packing
Definition: h264_sei.h:191
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
Bi-dir predicted.
Definition: avutil.h:276
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:3399
int den
Denominator.
Definition: rational.h:60
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:317
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:695
GetBitContext gb
Definition: h2645_parse.h:47
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264_ps.h:100
int delta_poc[2]
Definition: h264_parse.h:47
#define PICT_FRAME
Definition: mpegutils.h:39
static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf, int buf_size, void *logctx)
Definition: h264_parser.c:68
pixel format definitions
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:333
int format
The format of the coded data, corresponds to enum AVPixelFormat for video and for enum AVSampleFormat...
Definition: avcodec.h:3529
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
int mb_width
pic_width_in_mbs_minus1 + 1
Definition: h264_ps.h:59
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
Definition: h264dsp.c:67
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:3383
#define av_freep(p)
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:387
const SPS * sps
Definition: h264_ps.h:140
int prev_frame_num_offset
for POC type 2
Definition: h264_parse.h:52
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
int64_t reference_dts
Definition: h264_parser.c:63
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
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
Definition: h264_ps.h:71
exp golomb vlc stuff
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
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:3414
int level_idc
Definition: h264_ps.h:47
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:152
int dts_sync_point
Synchronization point for start of timestamp generation.
Definition: avcodec.h:3434
static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb, void *logctx)
Definition: h264_parser.c:158
6: bottom field, top field, bottom field repeated, in that order
Definition: h264_sei.h:53
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
Predicted.
Definition: avutil.h:275
#define MAX_MMCO_COUNT
Definition: h264dec.h:54