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 
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);
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 
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) ||
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);
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 
279 {
280  int i;
281 
282  h->avctx = avctx;
283  h->cur_chroma_format_idc = -1;
284 
285  h->width_from_caller = avctx->width;
286  h->height_from_caller = avctx->height;
287 
288  h->workaround_bugs = avctx->workaround_bugs;
289  h->flags = avctx->flags;
290  h->poc.prev_poc_msb = 1 << 16;
291  h->recovery_frame = -1;
292  h->frame_recovered = 0;
293  h->poc.prev_frame_num = -1;
295  h->sei.unregistered.x264_build = -1;
296 
297  h->next_outputed_poc = INT_MIN;
298  for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
299  h->last_pocs[i] = INT_MIN;
300 
301  ff_h264_sei_uninit(&h->sei);
302 
303  h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
304  h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));
305  if (!h->slice_ctx) {
306  h->nb_slice_ctx = 0;
307  return AVERROR(ENOMEM);
308  }
309 
310  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
311  h->DPB[i].f = av_frame_alloc();
312  if (!h->DPB[i].f)
313  return AVERROR(ENOMEM);
314  }
315 
316  h->cur_pic.f = av_frame_alloc();
317  if (!h->cur_pic.f)
318  return AVERROR(ENOMEM);
319 
321  if (!h->last_pic_for_ec.f)
322  return AVERROR(ENOMEM);
323 
324  for (i = 0; i < h->nb_slice_ctx; i++)
325  h->slice_ctx[i].h264 = h;
326 
327  return 0;
328 }
329 
331 {
332  H264Context *h = avctx->priv_data;
333  int i;
334 
337 
338  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
339  ff_h264_unref_picture(h, &h->DPB[i]);
340  av_frame_free(&h->DPB[i].f);
341  }
342  memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
343 
344  h->cur_pic_ptr = NULL;
345 
346  av_freep(&h->slice_ctx);
347  h->nb_slice_ctx = 0;
348 
349  ff_h264_sei_uninit(&h->sei);
350  ff_h264_ps_uninit(&h->ps);
351 
353 
355  av_frame_free(&h->cur_pic.f);
358 
359  return 0;
360 }
361 
363 
365 {
366  H264Context *h = avctx->priv_data;
367  int ret;
368 
369  ret = h264_init_context(avctx, h);
370  if (ret < 0)
371  return ret;
372 
373  ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc);
374  if (ret != 0) {
375  av_log(avctx, AV_LOG_ERROR, "pthread_once has failed.");
376  return AVERROR_UNKNOWN;
377  }
378 
379  if (avctx->ticks_per_frame == 1) {
380  if(h->avctx->time_base.den < INT_MAX/2) {
381  h->avctx->time_base.den *= 2;
382  } else
383  h->avctx->time_base.num /= 2;
384  }
385  avctx->ticks_per_frame = 2;
386 
387  if (!avctx->internal->is_copy) {
388  if (avctx->extradata_size > 0 && avctx->extradata) {
390  &h->ps, &h->is_avc, &h->nal_length_size,
391  avctx->err_recognition, avctx);
392  if (ret < 0) {
393  int explode = avctx->err_recognition & AV_EF_EXPLODE;
394  av_log(avctx, explode ? AV_LOG_ERROR: AV_LOG_WARNING,
395  "Error decoding the extradata\n");
396  if (explode) {
397  return ret;
398  }
399  ret = 0;
400  }
401  }
402  }
403 
404  if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&
407  }
408 
410 
411  if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
412  h->enable_er = 0;
413 
414  if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {
415  av_log(avctx, AV_LOG_WARNING,
416  "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
417  "Use it at your own risk\n");
418  }
419 
420  return 0;
421 }
422 
423 /**
424  * instantaneous decoder refresh.
425  */
426 static void idr(H264Context *h)
427 {
428  int i;
430  h->poc.prev_frame_num =
431  h->poc.prev_frame_num_offset = 0;
432  h->poc.prev_poc_msb = 1<<16;
433  h->poc.prev_poc_lsb = -1;
434  for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
435  h->last_pocs[i] = INT_MIN;
436 }
437 
438 /* forget old pics after a seek */
440 {
441  int i, j;
442 
443  h->next_outputed_poc = INT_MIN;
444  h->prev_interlaced_frame = 1;
445  idr(h);
446 
447  h->poc.prev_frame_num = -1;
448  if (h->cur_pic_ptr) {
449  h->cur_pic_ptr->reference = 0;
450  for (j=i=0; h->delayed_pic[i]; i++)
451  if (h->delayed_pic[i] != h->cur_pic_ptr)
452  h->delayed_pic[j++] = h->delayed_pic[i];
453  h->delayed_pic[j] = NULL;
454  }
456 
457  h->first_field = 0;
458  h->recovery_frame = -1;
459  h->frame_recovered = 0;
460  h->current_slice = 0;
461  h->mmco_reset = 1;
462 }
463 
465 {
466  H264Context *h = avctx->priv_data;
467  int i;
468 
469  memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
470 
472  ff_h264_sei_uninit(&h->sei);
473 
474  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
475  ff_h264_unref_picture(h, &h->DPB[i]);
476  h->cur_pic_ptr = NULL;
478 
479  h->mb_y = 0;
480 
482  h->context_initialized = 0;
483 }
484 
486 {
487  int nals_needed = 0;
488  int first_slice = 0;
489  int i, ret;
490 
491  for (i = 0; i < h->pkt.nb_nals; i++) {
492  H2645NAL *nal = &h->pkt.nals[i];
493  GetBitContext gb;
494 
495  /* packets can sometimes contain multiple PPS/SPS,
496  * e.g. two PAFF field pictures in one packet, or a demuxer
497  * which splits NALs strangely if so, when frame threading we
498  * can't start the next thread until we've read all of them */
499  switch (nal->type) {
500  case H264_NAL_SPS:
501  case H264_NAL_PPS:
502  nals_needed = i;
503  break;
504  case H264_NAL_DPA:
505  case H264_NAL_IDR_SLICE:
506  case H264_NAL_SLICE:
507  ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);
508  if (ret < 0) {
509  av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");
511  return ret;
512 
513  break;
514  }
515  if (!get_ue_golomb_long(&gb) || // first_mb_in_slice
516  !first_slice ||
517  first_slice != nal->type)
518  nals_needed = i;
519  if (!first_slice)
520  first_slice = nal->type;
521  }
522  }
523 
524  return nals_needed;
525 }
526 
527 static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
528 {
529  av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n");
530  av_log(logctx, AV_LOG_DEBUG, " green_metadata_type: %d\n", gm->green_metadata_type);
531 
532  if (gm->green_metadata_type == 0) {
533  av_log(logctx, AV_LOG_DEBUG, " green_metadata_period_type: %d\n", gm->period_type);
534 
535  if (gm->period_type == 2)
536  av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_seconds: %d\n", gm->num_seconds);
537  else if (gm->period_type == 3)
538  av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_pictures: %d\n", gm->num_pictures);
539 
540  av_log(logctx, AV_LOG_DEBUG, " SEI GREEN Complexity Metrics: %f %f %f %f\n",
541  (float)gm->percent_non_zero_macroblocks/255,
542  (float)gm->percent_intra_coded_macroblocks/255,
543  (float)gm->percent_six_tap_filtering/255,
545 
546  } else if (gm->green_metadata_type == 1) {
547  av_log(logctx, AV_LOG_DEBUG, " xsd_metric_type: %d\n", gm->xsd_metric_type);
548 
549  if (gm->xsd_metric_type == 0)
550  av_log(logctx, AV_LOG_DEBUG, " xsd_metric_value: %f\n",
551  (float)gm->xsd_metric_value/100);
552  }
553 }
554 
555 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
556 {
557  AVCodecContext *const avctx = h->avctx;
558  int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
559  int idr_cleared=0;
560  int i, ret = 0;
561 
562  h->has_slice = 0;
563  h->nal_unit_type= 0;
564 
565  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
566  h->current_slice = 0;
567  if (!h->first_field) {
568  h->cur_pic_ptr = NULL;
569  ff_h264_sei_uninit(&h->sei);
570  }
571  }
572 
573  if (h->nal_length_size == 4) {
574  if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
575  h->is_avc = 0;
576  }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
577  h->is_avc = 1;
578  }
579 
580  ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc, h->nal_length_size,
581  avctx->codec_id, 0, 0);
582  if (ret < 0) {
583  av_log(avctx, AV_LOG_ERROR,
584  "Error splitting the input into NAL units.\n");
585  return ret;
586  }
587 
588  if (avctx->active_thread_type & FF_THREAD_FRAME)
589  nals_needed = get_last_needed_nal(h);
590  if (nals_needed < 0)
591  return nals_needed;
592 
593  for (i = 0; i < h->pkt.nb_nals; i++) {
594  H2645NAL *nal = &h->pkt.nals[i];
595  int max_slice_ctx, err;
596 
597  if (avctx->skip_frame >= AVDISCARD_NONREF &&
598  nal->ref_idc == 0 && nal->type != H264_NAL_SEI)
599  continue;
600 
601  // FIXME these should stop being context-global variables
602  h->nal_ref_idc = nal->ref_idc;
603  h->nal_unit_type = nal->type;
604 
605  err = 0;
606  switch (nal->type) {
607  case H264_NAL_IDR_SLICE:
608  if ((nal->data[1] & 0xFC) == 0x98) {
609  av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");
610  h->next_outputed_poc = INT_MIN;
611  ret = -1;
612  goto end;
613  }
614  if(!idr_cleared) {
615  idr(h); // FIXME ensure we don't lose some frames if there is reordering
616  }
617  idr_cleared = 1;
618  h->has_recovery_point = 1;
619  case H264_NAL_SLICE:
620  h->has_slice = 1;
621 
622  if ((err = ff_h264_queue_decode_slice(h, nal))) {
624  sl->ref_count[0] = sl->ref_count[1] = 0;
625  break;
626  }
627 
628  if (h->current_slice == 1) {
629  if (avctx->active_thread_type & FF_THREAD_FRAME &&
630  i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {
631  ff_thread_finish_setup(avctx);
632  h->setup_finished = 1;
633  }
634 
635  if (h->avctx->hwaccel &&
636  (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)
637  goto end;
638  }
639 
640  max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;
641  if (h->nb_slice_ctx_queued == max_slice_ctx) {
642  if (h->avctx->hwaccel) {
643  ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
644  h->nb_slice_ctx_queued = 0;
645  } else
647  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
648  goto end;
649  }
650  break;
651  case H264_NAL_DPA:
652  case H264_NAL_DPB:
653  case H264_NAL_DPC:
654  avpriv_request_sample(avctx, "data partitioning");
655  break;
656  case H264_NAL_SEI:
657  ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
659  if (avctx->debug & FF_DEBUG_GREEN_MD)
661  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
662  goto end;
663  break;
664  case H264_NAL_SPS: {
665  GetBitContext tmp_gb = nal->gb;
666  if (avctx->hwaccel && avctx->hwaccel->decode_params) {
667  ret = avctx->hwaccel->decode_params(avctx,
668  nal->type,
669  nal->raw_data,
670  nal->raw_size);
671  if (ret < 0)
672  goto end;
673  }
674  if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
675  break;
677  "SPS decoding failure, trying again with the complete NAL\n");
678  init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
679  if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
680  break;
681  ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);
682  break;
683  }
684  case H264_NAL_PPS:
685  if (avctx->hwaccel && avctx->hwaccel->decode_params) {
686  ret = avctx->hwaccel->decode_params(avctx,
687  nal->type,
688  nal->raw_data,
689  nal->raw_size);
690  if (ret < 0)
691  goto end;
692  }
693  ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
694  nal->size_bits);
695  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
696  goto end;
697  break;
698  case H264_NAL_AUD:
700  case H264_NAL_END_STREAM:
702  case H264_NAL_SPS_EXT:
704  break;
705  default:
706  av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
707  nal->type, nal->size_bits);
708  }
709 
710  if (err < 0) {
711  av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
712  }
713  }
714 
716  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
717  goto end;
718 
719  // set decode_error_flags to allow users to detect concealed decoding errors
720  if ((ret < 0 || h->slice_ctx->er.error_occurred) && h->cur_pic_ptr) {
722  }
723 
724  ret = 0;
725 end:
726 
727 #if CONFIG_ERROR_RESILIENCE
728  /*
729  * FIXME: Error handling code does not seem to support interlaced
730  * when slices span multiple rows
731  * The ff_er_add_slice calls don't work right for bottom
732  * fields; they cause massive erroneous error concealing
733  * Error marking covers both fields (top and bottom).
734  * This causes a mismatched s->error_count
735  * and a bad error table. Further, the error count goes to
736  * INT_MAX when called for bottom field, because mb_y is
737  * past end by one (callers fault) and resync_mb_y != 0
738  * causes problems for the first MB line, too.
739  */
740  if (!FIELD_PICTURE(h) && h->current_slice && h->enable_er) {
741 
742  H264SliceContext *sl = h->slice_ctx;
743  int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
744 
746 
747  if (use_last_pic) {
749  sl->ref_list[0][0].parent = &h->last_pic_for_ec;
750  memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
751  memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
753  } else if (sl->ref_count[0]) {
754  ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
755  } else
757 
758  if (sl->ref_count[1])
759  ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);
760 
761  sl->er.ref_count = sl->ref_count[0];
762 
763  ff_er_frame_end(&sl->er);
764  if (use_last_pic)
765  memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
766  }
767 #endif /* CONFIG_ERROR_RESILIENCE */
768  /* clean up */
769  if (h->cur_pic_ptr && !h->droppable && h->has_slice) {
772  }
773 
774  return (ret < 0) ? ret : buf_size;
775 }
776 
777 /**
778  * Return the number of bytes consumed for building the current frame.
779  */
780 static int get_consumed_bytes(int pos, int buf_size)
781 {
782  if (pos == 0)
783  pos = 1; // avoid infinite loops (I doubt that is needed but...)
784  if (pos + 10 > buf_size)
785  pos = buf_size; // oops ;)
786 
787  return pos;
788 }
789 
791 {
792  AVVideoEncParams *par;
793  unsigned int nb_mb = p->mb_height * p->mb_width;
794  unsigned int x, y;
795 
797  if (!par)
798  return AVERROR(ENOMEM);
799 
800  par->qp = p->pps->init_qp;
801 
802  par->delta_qp[1][0] = p->pps->chroma_qp_index_offset[0];
803  par->delta_qp[1][1] = p->pps->chroma_qp_index_offset[0];
804  par->delta_qp[2][0] = p->pps->chroma_qp_index_offset[1];
805  par->delta_qp[2][1] = p->pps->chroma_qp_index_offset[1];
806 
807  for (y = 0; y < p->mb_height; y++)
808  for (x = 0; x < p->mb_width; x++) {
809  const unsigned int block_idx = y * p->mb_width + x;
810  const unsigned int mb_xy = y * p->mb_stride + x;
812 
813  b->src_x = x * 16;
814  b->src_y = y * 16;
815  b->w = 16;
816  b->h = 16;
817 
818  b->delta_qp = p->qscale_table[mb_xy] - par->qp;
819  }
820 
821  return 0;
822 }
823 
824 static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
825 {
826  AVFrame *src = srcp->f;
827  int ret;
828 
829  ret = av_frame_ref(dst, src);
830  if (ret < 0)
831  return ret;
832 
833  av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);
834 
835  if (srcp->sei_recovery_frame_cnt == 0)
836  dst->key_frame = 1;
837 
839  ret = h264_export_enc_params(dst, srcp);
840  if (ret < 0)
841  goto fail;
842  }
843 
844  return 0;
845 fail:
846  av_frame_unref(dst);
847  return ret;
848 }
849 
850 static int is_avcc_extradata(const uint8_t *buf, int buf_size)
851 {
852  int cnt= buf[5]&0x1f;
853  const uint8_t *p= buf+6;
854  if (!cnt)
855  return 0;
856  while(cnt--){
857  int nalsize= AV_RB16(p) + 2;
858  if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
859  return 0;
860  p += nalsize;
861  }
862  cnt = *(p++);
863  if(!cnt)
864  return 0;
865  while(cnt--){
866  int nalsize= AV_RB16(p) + 2;
867  if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
868  return 0;
869  p += nalsize;
870  }
871  return 1;
872 }
873 
874 static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
875 {
876  int ret;
877 
880  out->recovered)) {
881 
882  if (!h->avctx->hwaccel &&
883  (out->field_poc[0] == INT_MAX ||
884  out->field_poc[1] == INT_MAX)
885  ) {
886  int p;
887  AVFrame *f = out->f;
888  int field = out->field_poc[0] == INT_MAX;
889  uint8_t *dst_data[4];
890  int linesizes[4];
891  const uint8_t *src_data[4];
892 
893  av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
894 
895  for (p = 0; p<4; p++) {
896  dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
897  src_data[p] = f->data[p] + field *f->linesize[p];
898  linesizes[p] = 2*f->linesize[p];
899  }
900 
901  av_image_copy(dst_data, linesizes, src_data, linesizes,
902  f->format, f->width, f->height>>1);
903  }
904 
905  ret = output_frame(h, dst, out);
906  if (ret < 0)
907  return ret;
908 
909  *got_frame = 1;
910 
911  if (CONFIG_MPEGVIDEO) {
913  out->mb_type,
914  out->qscale_table,
915  out->motion_val,
916  NULL,
917  h->mb_width, h->mb_height, h->mb_stride, 1);
918  }
919  }
920 
921  return 0;
922 }
923 
925  int *got_frame, int buf_index)
926 {
927  int ret, i, out_idx;
928  H264Picture *out = h->delayed_pic[0];
929 
930  h->cur_pic_ptr = NULL;
931  h->first_field = 0;
932 
933  out_idx = 0;
934  for (i = 1;
935  h->delayed_pic[i] &&
936  !h->delayed_pic[i]->f->key_frame &&
937  !h->delayed_pic[i]->mmco_reset;
938  i++)
939  if (h->delayed_pic[i]->poc < out->poc) {
940  out = h->delayed_pic[i];
941  out_idx = i;
942  }
943 
944  for (i = out_idx; h->delayed_pic[i]; i++)
945  h->delayed_pic[i] = h->delayed_pic[i + 1];
946 
947  if (out) {
948  out->reference &= ~DELAYED_PIC_REF;
949  ret = finalize_frame(h, dst_frame, out, got_frame);
950  if (ret < 0)
951  return ret;
952  }
953 
954  return buf_index;
955 }
956 
957 static int h264_decode_frame(AVCodecContext *avctx, void *data,
958  int *got_frame, AVPacket *avpkt)
959 {
960  const uint8_t *buf = avpkt->data;
961  int buf_size = avpkt->size;
962  H264Context *h = avctx->priv_data;
963  AVFrame *pict = data;
964  int buf_index;
965  int ret;
966 
967  h->flags = avctx->flags;
968  h->setup_finished = 0;
969  h->nb_slice_ctx_queued = 0;
970 
972 
973  /* end of stream, output what is still in the buffers */
974  if (buf_size == 0)
975  return send_next_delayed_frame(h, pict, got_frame, 0);
976 
978  int side_size;
979  uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
980  ff_h264_decode_extradata(side, side_size,
981  &h->ps, &h->is_avc, &h->nal_length_size,
982  avctx->err_recognition, avctx);
983  }
984  if (h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) {
985  if (is_avcc_extradata(buf, buf_size))
986  return ff_h264_decode_extradata(buf, buf_size,
987  &h->ps, &h->is_avc, &h->nal_length_size,
988  avctx->err_recognition, avctx);
989  }
990 
991  buf_index = decode_nal_units(h, buf, buf_size);
992  if (buf_index < 0)
993  return AVERROR_INVALIDDATA;
994 
996  av_assert0(buf_index <= buf_size);
997  return send_next_delayed_frame(h, pict, got_frame, buf_index);
998  }
999 
1000  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {
1001  if (avctx->skip_frame >= AVDISCARD_NONREF ||
1002  buf_size >= 4 && !memcmp("Q264", buf, 4))
1003  return buf_size;
1004  av_log(avctx, AV_LOG_ERROR, "no frame!\n");
1005  return AVERROR_INVALIDDATA;
1006  }
1007 
1008  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
1009  (h->mb_y >= h->mb_height && h->mb_height)) {
1010  if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)
1011  return ret;
1012 
1013  /* Wait for second field. */
1014  if (h->next_output_pic) {
1015  ret = finalize_frame(h, pict, h->next_output_pic, got_frame);
1016  if (ret < 0)
1017  return ret;
1018  }
1019  }
1020 
1021  av_assert0(pict->buf[0] || !*got_frame);
1022 
1024 
1025  return get_consumed_bytes(buf_index, buf_size);
1026 }
1027 
1028 #define OFFSET(x) offsetof(H264Context, x)
1029 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1030 static const AVOption h264_options[] = {
1031  { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 },
1032  { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },
1033  { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },
1034  { "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 },
1035  { NULL },
1036 };
1037 
1038 static const AVClass h264_class = {
1039  .class_name = "H264 Decoder",
1040  .item_name = av_default_item_name,
1041  .option = h264_options,
1042  .version = LIBAVUTIL_VERSION_INT,
1043 };
1044 
1046  .name = "h264",
1047  .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1048  .type = AVMEDIA_TYPE_VIDEO,
1049  .id = AV_CODEC_ID_H264,
1050  .priv_data_size = sizeof(H264Context),
1052  .close = h264_decode_end,
1054  .capabilities = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 |
1057  .hw_configs = (const AVCodecHWConfigInternal*[]) {
1058 #if CONFIG_H264_DXVA2_HWACCEL
1059  HWACCEL_DXVA2(h264),
1060 #endif
1061 #if CONFIG_H264_D3D11VA_HWACCEL
1062  HWACCEL_D3D11VA(h264),
1063 #endif
1064 #if CONFIG_H264_D3D11VA2_HWACCEL
1065  HWACCEL_D3D11VA2(h264),
1066 #endif
1067 #if CONFIG_H264_NVDEC_HWACCEL
1068  HWACCEL_NVDEC(h264),
1069 #endif
1070 #if CONFIG_H264_VAAPI_HWACCEL
1071  HWACCEL_VAAPI(h264),
1072 #endif
1073 #if CONFIG_H264_VDPAU_HWACCEL
1074  HWACCEL_VDPAU(h264),
1075 #endif
1076 #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
1077  HWACCEL_VIDEOTOOLBOX(h264),
1078 #endif
1079  NULL
1080  },
1083  .flush = h264_decode_flush,
1084  .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
1086  .priv_class = &h264_class,
1087 };
#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:48
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
Definition: h264_ps.c:749
struct H264Context * h264
Definition: h264dec.h:184
static int h264_export_enc_params(AVFrame *f, H264Picture *p)
Definition: h264dec.c:790
#define NULL
Definition: coverity.c:32
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
Definition: avcodec.h:412
int workaround_bugs
Definition: h264dec.h:373
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int sei_recovery_frame_cnt
Definition: h264dec.h:163
#define AV_NUM_DATA_POINTERS
Definition: frame.h:309
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
Definition: avcodec.h:1006
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
Definition: h264_slice.c:2083
H264POCContext poc
Definition: h264dec.h:466
static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame, int *got_frame, int buf_index)
Definition: h264dec.c:924
int mb_num
Definition: h264dec.h:443
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:141
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:305
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int size
Definition: h2645_parse.h:35
int edge_emu_buffer_allocated
Definition: h264dec.h:293
uint16_t num_pictures
Definition: h264_sei.h:170
static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
Definition: h264dec.c:527
int32_t qp
Base quantisation parameter for the frame.
int first_field
Definition: h264dec.h:414
const char * desc
Definition: libsvtav1.c:79
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int chroma_qp_index_offset[2]
Definition: h264_ps.h:122
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:499
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint16_t * cbp_table
Definition: h264dec.h:419
#define avpriv_request_sample(...)
void ff_er_frame_end(ERContext *s)
int32_t delta_qp
Difference between this block&#39;s final quantization parameter and the corresponding per-frame value...
int mb_y
Definition: h264dec.h:440
int bitstream_restriction_flag
Definition: h264_ps.h:87
int num
Numerator.
Definition: rational.h:59
int bipred_scratchpad_allocated
Definition: h264dec.h:292
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:71
int size
Definition: packet.h:364
#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
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVBufferPool * mb_type_pool
Definition: h264dec.h:556
static void idr(H264Context *h)
instantaneous decoder refresh.
Definition: h264dec.c:426
int16_t(*[2] motion_val)[2]
Definition: h264dec.h:136
int flags
Definition: h264dec.h:372
void ff_h264_flush_change(H264Context *h)
Definition: h264dec.c:439
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
int mb_height
Definition: h264dec.h:441
H264Picture * delayed_pic[MAX_DELAYED_PIC_COUNT+2]
Definition: h264dec.h:471
int is_avc
Used to parse AVC variant of H.264.
Definition: h264dec.h:456
AVBufferPool * ref_index_pool
Definition: h264dec.h:558
int height_from_caller
Definition: h264dec.h:549
int src_x
Distance in luma pixels from the top-left corner of the visible frame to the top-left corner of the b...
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:42
ERPicture last_pic
H264Context.
Definition: h264dec.h:343
AVFrame * f
Definition: h264dec.h:129
const PPS * pps
Definition: h264dec.h:166
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries...
Definition: avcodec.h:367
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:91
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1690
AVCodec.
Definition: codec.h:190
int picture_structure
Definition: h264dec.h:413
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
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, &#39;draw_horiz_band&#39; is called by the libavcodec decoder to draw a horizontal band...
Definition: avcodec.h:761
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:273
int size_bits
Size, in bits, of just the data, excluding the stop bit and any trailing padding. ...
Definition: h2645_parse.h:42
H264SEIGreenMetaData green_metadata
Definition: h264_sei.h:193
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:296
uint8_t * chroma_pred_mode_table
Definition: h264dec.h:422
int32_t delta_qp[4][2]
Quantisation parameter offset from the base (per-frame) qp for a given plane (first index) and AC/DC ...
int setup_finished
Definition: h264dec.h:540
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:565
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2004
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
Definition: h264_slice.c:2792
H264SEIContext sei
Definition: h264dec.h:553
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c:61
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:467
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:72
#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:75
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static int get_consumed_bytes(int pos, int buf_size)
Return the number of bytes consumed for building the current frame.
Definition: h264dec.c:780
ptrdiff_t b8_stride
#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:40
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
Definition: avcodec.h:2354
uint8_t
#define av_cold
Definition: attributes.h:88
uint8_t green_metadata_type
Definition: h264_sei.h:167
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:75
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:2486
AVOptions.
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
Definition: h264_picture.c:136
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
Definition: h264_mb.c:799
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
int poc
frame POC
Definition: h264dec.h:148
#define f(width, name)
Definition: cbs_vp9.c:255
Data structure for storing block-level encoding information.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
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:443
static int get_last_needed_nal(H264Context *h)
Definition: h264dec.c:485
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
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
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:91
uint8_t(*[2] top_borders)[(16 *3)*2]
Definition: h264dec.h:291
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:523
ERPicture cur_pic
int frame_recovered
Initial frame has been completely recovered.
Definition: h264dec.h:530
int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)
Definition: h264_parse.c:462
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define height
uint8_t * data
Definition: packet.h:363
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
Definition: h264dec.c:555
AVDictionary * metadata
metadata.
Definition: frame.h:594
int has_slice
slice NAL is found in the packet, set by decode_nal_units, its state does not need to be preserved ou...
Definition: h264dec.h:451
static int h264_init_context(AVCodecContext *avctx, H264Context *h)
Definition: h264dec.c:278
H264Picture * parent
Definition: h264dec.h:180
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:161
#define AVOnce
Definition: thread.h:172
#define av_log(a,...)
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:75
int last_pocs[MAX_DELAYED_PIC_COUNT]
Definition: h264dec.h:472
uint16_t num_seconds
Definition: h264_sei.h:169
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:79
uint8_t percent_six_tap_filtering
Definition: h264_sei.h:173
H.264 common definitions.
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:103
#define src
Definition: vp8dsp.c:254
H.264 parameter set handling.
H264Picture DPB[H264_MAX_PICTURE_COUNT]
Definition: h264dec.h:351
int width
Definition: frame.h:366
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static const AVClass h264_class
Definition: h264dec.c:1038
int16_t * dc_val_base
Definition: h264dec.h:287
int context_initialized
Definition: h264dec.h:371
ERContext er
Definition: h264dec.h:186
int nal_unit_type
Definition: h264dec.h:449
int num_reorder_frames
Definition: h264_ps.h:88
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:126
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
static const AVOption h264_options[]
Definition: h264dec.c:1030
Display matrix.
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1804
H2645Packet pkt
Definition: h264dec.h:360
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define FIELD_PICTURE(h)
Definition: h264dec.h:74
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 local see the OFFSET() macro
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:423
static av_cold int h264_decode_end(AVCodecContext *avctx)
Definition: h264dec.c:330
int prev_interlaced_frame
Complement sei_pic_struct SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced...
Definition: h264dec.h:504
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
Definition: h264dec.c:874
ThreadFrame tf
Definition: h264dec.h:130
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: codec.h:197
H264SEIUnregistered unregistered
Definition: h264_sei.h:188
uint8_t * list_counts
Array of list_count per MB specifying the slice type.
Definition: h264dec.h:416
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:123
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
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
int * mb_index2xy
int raw_size
Definition: h2645_parse.h:44
uint8_t percent_non_zero_macroblocks
Definition: h264_sei.h:171
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: internal.h:66
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:192
uint8_t * error_status_table
uint8_t * direct_table
Definition: h264dec.h:424
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: h264dec.h:457
useful rectangle filling function
uint8_t * data[3]
Definition: h264dec.h:173
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:49
#define b
Definition: input.c:41
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1655
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1796
uint32_t * mb2br_xy
Definition: h264dec.h:406
uint8_t * er_temp_buffer
#define FFMIN(a, b)
Definition: common.h:96
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264dec.h:409
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
Video encoding parameters for a given frame.
int reference
Definition: h264dec.h:160
int w
Width and height of the block in luma pixels.
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
int width
picture width / height.
Definition: avcodec.h:699
int nb_slice_ctx
Definition: h264dec.h:357
uint32_t * mb_type
Definition: h264dec.h:139
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1797
Context Adaptive Binary Arithmetic Coder inline functions.
int init_qp
pic_init_qp_minus26 + 26
Definition: h264_ps.h:120
H.264 / AVC / MPEG-4 part10 codec.
int mmco_reset
Definition: h264dec.h:481
H264SliceContext * slice_ctx
Definition: h264dec.h:356
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
int reference
Definition: h264dec.h:176
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
int top_borders_allocated[2]
Definition: h264dec.h:294
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:831
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:70
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 *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:103
int type
NAL unit type.
Definition: h2645_parse.h:52
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:67
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1785
uint8_t * edge_emu_buffer
Definition: h264dec.h:290
if(ret)
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:106
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
static const int8_t mv[256][2]
Definition: 4xm.c:77
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:381
static int is_avcc_extradata(const uint8_t *buf, int buf_size)
Definition: h264dec.c:850
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
int mb_stride
Definition: h264dec.h:442
AVCodecContext * avctx
Definition: h264dec.h:345
#define AV_ONCE_INIT
Definition: thread.h:173
Libavcodec external API header.
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
enum AVCodecID codec_id
Definition: avcodec.h:536
AVCodec ff_h264_decoder
Definition: h264dec.c:1045
ERPicture next_pic
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
int next_outputed_poc
Definition: h264dec.h:474
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int field_poc[2]
top/bottom POC
Definition: h264dec.h:147
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.
int debug
debug
Definition: avcodec.h:1611
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
int recovery_frame
recovery_frame is the frame_num at which the next frame should be fully constructed.
Definition: h264dec.h:517
main external API structure.
Definition: avcodec.h:526
const uint8_t * data
Definition: h2645_parse.h:36
int mb_height
Definition: h264dec.h:168
static AVOnce h264_vlc_init
Definition: h264dec.c:362
int8_t * qscale_table
Definition: h264dec.h:133
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:650
int extradata_size
Definition: avcodec.h:628
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
int slice_flags
slice flags
Definition: avcodec.h:1004
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
Definition: h264dec.c:824
Describe the class of an AVClass context structure.
Definition: log.h:67
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264_parse.h:53
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:300
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:303
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:666
int8_t * ref_index[2]
Definition: h264dec.h:145
av_cold void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:327
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:69
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:150
H264Picture * cur_pic_ptr
Definition: h264dec.h:352
#define FMO
Definition: h264dec.h:62
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:248
#define FF_DEBUG_GREEN_MD
Definition: avcodec.h:1635
int enable_er
Definition: h264dec.h:551
uint8_t percent_intra_coded_macroblocks
Definition: h264_sei.h:172
const SPS * sps
Definition: h264_ps.h:150
#define FF_DECODE_ERROR_DECODE_SLICES
Definition: frame.h:607
int width_from_caller
Definition: h264dec.h:548
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:603
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:189
AVCodecContext * avctx
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
int linesize[3]
Definition: h264dec.h:174
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2500
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
Definition: h264_parse.h:50
uint8_t xsd_metric_type
Definition: h264_sei.h:175
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
Definition: h264dec.c:181
int has_recovery_point
Definition: h264dec.h:532
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:2472
int mb_stride
Definition: h264dec.h:169
uint16_t xsd_metric_value
Definition: h264_sei.h:176
int nb_slice_ctx_queued
Definition: h264dec.h:358
discard all non reference
Definition: avcodec.h:232
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:159
AVBufferPool * qscale_table_pool
Definition: h264dec.h:555
H264Picture * next_output_pic
Definition: h264dec.h:473
int
AVBufferPool * motion_val_pool
Definition: h264dec.h:557
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
uint16_t * slice_table_base
Definition: h264dec.h:464
H264ParamSets ps
Definition: h264dec.h:462
int16_t * dc_val[3]
H264SEIFramePacking frame_packing
Definition: h264_sei.h:191
H.264 / AVC / MPEG-4 part10 motion vector prediction.
Stereoscopic video.
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:1560
const AVProfile ff_h264_profiles[]
Definition: profiles.c:58
int cur_chroma_format_idc
Definition: h264dec.h:542
int8_t * intra4x4_pred_mode
Definition: h264dec.h:212
int den
Denominator.
Definition: rational.h:60
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:317
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
static int h264_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: h264dec.c:957
GetBitContext gb
Definition: h2645_parse.h:47
void ff_h264_free_tables(H264Context *h)
Definition: h264dec.c:138
void * priv_data
Definition: avcodec.h:553
const uint8_t * raw_data
Definition: h2645_parse.h:45
#define PICT_FRAME
Definition: mpegutils.h:39
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:306
#define AV_CODEC_FLAG_OUTPUT_CORRUPT
Output even those frames that might be corrupted.
Definition: avcodec.h:283
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:333
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:561
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
H2645NAL * nals
Definition: h2645_parse.h:82
H264Picture cur_pic
Definition: h264dec.h:353
#define PART_NOT_AVAILABLE
Definition: h264dec.h:397
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
int mb_width
Definition: h264dec.h:441
int current_slice
current slice number, used to initialize slice_num of each thread/context
Definition: h264dec.h:494
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:613
uint32_t * mb2b_xy
Definition: h264dec.h:405
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:275
static av_cold int h264_decode_init(AVCodecContext *avctx)
Definition: h264dec.c:364
H264Picture last_pic_for_ec
Definition: h264dec.h:354
int height
Definition: frame.h:366
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:376
FILE * out
Definition: movenc.c:54
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:319
int mb_width
Definition: h264dec.h:168
#define av_freep(p)
static void h264_decode_flush(AVCodecContext *avctx)
Definition: h264dec.c:464
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:387
int prev_frame_num_offset
for POC type 2
Definition: h264_parse.h:52
int8_t * intra4x4_pred_mode
Definition: h264dec.h:391
#define VD
Definition: cuviddec.c:1096
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:141
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
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
ptrdiff_t mb_stride
int mb_field_decoding_flag
Definition: h264dec.h:247
uint8_t(* non_zero_count)[48]
Definition: h264dec.h:394
exp golomb vlc stuff
uint8_t * bipred_scratchpad
Definition: h264dec.h:289
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
Definition: h264_picture.c:44
This structure stores compressed data.
Definition: packet.h:340
int droppable
Definition: h264dec.h:368
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:152
int nal_ref_idc
Definition: h264dec.h:448
for(j=16;j >0;--j)
int i
Definition: input.c:407
int b_stride
Definition: h264dec.h:407
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:59
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)
#define H264_MAX_PICTURE_COUNT
Definition: h264dec.h:52
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
uint8_t percent_alpha_point_deblocking_instance
Definition: h264_sei.h:174