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