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