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 
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 
365  p->ps.pps = NULL;
366  p->ps.sps = NULL;
367  p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);
368  if (!p->ps.pps_ref)
369  goto fail;
370  p->ps.pps = (const PPS*)p->ps.pps_ref->data;
371 
372  if (!p->ps.sps_list[p->ps.pps->sps_id]) {
373  av_log(avctx, AV_LOG_ERROR,
374  "non-existing SPS %u referenced\n", p->ps.pps->sps_id);
375  goto fail;
376  }
377 
378  p->ps.sps_ref = av_buffer_ref(p->ps.sps_list[p->ps.pps->sps_id]);
379  if (!p->ps.sps_ref)
380  goto fail;
381  p->ps.sps = (const SPS*)p->ps.sps_ref->data;
382 
383  sps = p->ps.sps;
384 
385  // heuristic to detect non marked keyframes
386  if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
387  s->key_frame = 1;
388 
389  p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
390 
391  s->coded_width = 16 * sps->mb_width;
392  s->coded_height = 16 * sps->mb_height;
393  s->width = s->coded_width - (sps->crop_right + sps->crop_left);
394  s->height = s->coded_height - (sps->crop_top + sps->crop_bottom);
395  if (s->width <= 0 || s->height <= 0) {
396  s->width = s->coded_width;
397  s->height = s->coded_height;
398  }
399 
400  switch (sps->bit_depth_luma) {
401  case 9:
402  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9;
403  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;
404  else s->format = AV_PIX_FMT_YUV420P9;
405  break;
406  case 10:
407  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10;
408  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;
409  else s->format = AV_PIX_FMT_YUV420P10;
410  break;
411  case 8:
412  if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P;
413  else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;
414  else s->format = AV_PIX_FMT_YUV420P;
415  break;
416  default:
417  s->format = AV_PIX_FMT_NONE;
418  }
419 
420  avctx->profile = ff_h264_get_profile(sps);
421  avctx->level = sps->level_idc;
422 
423  if (sps->frame_mbs_only_flag) {
425  } else {
426  if (get_bits1(&nal.gb)) { // field_pic_flag
427  p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag
428  } else {
430  }
431  }
432 
433  if (nal.type == H264_NAL_IDR_SLICE)
434  get_ue_golomb_long(&nal.gb); /* idr_pic_id */
435  if (sps->poc_type == 0) {
436  p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
437 
438  if (p->ps.pps->pic_order_present == 1 &&
441  }
442 
443  if (sps->poc_type == 1 &&
445  p->poc.delta_poc[0] = get_se_golomb(&nal.gb);
446 
447  if (p->ps.pps->pic_order_present == 1 &&
449  p->poc.delta_poc[1] = get_se_golomb(&nal.gb);
450  }
451 
452  /* Decode POC of this picture.
453  * The prev_ values needed for decoding POC of the next picture are not set here. */
454  field_poc[0] = field_poc[1] = INT_MAX;
455  ret = ff_h264_init_poc(field_poc, &s->output_picture_number, sps,
456  &p->poc, p->picture_structure, nal.ref_idc);
457  if (ret < 0)
458  goto fail;
459 
460  /* Continue parsing to check if MMCO_RESET is present.
461  * FIXME: MMCO_RESET could appear in non-first slice.
462  * Maybe, we should parse all undisposable non-IDR slice of this
463  * picture until encountering MMCO_RESET in a slice of it. */
464  if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {
465  got_reset = scan_mmco_reset(s, &nal.gb, avctx);
466  if (got_reset < 0)
467  goto fail;
468  }
469 
470  /* Set up the prev_ values for decoding POC of the next picture. */
471  p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num;
472  p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;
473  if (nal.ref_idc != 0) {
474  if (!got_reset) {
475  p->poc.prev_poc_msb = p->poc.poc_msb;
476  p->poc.prev_poc_lsb = p->poc.poc_lsb;
477  } else {
478  p->poc.prev_poc_msb = 0;
479  p->poc.prev_poc_lsb =
480  p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];
481  }
482  }
483 
485  switch (p->sei.picture_timing.pic_struct) {
488  s->repeat_pict = 0;
489  break;
493  s->repeat_pict = 1;
494  break;
497  s->repeat_pict = 2;
498  break;
500  s->repeat_pict = 3;
501  break;
503  s->repeat_pict = 5;
504  break;
505  default:
506  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
507  break;
508  }
509  } else {
510  s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
511  }
512 
513  if (p->picture_structure == PICT_FRAME) {
516  switch (p->sei.picture_timing.pic_struct) {
520  break;
524  break;
525  default:
527  break;
528  }
529  } else {
530  if (field_poc[0] < field_poc[1])
532  else if (field_poc[0] > field_poc[1])
534  else
536  }
537  } else {
540  else
542  if (p->poc.frame_num == p->last_frame_num &&
548  else
550  } else {
552  }
554  p->last_frame_num = p->poc.frame_num;
555  }
556 
557  av_freep(&rbsp.rbsp_buffer);
558  return 0; /* no need to evaluate the rest */
559  }
560  }
561  if (q264) {
562  av_freep(&rbsp.rbsp_buffer);
563  return 0;
564  }
565  /* didn't find a picture! */
566  av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
567 fail:
568  av_freep(&rbsp.rbsp_buffer);
569  return -1;
570 }
571 
573  AVCodecContext *avctx,
574  const uint8_t **poutbuf, int *poutbuf_size,
575  const uint8_t *buf, int buf_size)
576 {
577  H264ParseContext *p = s->priv_data;
578  ParseContext *pc = &p->pc;
579  int next;
580 
581  if (!p->got_first) {
582  p->got_first = 1;
583  if (avctx->extradata_size) {
585  &p->ps, &p->is_avc, &p->nal_length_size,
586  avctx->err_recognition, avctx);
587  }
588  }
589 
591  next = buf_size;
592  } else {
593  next = h264_find_frame_end(p, buf, buf_size, avctx);
594 
595  if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
596  *poutbuf = NULL;
597  *poutbuf_size = 0;
598  return buf_size;
599  }
600 
601  if (next < 0 && next != END_NOT_FOUND) {
602  av_assert1(pc->last_index + next >= 0);
603  h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state
604  }
605  }
606 
607  parse_nal_units(s, avctx, buf, buf_size);
608 
609  if (avctx->framerate.num)
610  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
611  if (p->sei.picture_timing.cpb_removal_delay >= 0) {
615  } else {
616  s->dts_sync_point = INT_MIN;
617  s->dts_ref_dts_delta = INT_MIN;
618  s->pts_dts_delta = INT_MIN;
619  }
620 
621  if (s->flags & PARSER_FLAG_ONCE) {
623  }
624 
625  if (s->dts_sync_point >= 0) {
626  int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num;
627  if (den > 0) {
628  int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den;
629  if (s->dts != AV_NOPTS_VALUE) {
630  // got DTS from the stream, update reference timestamp
631  p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den);
632  } else if (p->reference_dts != AV_NOPTS_VALUE) {
633  // compute DTS based on reference timestamp
634  s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den);
635  }
636 
637  if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE)
638  s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den);
639 
640  if (s->dts_sync_point > 0)
641  p->reference_dts = s->dts; // new reference
642  }
643  }
644 
645  *poutbuf = buf;
646  *poutbuf_size = buf_size;
647  return next;
648 }
649 
650 static int h264_split(AVCodecContext *avctx,
651  const uint8_t *buf, int buf_size)
652 {
653  uint32_t state = -1;
654  int has_sps = 0;
655  int has_pps = 0;
656  const uint8_t *ptr = buf, *end = buf + buf_size;
657  int nalu_type;
658 
659  while (ptr < end) {
660  ptr = avpriv_find_start_code(ptr, end, &state);
661  if ((state & 0xFFFFFF00) != 0x100)
662  break;
663  nalu_type = state & 0x1F;
664  if (nalu_type == H264_NAL_SPS) {
665  has_sps = 1;
666  } else if (nalu_type == H264_NAL_PPS)
667  has_pps = 1;
668  /* else if (nalu_type == 0x01 ||
669  * nalu_type == 0x02 ||
670  * nalu_type == 0x05) {
671  * }
672  */
673  else if ((nalu_type != H264_NAL_SEI || has_pps) &&
674  nalu_type != H264_NAL_AUD && nalu_type != H264_NAL_SPS_EXT &&
675  nalu_type != 0x0f) {
676  if (has_sps) {
677  while (ptr - 4 > buf && ptr[-5] == 0)
678  ptr--;
679  return ptr - 4 - buf;
680  }
681  }
682  }
683 
684  return 0;
685 }
686 
688 {
689  H264ParseContext *p = s->priv_data;
690  ParseContext *pc = &p->pc;
691 
692  av_freep(&pc->buffer);
693 
694  ff_h264_sei_uninit(&p->sei);
695  ff_h264_ps_uninit(&p->ps);
696 }
697 
699 {
700  H264ParseContext *p = s->priv_data;
701 
703  p->last_frame_num = INT_MAX;
704  ff_h264dsp_init(&p->h264dsp, 8, 1);
705  return 0;
706 }
707 
710  .priv_data_size = sizeof(H264ParseContext),
711  .parser_init = init,
712  .parser_parse = h264_parse,
713  .parser_close = h264_close,
714  .split = h264_split,
715 };
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:739
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3110
#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:134
int size
Definition: h2645_parse.h:35
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
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:117
Memory handling functions.
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:139
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:5268
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:5245
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264_ps.h:115
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:5289
Picture parameter set.
Definition: h264_ps.h:109
int coded_width
Dimensions of the coded video.
Definition: avcodec.h:5274
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:816
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:70
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:41
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:5205
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:2903
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:1693
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264_ps.h:70
const PPS * pps
Definition: h264_ps.h:145
enum AVPictureStructure picture_structure
Indicate whether a picture is coded as a frame, top field or bottom field.
Definition: avcodec.h:5255
4: bottom field, top field, in that order
Definition: h264_sei.h:50
uint8_t
#define av_cold
Definition: attributes.h:82
#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:90
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:1671
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:123
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
static struct @321 state
#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:3124
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 i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVBufferRef * sps_ref
Definition: h264_ps.h:143
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:138
int weighted_pred
weighted_pred_flag
Definition: h264_ps.h:116
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
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:122
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:385
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:83
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2699
#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:3023
static int get_nalsize(int nal_length_size, const uint8_t *buf, int buf_size, int *buf_index, void *logctx)
Definition: h2645_parse.h:113
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:100
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:65
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
int type
NAL unit type.
Definition: h2645_parse.h:52
AVCodecParser ff_h264_parser
Definition: h264_parser.c:708
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:105
int pic_order_present
pic_order_present_flag
Definition: h264_ps.h:112
static void h264_close(AVCodecParserContext *s)
Definition: h264_parser.c:687
int pts_dts_delta
Presentation delay of current frame in units of AVCodecContext.time_base.
Definition: avcodec.h:5219
uint8_t * buffer
Definition: parser.h:29
5: top field, bottom field, top field repeated, in that order
Definition: h264_sei.h:51
Libavcodec external API header.
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:140
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
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:1570
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
void * buf
Definition: avisynth_c.h:766
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
int extradata_size
Definition: avcodec.h:1672
int rbsp_buffer_alloc_size
Definition: h2645_parse.h:71
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
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:650
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:69
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:183
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
const SPS * sps
Definition: h264_ps.h:146
#define END_NOT_FOUND
Definition: parser.h:40
unsigned int sps_id
Definition: h264_ps.h:110
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:178
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264_ps.h:52
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:182
3: top field, bottom field, in that order
Definition: h264_sei.h:49
int output_picture_number
Picture number incremented in presentation or output order.
Definition: avcodec.h:5263
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
int pic_struct_present_flag
Definition: h264_ps.h:92
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:5156
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.
int dpb_output_delay
dpb_output_delay in picture timing SEI message, see H.264 C.2.2
Definition: h264_sei.h:95
AVBufferRef * pps_ref
Definition: h264_ps.h:142
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
H264SEIFramePacking frame_packing
Definition: h264_sei.h:184
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:5155
int den
Denominator.
Definition: rational.h:60
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:316
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:698
GetBitContext gb
Definition: h2645_parse.h:47
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264_ps.h:98
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:5285
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:5139
#define av_freep(p)
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:404
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:572
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:5170
int level_idc
Definition: h264_ps.h:47
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:145
int dts_sync_point
Synchronization point for start of timestamp generation.
Definition: avcodec.h:5190
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:52
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
Predicted.
Definition: avutil.h:275
#define MAX_MMCO_COUNT
Definition: h264dec.h:54