FFmpeg
h264dec.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... decoder
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 codec.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #define UNCHECKED_BITSTREAM_READER 1
29 
30 #include "config_components.h"
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/emms.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/thread.h"
38 
39 #include "codec_internal.h"
40 #include "internal.h"
41 #include "error_resilience.h"
42 #include "avcodec.h"
43 #include "h264.h"
44 #include "h264dec.h"
45 #include "h2645_parse.h"
46 #include "h264data.h"
47 #include "h264_ps.h"
48 #include "golomb.h"
49 #include "hwaccel_internal.h"
50 #include "hwconfig.h"
51 #include "mpegutils.h"
52 #include "profiles.h"
53 #include "rectangle.h"
54 #include "refstruct.h"
55 #include "thread.h"
56 #include "threadframe.h"
57 
58 const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
59 
61 {
62  H264Context *h = avctx->priv_data;
63  return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0;
64 }
65 
66 static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
67  int (*mv)[2][4][2],
68  int mb_x, int mb_y, int mb_intra, int mb_skipped)
69 {
70  const H264Context *h = opaque;
71  H264SliceContext *sl = &h->slice_ctx[0];
72 
73  sl->mb_x = mb_x;
74  sl->mb_y = mb_y;
75  sl->mb_xy = mb_x + mb_y * h->mb_stride;
76  memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));
77  av_assert1(ref >= 0);
78  /* FIXME: It is possible albeit uncommon that slice references
79  * differ between slices. We take the easy approach and ignore
80  * it for now. If this turns out to have any relevance in
81  * practice then correct remapping should be added. */
82  if (ref >= sl->ref_count[0])
83  ref = 0;
84  if (!sl->ref_list[0][ref].data[0]) {
85  av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
86  ref = 0;
87  }
88  if ((sl->ref_list[0][ref].reference&3) != 3) {
89  av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n");
90  return;
91  }
92  fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],
93  2, 2, 2, ref, 1);
94  fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
95  fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
96  pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
97  sl->mb_mbaff =
98  sl->mb_field_decoding_flag = 0;
99  ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
100 }
101 
103  int y, int height)
104 {
105  AVCodecContext *avctx = h->avctx;
106  const AVFrame *src = h->cur_pic.f;
107  const AVPixFmtDescriptor *desc;
109  int vshift;
110  const int field_pic = h->picture_structure != PICT_FRAME;
111 
112  if (!avctx->draw_horiz_band)
113  return;
114 
115  if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
116  return;
117 
118  if (field_pic) {
119  height <<= 1;
120  y <<= 1;
121  }
122 
123  height = FFMIN(height, avctx->height - y);
124 
125  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
126  vshift = desc->log2_chroma_h;
127 
128  offset[0] = y * src->linesize[0];
129  offset[1] =
130  offset[2] = (y >> vshift) * src->linesize[1];
131  for (int i = 3; i < AV_NUM_DATA_POINTERS; i++)
132  offset[i] = 0;
133 
134  emms_c();
135 
136  avctx->draw_horiz_band(avctx, src, offset,
137  y, h->picture_structure, height);
138 }
139 
141 {
142  int i;
143 
144  av_freep(&h->intra4x4_pred_mode);
145  av_freep(&h->chroma_pred_mode_table);
146  av_freep(&h->cbp_table);
147  av_freep(&h->mvd_table[0]);
148  av_freep(&h->mvd_table[1]);
149  av_freep(&h->direct_table);
150  av_freep(&h->non_zero_count);
151  av_freep(&h->slice_table_base);
152  h->slice_table = NULL;
153  av_freep(&h->list_counts);
154 
155  av_freep(&h->mb2b_xy);
156  av_freep(&h->mb2br_xy);
157 
158  ff_refstruct_pool_uninit(&h->qscale_table_pool);
159  ff_refstruct_pool_uninit(&h->mb_type_pool);
160  ff_refstruct_pool_uninit(&h->motion_val_pool);
161  ff_refstruct_pool_uninit(&h->ref_index_pool);
162 
163 #if CONFIG_ERROR_RESILIENCE
164  av_freep(&h->er.mb_index2xy);
165  av_freep(&h->er.error_status_table);
166  av_freep(&h->er.er_temp_buffer);
167  av_freep(&h->dc_val_base);
168 #endif
169 
170  for (i = 0; i < h->nb_slice_ctx; i++) {
171  H264SliceContext *sl = &h->slice_ctx[i];
172 
175  av_freep(&sl->top_borders[0]);
176  av_freep(&sl->top_borders[1]);
177 
180  sl->top_borders_allocated[0] = 0;
181  sl->top_borders_allocated[1] = 0;
182  }
183 }
184 
186 {
187  ERContext *const er = &h->er;
188  const int big_mb_num = h->mb_stride * (h->mb_height + 1);
189  const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1);
190  const int st_size = big_mb_num + h->mb_stride;
191  int x, y;
192 
193  if (!FF_ALLOCZ_TYPED_ARRAY(h->intra4x4_pred_mode, row_mb_num * 8) ||
194  !FF_ALLOCZ_TYPED_ARRAY(h->non_zero_count, big_mb_num) ||
195  !FF_ALLOCZ_TYPED_ARRAY(h->slice_table_base, st_size) ||
196  !FF_ALLOCZ_TYPED_ARRAY(h->cbp_table, big_mb_num) ||
197  !FF_ALLOCZ_TYPED_ARRAY(h->chroma_pred_mode_table, big_mb_num) ||
198  !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[0], row_mb_num * 8) ||
199  !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[1], row_mb_num * 8) ||
200  !FF_ALLOCZ_TYPED_ARRAY(h->direct_table, big_mb_num * 4) ||
201  !FF_ALLOCZ_TYPED_ARRAY(h->list_counts, big_mb_num) ||
202  !FF_ALLOCZ_TYPED_ARRAY(h->mb2b_xy, big_mb_num) ||
203  !FF_ALLOCZ_TYPED_ARRAY(h->mb2br_xy, big_mb_num))
204  return AVERROR(ENOMEM);
205  h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
206  h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
207  h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
208  memset(h->slice_table_base, -1,
209  st_size * sizeof(*h->slice_table_base));
210  h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
211  for (y = 0; y < h->mb_height; y++)
212  for (x = 0; x < h->mb_width; x++) {
213  const int mb_xy = x + y * h->mb_stride;
214  const int b_xy = 4 * x + 4 * y * h->b_stride;
215 
216  h->mb2b_xy[mb_xy] = b_xy;
217  h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
218  }
219 
220  if (CONFIG_ERROR_RESILIENCE) {
221  const int er_size = h->mb_height * h->mb_stride * (4*sizeof(int) + 1);
222  int mb_array_size = h->mb_height * h->mb_stride;
223  int y_size = (2 * h->mb_width + 1) * (2 * h->mb_height + 1);
224  int yc_size = y_size + 2 * big_mb_num;
225 
226  /* init ER */
227  er->avctx = h->avctx;
229  er->opaque = h;
230  er->quarter_sample = 1;
231 
232  er->mb_num = h->mb_num;
233  er->mb_width = h->mb_width;
234  er->mb_height = h->mb_height;
235  er->mb_stride = h->mb_stride;
236  er->b8_stride = h->mb_width * 2 + 1;
237 
238  // error resilience code looks cleaner with this
239  if (!FF_ALLOCZ_TYPED_ARRAY(er->mb_index2xy, h->mb_num + 1) ||
240  !FF_ALLOCZ_TYPED_ARRAY(er->error_status_table, mb_array_size) ||
241  !FF_ALLOCZ_TYPED_ARRAY(er->er_temp_buffer, er_size) ||
242  !FF_ALLOCZ_TYPED_ARRAY(h->dc_val_base, yc_size))
243  return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
244 
245  for (y = 0; y < h->mb_height; y++)
246  for (x = 0; x < h->mb_width; x++)
247  er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;
248 
249  er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
250  h->mb_stride + h->mb_width;
251  er->dc_val[0] = h->dc_val_base + h->mb_width * 2 + 2;
252  er->dc_val[1] = h->dc_val_base + y_size + h->mb_stride + 1;
253  er->dc_val[2] = er->dc_val[1] + big_mb_num;
254  for (int i = 0; i < yc_size; i++)
255  h->dc_val_base[i] = 1024;
256  }
257 
258  return 0;
259 }
260 
261 /**
262  * Init slice context
263  */
265 {
266  sl->ref_cache[0][scan8[5] + 1] =
267  sl->ref_cache[0][scan8[7] + 1] =
268  sl->ref_cache[0][scan8[13] + 1] =
269  sl->ref_cache[1][scan8[5] + 1] =
270  sl->ref_cache[1][scan8[7] + 1] =
271  sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;
272 
273  sl->er = &h->er;
274 }
275 
276 static int h264_init_pic(H264Picture *pic)
277 {
278  pic->f = av_frame_alloc();
279  if (!pic->f)
280  return AVERROR(ENOMEM);
281 
282  pic->f_grain = av_frame_alloc();
283  if (!pic->f_grain)
284  return AVERROR(ENOMEM);
285 
286  return 0;
287 }
288 
290 {
291  int i, ret;
292 
293  h->avctx = avctx;
294  h->cur_chroma_format_idc = -1;
295 
296  h->width_from_caller = avctx->width;
297  h->height_from_caller = avctx->height;
298 
299  h->workaround_bugs = avctx->workaround_bugs;
300  h->flags = avctx->flags;
301  h->poc.prev_poc_msb = 1 << 16;
302  h->recovery_frame = -1;
303  h->frame_recovered = 0;
304  h->poc.prev_frame_num = -1;
305  h->sei.common.frame_packing.arrangement_cancel_flag = -1;
306  h->sei.common.unregistered.x264_build = -1;
307 
308  h->next_outputed_poc = INT_MIN;
309  for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
310  h->last_pocs[i] = INT_MIN;
311 
312  ff_h264_sei_uninit(&h->sei);
313 
314  if (avctx->active_thread_type & FF_THREAD_FRAME) {
315  h->decode_error_flags_pool = ff_refstruct_pool_alloc(sizeof(atomic_int), 0);
316  if (!h->decode_error_flags_pool)
317  return AVERROR(ENOMEM);
318  }
319 
320  h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
321  h->slice_ctx = av_calloc(h->nb_slice_ctx, sizeof(*h->slice_ctx));
322  if (!h->slice_ctx) {
323  h->nb_slice_ctx = 0;
324  return AVERROR(ENOMEM);
325  }
326 
327  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
328  if ((ret = h264_init_pic(&h->DPB[i])) < 0)
329  return ret;
330  }
331 
332  if ((ret = h264_init_pic(&h->cur_pic)) < 0)
333  return ret;
334 
335  if ((ret = h264_init_pic(&h->last_pic_for_ec)) < 0)
336  return ret;
337 
338  for (i = 0; i < h->nb_slice_ctx; i++)
339  h->slice_ctx[i].h264 = h;
340 
341  return 0;
342 }
343 
345 {
347  av_frame_free(&pic->f);
348  av_frame_free(&pic->f_grain);
349 }
350 
352 {
353  H264Context *h = avctx->priv_data;
354  int i;
355 
358 
359  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
360  h264_free_pic(h, &h->DPB[i]);
361  }
362  memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
363 
364  h->cur_pic_ptr = NULL;
365 
366  ff_refstruct_pool_uninit(&h->decode_error_flags_pool);
367 
368  av_freep(&h->slice_ctx);
369  h->nb_slice_ctx = 0;
370 
371  ff_h264_sei_uninit(&h->sei);
372  ff_h264_ps_uninit(&h->ps);
373 
374  ff_h2645_packet_uninit(&h->pkt);
375 
376  h264_free_pic(h, &h->cur_pic);
377  h264_free_pic(h, &h->last_pic_for_ec);
378 
379  return 0;
380 }
381 
383 
385 {
386  H264Context *h = avctx->priv_data;
387  int ret;
388 
389  ret = h264_init_context(avctx, h);
390  if (ret < 0)
391  return ret;
392 
394  if (ret != 0) {
395  av_log(avctx, AV_LOG_ERROR, "pthread_once has failed.");
396  return AVERROR_UNKNOWN;
397  }
398 
399 #if FF_API_TICKS_PER_FRAME
401  avctx->ticks_per_frame = 2;
403 #endif
404 
405  if (!avctx->internal->is_copy) {
406  if (avctx->extradata_size > 0 && avctx->extradata) {
408  &h->ps, &h->is_avc, &h->nal_length_size,
409  avctx->err_recognition, avctx);
410  if (ret < 0) {
411  int explode = avctx->err_recognition & AV_EF_EXPLODE;
412  av_log(avctx, explode ? AV_LOG_ERROR: AV_LOG_WARNING,
413  "Error decoding the extradata\n");
414  if (explode) {
415  return ret;
416  }
417  ret = 0;
418  }
419  }
420  }
421 
422  if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&
423  h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) {
424  h->avctx->has_b_frames = h->ps.sps->num_reorder_frames;
425  }
426 
428 
429  if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
430  h->enable_er = 0;
431 
432  if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {
433  av_log(avctx, AV_LOG_WARNING,
434  "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
435  "Use it at your own risk\n");
436  }
437 
438  return 0;
439 }
440 
441 /**
442  * instantaneous decoder refresh.
443  */
444 static void idr(H264Context *h)
445 {
446  int i;
448  h->poc.prev_frame_num =
449  h->poc.prev_frame_num_offset = 0;
450  h->poc.prev_poc_msb = 1<<16;
451  h->poc.prev_poc_lsb = -1;
452  for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
453  h->last_pocs[i] = INT_MIN;
454 }
455 
456 /* forget old pics after a seek */
458 {
459  int i, j;
460 
461  h->next_outputed_poc = INT_MIN;
462  h->prev_interlaced_frame = 1;
463  idr(h);
464 
465  h->poc.prev_frame_num = -1;
466  if (h->cur_pic_ptr) {
467  h->cur_pic_ptr->reference = 0;
468  for (j=i=0; h->delayed_pic[i]; i++)
469  if (h->delayed_pic[i] != h->cur_pic_ptr)
470  h->delayed_pic[j++] = h->delayed_pic[i];
471  h->delayed_pic[j] = NULL;
472  }
473  ff_h264_unref_picture(&h->last_pic_for_ec);
474 
475  h->first_field = 0;
476  h->recovery_frame = -1;
477  h->frame_recovered = 0;
478  h->current_slice = 0;
479  h->mmco_reset = 1;
480 }
481 
483 {
484  H264Context *h = avctx->priv_data;
485  int i;
486 
487  memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
488 
490  ff_h264_sei_uninit(&h->sei);
491 
492  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
493  ff_h264_unref_picture(&h->DPB[i]);
494  h->cur_pic_ptr = NULL;
495  ff_h264_unref_picture(&h->cur_pic);
496 
497  h->mb_y = 0;
498  h->non_gray = 0;
499 
501  h->context_initialized = 0;
502 
503  if (FF_HW_HAS_CB(avctx, flush))
504  FF_HW_SIMPLE_CALL(avctx, flush);
505 }
506 
508 {
509  int nals_needed = 0;
510  int slice_type = 0;
511  int picture_intra_only = 1;
512  int first_slice = 0;
513  int i, ret;
514 
515  for (i = 0; i < h->pkt.nb_nals; i++) {
516  H2645NAL *nal = &h->pkt.nals[i];
517  GetBitContext gb;
518 
519  /* packets can sometimes contain multiple PPS/SPS,
520  * e.g. two PAFF field pictures in one packet, or a demuxer
521  * which splits NALs strangely if so, when frame threading we
522  * can't start the next thread until we've read all of them */
523  switch (nal->type) {
524  case H264_NAL_SPS:
525  case H264_NAL_PPS:
526  nals_needed = i;
527  break;
528  case H264_NAL_DPA:
529  case H264_NAL_IDR_SLICE:
530  case H264_NAL_SLICE:
531  ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);
532  if (ret < 0) {
533  av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");
534  if (h->avctx->err_recognition & AV_EF_EXPLODE)
535  return ret;
536 
537  break;
538  }
539  if (!get_ue_golomb_long(&gb) || // first_mb_in_slice
540  !first_slice ||
541  first_slice != nal->type)
542  nals_needed = i;
543  slice_type = get_ue_golomb_31(&gb);
544  if (slice_type > 9)
545  slice_type = 0;
546  if (slice_type > 4)
547  slice_type -= 5;
548 
549  slice_type = ff_h264_golomb_to_pict_type[slice_type];
550  picture_intra_only &= (slice_type & 3) == AV_PICTURE_TYPE_I;
551  if (!first_slice)
552  first_slice = nal->type;
553  }
554  }
555 
556  h->picture_intra_only = picture_intra_only;
557 
558  return nals_needed;
559 }
560 
561 static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
562 {
563  av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n");
564  av_log(logctx, AV_LOG_DEBUG, " green_metadata_type: %d\n", gm->green_metadata_type);
565 
566  if (gm->green_metadata_type == 0) {
567  av_log(logctx, AV_LOG_DEBUG, " green_metadata_period_type: %d\n", gm->period_type);
568 
569  if (gm->period_type == 2)
570  av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_seconds: %d\n", gm->num_seconds);
571  else if (gm->period_type == 3)
572  av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_pictures: %d\n", gm->num_pictures);
573 
574  av_log(logctx, AV_LOG_DEBUG, " SEI GREEN Complexity Metrics: %f %f %f %f\n",
575  (float)gm->percent_non_zero_macroblocks/255,
576  (float)gm->percent_intra_coded_macroblocks/255,
577  (float)gm->percent_six_tap_filtering/255,
579 
580  } else if (gm->green_metadata_type == 1) {
581  av_log(logctx, AV_LOG_DEBUG, " xsd_metric_type: %d\n", gm->xsd_metric_type);
582 
583  if (gm->xsd_metric_type == 0)
584  av_log(logctx, AV_LOG_DEBUG, " xsd_metric_value: %f\n",
585  (float)gm->xsd_metric_value/100);
586  }
587 }
588 
589 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
590 {
591  AVCodecContext *const avctx = h->avctx;
592  int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
593  int idr_cleared=0;
594  int i, ret = 0;
595 
596  h->has_slice = 0;
597  h->nal_unit_type= 0;
598 
599  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
600  h->current_slice = 0;
601  if (!h->first_field) {
602  h->cur_pic_ptr = NULL;
603  ff_h264_sei_uninit(&h->sei);
604  }
605  }
606 
607  if (h->nal_length_size == 4) {
608  if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
609  h->is_avc = 0;
610  }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
611  h->is_avc = 1;
612  }
613 
614  ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc, h->nal_length_size,
615  avctx->codec_id, 0, 0);
616  if (ret < 0) {
617  av_log(avctx, AV_LOG_ERROR,
618  "Error splitting the input into NAL units.\n");
619  return ret;
620  }
621 
622  if (avctx->active_thread_type & FF_THREAD_FRAME)
623  nals_needed = get_last_needed_nal(h);
624  if (nals_needed < 0)
625  return nals_needed;
626 
627  for (i = 0; i < h->pkt.nb_nals; i++) {
628  H2645NAL *nal = &h->pkt.nals[i];
629  int max_slice_ctx, err;
630 
631  if (avctx->skip_frame >= AVDISCARD_NONREF &&
632  nal->ref_idc == 0 && nal->type != H264_NAL_SEI)
633  continue;
634 
635  // FIXME these should stop being context-global variables
636  h->nal_ref_idc = nal->ref_idc;
637  h->nal_unit_type = nal->type;
638 
639  err = 0;
640  switch (nal->type) {
641  case H264_NAL_IDR_SLICE:
642  if ((nal->data[1] & 0xFC) == 0x98) {
643  av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");
644  h->next_outputed_poc = INT_MIN;
645  ret = -1;
646  goto end;
647  }
648  if(!idr_cleared) {
649  idr(h); // FIXME ensure we don't lose some frames if there is reordering
650  }
651  idr_cleared = 1;
652  h->has_recovery_point = 1;
653  case H264_NAL_SLICE:
654  h->has_slice = 1;
655 
656  if ((err = ff_h264_queue_decode_slice(h, nal))) {
657  H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
658  sl->ref_count[0] = sl->ref_count[1] = 0;
659  break;
660  }
661 
662  if (h->current_slice == 1) {
663  if (avctx->active_thread_type & FF_THREAD_FRAME &&
664  i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {
665  ff_thread_finish_setup(avctx);
666  h->setup_finished = 1;
667  }
668 
669  if (h->avctx->hwaccel &&
670  (ret = FF_HW_CALL(h->avctx, start_frame, buf, buf_size)) < 0)
671  goto end;
672  }
673 
674  max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;
675  if (h->nb_slice_ctx_queued == max_slice_ctx) {
676  if (h->avctx->hwaccel) {
677  ret = FF_HW_CALL(avctx, decode_slice, nal->raw_data, nal->raw_size);
678  h->nb_slice_ctx_queued = 0;
679  } else
681  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
682  goto end;
683  }
684  break;
685  case H264_NAL_DPA:
686  case H264_NAL_DPB:
687  case H264_NAL_DPC:
688  avpriv_request_sample(avctx, "data partitioning");
689  break;
690  case H264_NAL_SEI:
691  if (h->setup_finished) {
692  avpriv_request_sample(avctx, "Late SEI");
693  break;
694  }
695  ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
696  h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1;
697  if (avctx->debug & FF_DEBUG_GREEN_MD)
698  debug_green_metadata(&h->sei.green_metadata, h->avctx);
699  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
700  goto end;
701  break;
702  case H264_NAL_SPS: {
703  GetBitContext tmp_gb = nal->gb;
704  if (FF_HW_HAS_CB(avctx, decode_params)) {
705  ret = FF_HW_CALL(avctx, decode_params,
706  nal->type, nal->raw_data, nal->raw_size);
707  if (ret < 0)
708  goto end;
709  }
710  if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
711  break;
712  av_log(h->avctx, AV_LOG_DEBUG,
713  "SPS decoding failure, trying again with the complete NAL\n");
714  init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
715  if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
716  break;
717  ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);
718  break;
719  }
720  case H264_NAL_PPS:
721  if (FF_HW_HAS_CB(avctx, decode_params)) {
722  ret = FF_HW_CALL(avctx, decode_params,
723  nal->type, nal->raw_data, nal->raw_size);
724  if (ret < 0)
725  goto end;
726  }
727  ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
728  nal->size_bits);
729  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
730  goto end;
731  break;
732  case H264_NAL_AUD:
734  case H264_NAL_END_STREAM:
736  case H264_NAL_SPS_EXT:
738  break;
739  default:
740  av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
741  nal->type, nal->size_bits);
742  }
743 
744  if (err < 0) {
745  av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
746  }
747  }
748 
750  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
751  goto end;
752 
753  // set decode_error_flags to allow users to detect concealed decoding errors
754  if ((ret < 0 || h->er.error_occurred) && h->cur_pic_ptr) {
755  if (h->cur_pic_ptr->decode_error_flags) {
756  /* Frame-threading in use */
757  atomic_int *decode_error = h->cur_pic_ptr->decode_error_flags;
758  /* Using atomics here is not supposed to provide syncronisation;
759  * they are merely used to allow to set decode_error from both
760  * decoding threads in case of coded slices. */
762  memory_order_relaxed);
763  } else
764  h->cur_pic_ptr->f->decode_error_flags |= FF_DECODE_ERROR_DECODE_SLICES;
765  }
766 
767  ret = 0;
768 end:
769 
770 #if CONFIG_ERROR_RESILIENCE
771  /*
772  * FIXME: Error handling code does not seem to support interlaced
773  * when slices span multiple rows
774  * The ff_er_add_slice calls don't work right for bottom
775  * fields; they cause massive erroneous error concealing
776  * Error marking covers both fields (top and bottom).
777  * This causes a mismatched s->error_count
778  * and a bad error table. Further, the error count goes to
779  * INT_MAX when called for bottom field, because mb_y is
780  * past end by one (callers fault) and resync_mb_y != 0
781  * causes problems for the first MB line, too.
782  */
783  if (!FIELD_PICTURE(h) && h->current_slice && h->enable_er) {
784 
785  H264SliceContext *sl = h->slice_ctx;
786  int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
787  int decode_error_flags = 0;
788 
789  ff_h264_set_erpic(&h->er.cur_pic, h->cur_pic_ptr);
790 
791  if (use_last_pic) {
792  ff_h264_set_erpic(&h->er.last_pic, &h->last_pic_for_ec);
793  sl->ref_list[0][0].parent = &h->last_pic_for_ec;
794  memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
795  memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
796  sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;
797  } else if (sl->ref_count[0]) {
798  ff_h264_set_erpic(&h->er.last_pic, sl->ref_list[0][0].parent);
799  } else
800  ff_h264_set_erpic(&h->er.last_pic, NULL);
801 
802  if (sl->ref_count[1])
803  ff_h264_set_erpic(&h->er.next_pic, sl->ref_list[1][0].parent);
804 
805  ff_er_frame_end(&h->er, &decode_error_flags);
806  if (decode_error_flags) {
807  if (h->cur_pic_ptr->decode_error_flags) {
808  atomic_int *decode_error = h->cur_pic_ptr->decode_error_flags;
809  atomic_fetch_or_explicit(decode_error, decode_error_flags,
810  memory_order_relaxed);
811  } else
812  h->cur_pic_ptr->f->decode_error_flags |= decode_error_flags;
813  }
814  if (use_last_pic)
815  memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
816  }
817 #endif /* CONFIG_ERROR_RESILIENCE */
818  /* clean up */
819  if (h->cur_pic_ptr && !h->droppable && h->has_slice) {
820  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
821  h->picture_structure == PICT_BOTTOM_FIELD);
822  }
823 
824  return (ret < 0) ? ret : buf_size;
825 }
826 
827 /**
828  * Return the number of bytes consumed for building the current frame.
829  */
830 static int get_consumed_bytes(int pos, int buf_size)
831 {
832  if (pos == 0)
833  pos = 1; // avoid infinite loops (I doubt that is needed but...)
834  if (pos + 10 > buf_size)
835  pos = buf_size; // oops ;)
836 
837  return pos;
838 }
839 
841 {
842  AVVideoEncParams *par;
843  unsigned int nb_mb = p->mb_height * p->mb_width;
844  unsigned int x, y;
845 
847  if (!par)
848  return AVERROR(ENOMEM);
849 
850  par->qp = p->pps->init_qp;
851 
852  par->delta_qp[1][0] = p->pps->chroma_qp_index_offset[0];
853  par->delta_qp[1][1] = p->pps->chroma_qp_index_offset[0];
854  par->delta_qp[2][0] = p->pps->chroma_qp_index_offset[1];
855  par->delta_qp[2][1] = p->pps->chroma_qp_index_offset[1];
856 
857  for (y = 0; y < p->mb_height; y++)
858  for (x = 0; x < p->mb_width; x++) {
859  const unsigned int block_idx = y * p->mb_width + x;
860  const unsigned int mb_xy = y * p->mb_stride + x;
862 
863  b->src_x = x * 16;
864  b->src_y = y * 16;
865  b->w = 16;
866  b->h = 16;
867 
868  b->delta_qp = p->qscale_table[mb_xy] - par->qp;
869  }
870 
871  return 0;
872 }
873 
874 static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
875 {
876  int ret;
877 
878  ret = av_frame_ref(dst, srcp->needs_fg ? srcp->f_grain : srcp->f);
879  if (ret < 0)
880  return ret;
881 
882  if (srcp->needs_fg && (ret = av_frame_copy_props(dst, srcp->f)) < 0)
883  return ret;
884 
885  if (srcp->decode_error_flags) {
886  atomic_int *decode_error = srcp->decode_error_flags;
887  /* The following is not supposed to provide synchronisation at all:
888  * given that srcp has already finished decoding, decode_error
889  * has already been set to its final value. */
890  dst->decode_error_flags |= atomic_load_explicit(decode_error, memory_order_relaxed);
891  }
892 
893  av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.common.frame_packing), 0);
894 
895  if (srcp->sei_recovery_frame_cnt == 0)
896  dst->flags |= AV_FRAME_FLAG_KEY;
897 
898  if (h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) {
899  ret = h264_export_enc_params(dst, srcp);
900  if (ret < 0)
901  goto fail;
902  }
903 
904  if (!(h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))
906 
907  return 0;
908 fail:
909  av_frame_unref(dst);
910  return ret;
911 }
912 
913 static int is_avcc_extradata(const uint8_t *buf, int buf_size)
914 {
915  int cnt= buf[5]&0x1f;
916  const uint8_t *p= buf+6;
917  if (!cnt)
918  return 0;
919  while(cnt--){
920  int nalsize= AV_RB16(p) + 2;
921  if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
922  return 0;
923  p += nalsize;
924  }
925  cnt = *(p++);
926  if(!cnt)
927  return 0;
928  while(cnt--){
929  int nalsize= AV_RB16(p) + 2;
930  if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
931  return 0;
932  p += nalsize;
933  }
934  return 1;
935 }
936 
937 static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
938 {
939  int ret;
940 
941  if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
942  (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||
943  out->recovered)) {
944 
945  if (h->skip_gray > 0 &&
946  h->non_gray && out->gray &&
947  !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)
948  )
949  return 0;
950 
951  if (!h->avctx->hwaccel &&
952  (out->field_poc[0] == INT_MAX ||
953  out->field_poc[1] == INT_MAX)
954  ) {
955  int p;
956  AVFrame *f = out->f;
957  int field = out->field_poc[0] == INT_MAX;
958  uint8_t *dst_data[4];
959  int linesizes[4];
960  const uint8_t *src_data[4];
961 
962  av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
963 
964  for (p = 0; p<4; p++) {
965  dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
966  src_data[p] = f->data[p] + field *f->linesize[p];
967  linesizes[p] = 2*f->linesize[p];
968  }
969 
970  av_image_copy(dst_data, linesizes, src_data, linesizes,
971  f->format, f->width, f->height>>1);
972  }
973 
974  ret = output_frame(h, dst, out);
975  if (ret < 0)
976  return ret;
977 
978  *got_frame = 1;
979 
980  if (CONFIG_MPEGVIDEODEC) {
981  ff_print_debug_info2(h->avctx, dst, NULL,
982  out->mb_type,
983  out->qscale_table,
984  out->motion_val,
985  out->mb_width, out->mb_height, out->mb_stride, 1);
986  }
987  }
988 
989  return 0;
990 }
991 
993  int *got_frame, int buf_index)
994 {
995  int ret, i, out_idx;
996  H264Picture *out = h->delayed_pic[0];
997 
998  h->cur_pic_ptr = NULL;
999  h->first_field = 0;
1000 
1001  out_idx = 0;
1002  for (i = 1;
1003  h->delayed_pic[i] &&
1004  !(h->delayed_pic[i]->f->flags & AV_FRAME_FLAG_KEY) &&
1005  !h->delayed_pic[i]->mmco_reset;
1006  i++)
1007  if (h->delayed_pic[i]->poc < out->poc) {
1008  out = h->delayed_pic[i];
1009  out_idx = i;
1010  }
1011 
1012  for (i = out_idx; h->delayed_pic[i]; i++)
1013  h->delayed_pic[i] = h->delayed_pic[i + 1];
1014 
1015  if (out) {
1016  out->reference &= ~DELAYED_PIC_REF;
1017  ret = finalize_frame(h, dst_frame, out, got_frame);
1018  if (ret < 0)
1019  return ret;
1020  }
1021 
1022  return buf_index;
1023 }
1024 
1025 static int h264_decode_frame(AVCodecContext *avctx, AVFrame *pict,
1026  int *got_frame, AVPacket *avpkt)
1027 {
1028  const uint8_t *buf = avpkt->data;
1029  int buf_size = avpkt->size;
1030  H264Context *h = avctx->priv_data;
1031  int buf_index;
1032  int ret;
1033 
1034  h->flags = avctx->flags;
1035  h->setup_finished = 0;
1036  h->nb_slice_ctx_queued = 0;
1037 
1038  ff_h264_unref_picture(&h->last_pic_for_ec);
1039 
1040  /* end of stream, output what is still in the buffers */
1041  if (buf_size == 0)
1042  return send_next_delayed_frame(h, pict, got_frame, 0);
1043 
1045  size_t side_size;
1046  uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
1047  ff_h264_decode_extradata(side, side_size,
1048  &h->ps, &h->is_avc, &h->nal_length_size,
1049  avctx->err_recognition, avctx);
1050  }
1051  if (h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) {
1052  if (is_avcc_extradata(buf, buf_size))
1053  return ff_h264_decode_extradata(buf, buf_size,
1054  &h->ps, &h->is_avc, &h->nal_length_size,
1055  avctx->err_recognition, avctx);
1056  }
1057 
1058  buf_index = decode_nal_units(h, buf, buf_size);
1059  if (buf_index < 0)
1060  return AVERROR_INVALIDDATA;
1061 
1062  if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) {
1063  av_assert0(buf_index <= buf_size);
1064  return send_next_delayed_frame(h, pict, got_frame, buf_index);
1065  }
1066 
1067  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {
1068  if (avctx->skip_frame >= AVDISCARD_NONREF ||
1069  buf_size >= 4 && !memcmp("Q264", buf, 4))
1070  return buf_size;
1071  av_log(avctx, AV_LOG_ERROR, "no frame!\n");
1072  return AVERROR_INVALIDDATA;
1073  }
1074 
1075  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
1076  (h->mb_y >= h->mb_height && h->mb_height)) {
1077  if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)
1078  return ret;
1079 
1080  /* Wait for second field. */
1081  if (h->next_output_pic) {
1082  ret = finalize_frame(h, pict, h->next_output_pic, got_frame);
1083  if (ret < 0)
1084  return ret;
1085  }
1086  }
1087 
1088  av_assert0(pict->buf[0] || !*got_frame);
1089 
1090  ff_h264_unref_picture(&h->last_pic_for_ec);
1091 
1092  return get_consumed_bytes(buf_index, buf_size);
1093 }
1094 
1095 #define OFFSET(x) offsetof(H264Context, x)
1096 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1097 #define VDX VD | AV_OPT_FLAG_EXPORT
1098 static const AVOption h264_options[] = {
1099  { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VDX },
1100  { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, VDX },
1101  { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },
1102  { "x264_build", "Assume this x264 version if no x264 version found in any SEI", OFFSET(x264_build), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VD },
1103  { "skip_gray", "Do not return gray gap frames", OFFSET(skip_gray), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VD },
1104  { "noref_gray", "Avoid using gray gap frames as references", OFFSET(noref_gray), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VD },
1105  { NULL },
1106 };
1107 
1108 static const AVClass h264_class = {
1109  .class_name = "H264 Decoder",
1110  .item_name = av_default_item_name,
1111  .option = h264_options,
1112  .version = LIBAVUTIL_VERSION_INT,
1113 };
1114 
1116  .p.name = "h264",
1117  CODEC_LONG_NAME("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1118  .p.type = AVMEDIA_TYPE_VIDEO,
1119  .p.id = AV_CODEC_ID_H264,
1120  .priv_data_size = sizeof(H264Context),
1122  .close = h264_decode_end,
1124  .p.capabilities = AV_CODEC_CAP_DR1 |
1127  .hw_configs = (const AVCodecHWConfigInternal *const []) {
1128 #if CONFIG_H264_DXVA2_HWACCEL
1129  HWACCEL_DXVA2(h264),
1130 #endif
1131 #if CONFIG_H264_D3D11VA_HWACCEL
1132  HWACCEL_D3D11VA(h264),
1133 #endif
1134 #if CONFIG_H264_D3D11VA2_HWACCEL
1135  HWACCEL_D3D11VA2(h264),
1136 #endif
1137 #if CONFIG_H264_D3D12VA_HWACCEL
1138  HWACCEL_D3D12VA(h264),
1139 #endif
1140 #if CONFIG_H264_NVDEC_HWACCEL
1141  HWACCEL_NVDEC(h264),
1142 #endif
1143 #if CONFIG_H264_VAAPI_HWACCEL
1144  HWACCEL_VAAPI(h264),
1145 #endif
1146 #if CONFIG_H264_VDPAU_HWACCEL
1147  HWACCEL_VDPAU(h264),
1148 #endif
1149 #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
1150  HWACCEL_VIDEOTOOLBOX(h264),
1151 #endif
1152 #if CONFIG_H264_VULKAN_HWACCEL
1153  HWACCEL_VULKAN(h264),
1154 #endif
1155  NULL
1156  },
1157  .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING |
1159  .flush = h264_decode_flush,
1162  .p.profiles = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
1163  .p.priv_class = &h264_class,
1164 };
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:88
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition: hwconfig.h:80
AVVideoEncParams::qp
int32_t qp
Base quantisation parameter for the frame.
Definition: video_enc_params.h:103
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1439
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
H264SliceContext::mb_xy
int mb_xy
Definition: h264dec.h:226
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
H264SliceContext::ref_cache
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:294
ff_h264_free_tables
void ff_h264_free_tables(H264Context *h)
Definition: h264dec.c:140
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
ff_h264_sei_uninit
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:48
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
h2645_parse.h
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
decode_slice
static int decode_slice(AVCodecContext *c, void *arg)
Definition: ffv1dec.c:255
AVCodecContext::workaround_bugs
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:1345
opt.h
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
ff_h264_mb_sizes
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:58
H264Picture::f
AVFrame * f
Definition: h264dec.h:107
ff_h264_ps_uninit
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:270
idr
static void idr(H264Context *h)
instantaneous decoder refresh.
Definition: h264dec.c:444
ff_refstruct_pool_alloc
FFRefStructPool * ff_refstruct_pool_alloc(size_t size, unsigned flags)
Equivalent to ff_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL)
Definition: refstruct.c:335
out
FILE * out
Definition: movenc.c:54
thread.h
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
h264_decode_init
static av_cold int h264_decode_init(AVCodecContext *avctx)
Definition: h264dec.c:384
SLICE_FLAG_ALLOW_FIELD
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
Definition: avcodec.h:921
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1416
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:184
H264Picture::pps
const PPS * pps
Definition: h264dec.h:150
H2645NAL::ref_idc
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:57
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
ff_h264_slice_context_init
void ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
Init slice context.
Definition: h264dec.c:264
ERContext::mb_index2xy
int * mb_index2xy
Definition: error_resilience.h:58
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:64
ff_h264_update_thread_context
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:329
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:251
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:66
ff_h2645_packet_uninit
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:598
b
#define b
Definition: input.c:41
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:262
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
H264SEIGreenMetaData::xsd_metric_value
uint16_t xsd_metric_value
Definition: h264_sei.h:116
H264SEIGreenMetaData::period_type
uint8_t period_type
Definition: h264_sei.h:108
PPS::chroma_qp_index_offset
int chroma_qp_index_offset[2]
Definition: h264_ps.h:122
H264Picture::qscale_table
int8_t * qscale_table
Definition: h264dec.h:113
FFCodec
Definition: codec_internal.h:127
ERContext
Definition: error_resilience.h:52
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
H264_NAL_DPB
@ H264_NAL_DPB
Definition: h264.h:37
ff_h264_update_thread_context_for_user
int ff_h264_update_thread_context_for_user(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:465
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:174
decode_nal_units
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
Definition: h264dec.c:589
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
mpegutils.h
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:590
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
H264SliceContext::mb_x
int mb_x
Definition: h264dec.h:225
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:696
FF_DECODE_ERROR_DECODE_SLICES
#define FF_DECODE_ERROR_DECODE_SLICES
Definition: frame.h:721
H264SliceContext
Definition: h264dec.h:172
golomb.h
exp golomb vlc stuff
AVCodecInternal::is_copy
int is_copy
When using frame-threaded decoding, this field is set for the first worker thread (e....
Definition: internal.h:54
H264SliceContext::mv_cache
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:293
AV_CODEC_FLAG_OUTPUT_CORRUPT
#define AV_CODEC_FLAG_OUTPUT_CORRUPT
Output even those frames that might be corrupted.
Definition: avcodec.h:232
debug_green_metadata
static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
Definition: h264dec.c:561
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
H264SEIGreenMetaData::percent_non_zero_macroblocks
uint8_t percent_non_zero_macroblocks
Definition: h264_sei.h:111
AVVideoEncParams::delta_qp
int32_t delta_qp[4][2]
Quantisation parameter offset from the base (per-frame) qp for a given plane (first index) and AC/DC ...
Definition: video_enc_params.h:109
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1770
fail
#define fail()
Definition: checkasm.h:179
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1536
ff_refstruct_pool_uninit
static void ff_refstruct_pool_uninit(FFRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
ff_h264_sei_decode
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:231
GetBitContext
Definition: get_bits.h:108
AV_VIDEO_ENC_PARAMS_H264
@ AV_VIDEO_ENC_PARAMS_H264
H.264 stores:
Definition: video_enc_params.h:57
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:525
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
H264Picture::mb_stride
int mb_stride
Definition: h264dec.h:153
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264_parse.h:40
ff_h264_flush_change
void ff_h264_flush_change(H264Context *h)
Definition: h264dec.c:457
finalize_frame
static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
Definition: h264dec.c:937
H264Picture::f_grain
AVFrame * f_grain
Definition: h264dec.h:110
ff_h264_golomb_to_pict_type
const uint8_t ff_h264_golomb_to_pict_type[5]
Definition: h264data.c:37
H264Ref::data
uint8_t * data[3]
Definition: h264dec.h:162
pack16to32
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264_parse.h:127
refstruct.h
AVVideoEncParams
Video encoding parameters for a given frame.
Definition: video_enc_params.h:73
ERContext::mb_num
int mb_num
Definition: error_resilience.h:59
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
ERContext::avctx
AVCodecContext * avctx
Definition: error_resilience.h:53
ff_h264_hl_decode_mb
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
Definition: h264_mb.c:800
avassert.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
h264_decode_frame
static int h264_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h264dec.c:1025
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
h264_free_pic
static void h264_free_pic(H264Context *h, H264Picture *pic)
Definition: h264dec.c:344
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:545
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:589
H2645NAL::size
int size
Definition: h2645_parse.h:36
emms_c
#define emms_c()
Definition: emms.h:63
get_last_needed_nal
static int get_last_needed_nal(H264Context *h)
Definition: h264dec.c:507
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
ff_er_frame_end
void ff_er_frame_end(ERContext *s, int *decode_error_flags)
Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...
Definition: error_resilience.c:892
ff_h264_queue_decode_slice
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
Definition: h264_slice.c:2056
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
h264_init_pic
static int h264_init_pic(H264Picture *pic)
Definition: h264dec.c:276
h264_decode_end
static av_cold int h264_decode_end(AVCodecContext *avctx)
Definition: h264dec.c:351
get_consumed_bytes
static int get_consumed_bytes(int pos, int buf_size)
Return the number of bytes consumed for building the current frame.
Definition: h264dec.c:830
ff_h264_decode_extradata
int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)
Definition: h264_parse.c:464
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:67
avpriv_h264_has_num_reorder_frames
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c:60
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
h264data.h
ff_h264_remove_all_refs
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:576
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ERContext::dc_val
int16_t * dc_val[3]
Definition: error_resilience.h:68
H2645NAL::data
const uint8_t * data
Definition: h2645_parse.h:35
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
ff_h264_decoder
const FFCodec ff_h264_decoder
Definition: h264dec.c:1115
H264Picture::sei_recovery_frame_cnt
int sei_recovery_frame_cnt
Definition: h264dec.h:147
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
ff_h264_draw_horiz_band
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:102
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
threadframe.h
H264SEIGreenMetaData::percent_alpha_point_deblocking_instance
uint8_t percent_alpha_point_deblocking_instance
Definition: h264_sei.h:114
H264_NAL_DPC
@ H264_NAL_DPC
Definition: h264.h:38
H2645NAL::raw_size
int raw_size
Definition: h2645_parse.h:44
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
h264_class
static const AVClass h264_class
Definition: h264dec.c:1108
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
h264_er_decode_mb
static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, int(*mv)[2][4][2], int mb_x, int mb_y, int mb_intra, int mb_skipped)
Definition: h264dec.c:66
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
H264SliceContext::edge_emu_buffer
uint8_t * edge_emu_buffer
Definition: h264dec.h:278
hwaccel_internal.h
AVCodecContext::slice_flags
int slice_flags
slice flags
Definition: avcodec.h:919
h264_init_context
static int h264_init_context(AVCodecContext *avctx, H264Context *h)
Definition: h264dec.c:289
H264Ref::parent
const H264Picture * parent
Definition: h264dec.h:169
H264Ref::linesize
int linesize[3]
Definition: h264dec.h:163
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
profiles.h
ff_h264_profiles
const AVProfile ff_h264_profiles[]
Definition: profiles.c:70
PPS::init_qp
int init_qp
pic_init_qp_minus26 + 26
Definition: h264_ps.h:120
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:367
H264Picture::mb_height
int mb_height
Definition: h264dec.h:152
H264SEIGreenMetaData
Definition: h264_sei.h:106
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:281
FF_HW_HAS_CB
#define FF_HW_HAS_CB(avctx, function)
Definition: hwaccel_internal.h:177
H264SliceContext::top_borders_allocated
int top_borders_allocated[2]
Definition: h264dec.h:282
H264_NAL_END_STREAM
@ H264_NAL_END_STREAM
Definition: h264.h:45
atomic_load_explicit
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
AVOnce
#define AVOnce
Definition: thread.h:202
H264SEIGreenMetaData::percent_intra_coded_macroblocks
uint8_t percent_intra_coded_macroblocks
Definition: h264_sei.h:112
h264_ps.h
h264_vlc_init
static AVOnce h264_vlc_init
Definition: h264dec.c:382
DELAYED_PIC_REF
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output.
Definition: diracdec.c:67
av_video_enc_params_create_side_data
AVVideoEncParams * av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type, unsigned int nb_blocks)
Allocates memory for AVEncodeInfoFrame plus an array of.
Definition: video_enc_params.c:58
ERContext::opaque
void * opaque
Definition: error_resilience.h:88
f
f
Definition: af_crystalizer.c:121
H264SEIGreenMetaData::percent_six_tap_filtering
uint8_t percent_six_tap_filtering
Definition: h264_sei.h:113
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:532
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:523
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:361
h264_options
static const AVOption h264_options[]
Definition: h264dec.c:1098
codec_internal.h
H264SEIGreenMetaData::num_seconds
uint16_t num_seconds
Definition: h264_sei.h:109
rectangle.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: codec_internal.h:60
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:341
ERContext::b8_stride
ptrdiff_t b8_stride
Definition: error_resilience.h:62
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: codec_internal.h:69
H264Picture::decode_error_flags
atomic_int * decode_error_flags
RefStruct reference; its pointee is shared between decoding threads.
Definition: h264dec.h:156
H2645NAL::gb
GetBitContext gb
Definition: h2645_parse.h:47
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
H2645NAL
Definition: h2645_parse.h:34
H264SliceContext::top_borders
uint8_t(*[2] top_borders)[(16 *3) *2]
Definition: h264dec.h:279
H264SEIGreenMetaData::green_metadata_type
uint8_t green_metadata_type
Definition: h264_sei.h:107
ERContext::mb_stride
ptrdiff_t mb_stride
Definition: error_resilience.h:61
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1548
AVCodecHWConfigInternal
Definition: hwconfig.h:25
H264SliceContext::mb_y
int mb_y
Definition: h264dec.h:225
av_frame_remove_side_data
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type.
Definition: frame.c:919
ff_h2645_packet_split
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)
Split an input packet into NAL units.
Definition: h2645_parse.c:464
height
#define height
ERContext::decode_mb
void(* decode_mb)(void *opaque, int ref, int mv_dir, int mv_type, int(*mv)[2][4][2], int mb_x, int mb_y, int mb_intra, int mb_skipped)
Definition: error_resilience.h:85
VD
#define VD
Definition: av1dec.c:1479
output_frame
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
Definition: h264dec.c:874
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:78
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1547
H264SliceContext::mb_mbaff
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:237
emms.h
h264dec.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:284
H264Picture::needs_fg
int needs_fg
whether picture needs film grain synthesis (see f_grain)
Definition: h264dec.h:148
is_avcc_extradata
static int is_avcc_extradata(const uint8_t *buf, int buf_size)
Definition: h264dec.c:913
H264Context
H264Context.
Definition: h264dec.h:332
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AV_CODEC_FLAG2_SHOW_ALL
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:380
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:546
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:252
H264_NAL_END_SEQUENCE
@ H264_NAL_END_SEQUENCE
Definition: h264.h:44
ff_h264_execute_decode_slices
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
Definition: h264_slice.c:2763
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
ERContext::mb_width
int mb_width
Definition: error_resilience.h:60
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
AVVideoBlockParams
Data structure for storing block-level encoding information.
Definition: video_enc_params.h:120
ff_h264_decode_init_vlc
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:315
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
ff_h264_alloc_tables
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
Definition: h264dec.c:185
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
avcodec.h
h264_export_enc_params
static int h264_export_enc_params(AVFrame *f, const H264Picture *p)
Definition: h264dec.c:840
AVFrame::decode_error_flags
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
Definition: frame.h:717
ret
ret
Definition: filter_design.txt:187
H2645NAL::raw_data
const uint8_t * raw_data
Definition: h2645_parse.h:45
ERContext::mb_height
int mb_height
Definition: error_resilience.h:60
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
FMO
#define FMO
Definition: h264dec.h:55
FF_DEBUG_GREEN_MD
#define FF_DEBUG_GREEN_MD
Definition: avcodec.h:1406
pos
unsigned int pos
Definition: spdifenc.c:413
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
Definition: avcodec.h:415
AV_CODEC_FLAG2_CHUNKS
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
Definition: avcodec.h:371
AVCodecContext::draw_horiz_band
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band.
Definition: avcodec.h:687
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:76
OFFSET
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1555
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
H264SliceContext::bipred_scratchpad
uint8_t * bipred_scratchpad
Definition: h264dec.h:277
error_resilience.h
FF_HW_CALL
#define FF_HW_CALL(avctx, function,...)
Definition: hwaccel_internal.h:171
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
H264Picture::mb_width
int mb_width
Definition: h264dec.h:152
ff_h264_unref_picture
void ff_h264_unref_picture(H264Picture *pic)
Definition: h264_picture.c:39
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:708
atomic_fetch_or_explicit
#define atomic_fetch_or_explicit(object, operand, order)
Definition: stdatomic.h:155
fill_rectangle
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:829
H264Picture
Definition: h264dec.h:106
ERContext::error_status_table
uint8_t * error_status_table
Definition: error_resilience.h:66
ERContext::quarter_sample
int quarter_sample
Definition: error_resilience.h:82
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:583
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
PART_NOT_AVAILABLE
#define PART_NOT_AVAILABLE
Definition: h264pred.h:89
ff_h264_field_end
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:189
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1392
H264_NAL_AUXILIARY_SLICE
@ H264_NAL_AUXILIARY_SLICE
Definition: h264.h:53
H264SliceContext::ref_list
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:264
H264SliceContext::non_zero_count_cache
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:288
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
ERContext::er_temp_buffer
uint8_t * er_temp_buffer
Definition: error_resilience.h:67
h264_decode_flush
static void h264_decode_flush(AVCodecContext *avctx)
Definition: h264dec.c:482
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
ff_h264_sei_stereo_mode
const char * ff_h264_sei_stereo_mode(const H2645SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:306
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
H264SliceContext::er
ERContext * er
Definition: h264dec.h:175
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
h264.h
H264_NAL_DPA
@ H264_NAL_DPA
Definition: h264.h:36
imgutils.h
H264SliceContext::edge_emu_buffer_allocated
int edge_emu_buffer_allocated
Definition: h264dec.h:281
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
UPDATE_THREAD_CONTEXT_FOR_USER
#define UPDATE_THREAD_CONTEXT_FOR_USER(func)
Definition: codec_internal.h:283
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_video_enc_params_block
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
Get the block at the specified.
Definition: video_enc_params.h:143
h
h
Definition: vp9dsp_template.c:2038
H264_MAX_PICTURE_COUNT
#define H264_MAX_PICTURE_COUNT
Definition: h264dec.h:49
H264SEIGreenMetaData::num_pictures
uint16_t num_pictures
Definition: h264_sei.h:110
H264SliceContext::bipred_scratchpad_allocated
int bipred_scratchpad_allocated
Definition: h264dec.h:280
av_image_copy
void av_image_copy(uint8_t *const dst_data[4], const int dst_linesizes[4], const uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
Definition: imgutils.c:422
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:215
int
int
Definition: ffmpeg_filter.c:424
send_next_delayed_frame
static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame, int *got_frame, int buf_index)
Definition: h264dec.c:992
H264Ref::reference
int reference
Definition: h264dec.h:165
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:420
video_enc_params.h
ff_print_debug_info2
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, const uint8_t *mbskip_table, const uint32_t *mbtype_table, const int8_t *qscale_table, int16_t(*const motion_val[2])[2], int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:159
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
H264SliceContext::mb_field_decoding_flag
int mb_field_decoding_flag
Definition: h264dec.h:236
ff_h264_set_erpic
void ff_h264_set_erpic(ERPicture *dst, const H264Picture *src)
Definition: h264_picture.c:166
H264_NAL_SPS_EXT
@ H264_NAL_SPS_EXT
Definition: h264.h:47
H264SEIGreenMetaData::xsd_metric_type
uint8_t xsd_metric_type
Definition: h264_sei.h:115