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 "libavutil/timer.h"
36 #include "internal.h"
37 #include "bytestream.h"
38 #include "cabac.h"
39 #include "cabac_functions.h"
40 #include "error_resilience.h"
41 #include "avcodec.h"
42 #include "h264.h"
43 #include "h264dec.h"
44 #include "h2645_parse.h"
45 #include "h264data.h"
46 #include "h264chroma.h"
47 #include "h264_mvpred.h"
48 #include "h264_ps.h"
49 #include "golomb.h"
50 #include "hwaccel.h"
51 #include "mathops.h"
52 #include "me_cmp.h"
53 #include "mpegutils.h"
54 #include "profiles.h"
55 #include "rectangle.h"
56 #include "thread.h"
57 
58 const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
59 
61 {
62  H264Context *h = avctx->priv_data;
63  return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0;
64 }
65 
66 static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
67  int (*mv)[2][4][2],
68  int mb_x, int mb_y, int mb_intra, int mb_skipped)
69 {
70  H264Context *h = opaque;
71  H264SliceContext *sl = &h->slice_ctx[0];
72 
73  sl->mb_x = mb_x;
74  sl->mb_y = mb_y;
75  sl->mb_xy = mb_x + mb_y * h->mb_stride;
76  memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));
77  av_assert1(ref >= 0);
78  /* FIXME: It is possible albeit uncommon that slice references
79  * differ between slices. We take the easy approach and ignore
80  * it for now. If this turns out to have any relevance in
81  * practice then correct remapping should be added. */
82  if (ref >= sl->ref_count[0])
83  ref = 0;
84  if (!sl->ref_list[0][ref].data[0]) {
85  av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
86  ref = 0;
87  }
88  if ((sl->ref_list[0][ref].reference&3) != 3) {
89  av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n");
90  return;
91  }
92  fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],
93  2, 2, 2, ref, 1);
94  fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
95  fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
96  pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
97  sl->mb_mbaff =
98  sl->mb_field_decoding_flag = 0;
100 }
101 
103  int y, int height)
104 {
105  AVCodecContext *avctx = h->avctx;
106  const AVFrame *src = h->cur_pic.f;
108  int vshift = desc->log2_chroma_h;
109  const int field_pic = h->picture_structure != PICT_FRAME;
110  if (field_pic) {
111  height <<= 1;
112  y <<= 1;
113  }
114 
115  height = FFMIN(height, avctx->height - y);
116 
117  if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
118  return;
119 
120  if (avctx->draw_horiz_band) {
122  int i;
123 
124  offset[0] = y * src->linesize[0];
125  offset[1] =
126  offset[2] = (y >> vshift) * src->linesize[1];
127  for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
128  offset[i] = 0;
129 
130  emms_c();
131 
132  avctx->draw_horiz_band(avctx, src, offset,
133  y, h->picture_structure, height);
134  }
135 }
136 
138 {
139  int i;
140 
143  av_freep(&h->cbp_table);
144  av_freep(&h->mvd_table[0]);
145  av_freep(&h->mvd_table[1]);
146  av_freep(&h->direct_table);
149  h->slice_table = NULL;
150  av_freep(&h->list_counts);
151 
152  av_freep(&h->mb2b_xy);
153  av_freep(&h->mb2br_xy);
154 
159 
160  for (i = 0; i < h->nb_slice_ctx; i++) {
161  H264SliceContext *sl = &h->slice_ctx[i];
162 
163  av_freep(&sl->dc_val_base);
164  av_freep(&sl->er.mb_index2xy);
166  av_freep(&sl->er.er_temp_buffer);
167 
170  av_freep(&sl->top_borders[0]);
171  av_freep(&sl->top_borders[1]);
172 
175  sl->top_borders_allocated[0] = 0;
176  sl->top_borders_allocated[1] = 0;
177  }
178 }
179 
181 {
182  const int big_mb_num = h->mb_stride * (h->mb_height + 1);
183  const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1);
184  int x, y;
185 
187  row_mb_num, 8 * sizeof(uint8_t), fail)
189 
191  big_mb_num * 48 * sizeof(uint8_t), fail)
193  (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail)
195  big_mb_num * sizeof(uint16_t), fail)
197  big_mb_num * sizeof(uint8_t), fail)
199  row_mb_num, 16 * sizeof(uint8_t), fail);
201  row_mb_num, 16 * sizeof(uint8_t), fail);
202  h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
203  h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
204 
206  4 * big_mb_num * sizeof(uint8_t), fail);
208  big_mb_num * sizeof(uint8_t), fail)
209 
210  memset(h->slice_table_base, -1,
211  (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));
212  h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
213 
215  big_mb_num * sizeof(uint32_t), fail);
217  big_mb_num * sizeof(uint32_t), fail);
218  for (y = 0; y < h->mb_height; y++)
219  for (x = 0; x < h->mb_width; x++) {
220  const int mb_xy = x + y * h->mb_stride;
221  const int b_xy = 4 * x + 4 * y * h->b_stride;
222 
223  h->mb2b_xy[mb_xy] = b_xy;
224  h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
225  }
226 
227  return 0;
228 
229 fail:
231  return AVERROR(ENOMEM);
232 }
233 
234 /**
235  * Init context
236  * Allocate buffers which are not shared amongst multiple threads.
237  */
239 {
240  ERContext *er = &sl->er;
241  int mb_array_size = h->mb_height * h->mb_stride;
242  int y_size = (2 * h->mb_width + 1) * (2 * h->mb_height + 1);
243  int c_size = h->mb_stride * (h->mb_height + 1);
244  int yc_size = y_size + 2 * c_size;
245  int x, y, i;
246 
247  sl->ref_cache[0][scan8[5] + 1] =
248  sl->ref_cache[0][scan8[7] + 1] =
249  sl->ref_cache[0][scan8[13] + 1] =
250  sl->ref_cache[1][scan8[5] + 1] =
251  sl->ref_cache[1][scan8[7] + 1] =
252  sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;
253 
254  if (sl != h->slice_ctx) {
255  memset(er, 0, sizeof(*er));
256  } else
257  if (CONFIG_ERROR_RESILIENCE) {
258 
259  /* init ER */
260  er->avctx = h->avctx;
262  er->opaque = h;
263  er->quarter_sample = 1;
264 
265  er->mb_num = h->mb_num;
266  er->mb_width = h->mb_width;
267  er->mb_height = h->mb_height;
268  er->mb_stride = h->mb_stride;
269  er->b8_stride = h->mb_width * 2 + 1;
270 
271  // error resilience code looks cleaner with this
273  (h->mb_num + 1) * sizeof(int), fail);
274 
275  for (y = 0; y < h->mb_height; y++)
276  for (x = 0; x < h->mb_width; x++)
277  er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;
278 
279  er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
280  h->mb_stride + h->mb_width;
281 
283  mb_array_size * sizeof(uint8_t), fail);
284 
286  h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
287 
289  yc_size * sizeof(int16_t), fail);
290  er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;
291  er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;
292  er->dc_val[2] = er->dc_val[1] + c_size;
293  for (i = 0; i < yc_size; i++)
294  sl->dc_val_base[i] = 1024;
295  }
296 
297  return 0;
298 
299 fail:
300  return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
301 }
302 
304 {
305  int i;
306 
307  h->avctx = avctx;
308  h->cur_chroma_format_idc = -1;
309 
310  h->width_from_caller = avctx->width;
311  h->height_from_caller = avctx->height;
312 
314  h->workaround_bugs = avctx->workaround_bugs;
315  h->flags = avctx->flags;
316  h->poc.prev_poc_msb = 1 << 16;
317  h->recovery_frame = -1;
318  h->frame_recovered = 0;
319  h->poc.prev_frame_num = -1;
321  h->sei.unregistered.x264_build = -1;
322 
323  h->next_outputed_poc = INT_MIN;
324  for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
325  h->last_pocs[i] = INT_MIN;
326 
327  ff_h264_sei_uninit(&h->sei);
328 
330 
331  h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
332  h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));
333  if (!h->slice_ctx) {
334  h->nb_slice_ctx = 0;
335  return AVERROR(ENOMEM);
336  }
337 
338  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
339  h->DPB[i].f = av_frame_alloc();
340  if (!h->DPB[i].f)
341  return AVERROR(ENOMEM);
342  }
343 
344  h->cur_pic.f = av_frame_alloc();
345  if (!h->cur_pic.f)
346  return AVERROR(ENOMEM);
347 
349  if (!h->last_pic_for_ec.f)
350  return AVERROR(ENOMEM);
351 
352  for (i = 0; i < h->nb_slice_ctx; i++)
353  h->slice_ctx[i].h264 = h;
354 
355  return 0;
356 }
357 
359 {
360  H264Context *h = avctx->priv_data;
361  int i;
362 
365 
366  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
367  ff_h264_unref_picture(h, &h->DPB[i]);
368  av_frame_free(&h->DPB[i].f);
369  }
370  memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
371 
372  h->cur_pic_ptr = NULL;
373 
374  av_freep(&h->slice_ctx);
375  h->nb_slice_ctx = 0;
376 
377  ff_h264_sei_uninit(&h->sei);
378  ff_h264_ps_uninit(&h->ps);
379 
381 
383  av_frame_free(&h->cur_pic.f);
386 
387  return 0;
388 }
389 
391 
393 {
394  H264Context *h = avctx->priv_data;
395  int ret;
396 
397  ret = h264_init_context(avctx, h);
398  if (ret < 0)
399  return ret;
400 
401  ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc);
402  if (ret != 0) {
403  av_log(avctx, AV_LOG_ERROR, "pthread_once has failed.");
404  return AVERROR_UNKNOWN;
405  }
406 
407  if (avctx->ticks_per_frame == 1) {
408  if(h->avctx->time_base.den < INT_MAX/2) {
409  h->avctx->time_base.den *= 2;
410  } else
411  h->avctx->time_base.num /= 2;
412  }
413  avctx->ticks_per_frame = 2;
414 
415  if (avctx->extradata_size > 0 && avctx->extradata) {
417  &h->ps, &h->is_avc, &h->nal_length_size,
418  avctx->err_recognition, avctx);
419  if (ret < 0) {
420  h264_decode_end(avctx);
421  return ret;
422  }
423  }
424 
425  if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&
428  }
429 
430  avctx->internal->allocate_progress = 1;
431 
433 
434  if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
435  h->enable_er = 0;
436 
437  if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {
438  av_log(avctx, AV_LOG_WARNING,
439  "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
440  "Use it at your own risk\n");
441  }
442 
443  return 0;
444 }
445 
446 #if HAVE_THREADS
447 static int decode_init_thread_copy(AVCodecContext *avctx)
448 {
449  H264Context *h = avctx->priv_data;
450  int ret;
451 
452  if (!avctx->internal->is_copy)
453  return 0;
454 
455  memset(h, 0, sizeof(*h));
456 
457  ret = h264_init_context(avctx, h);
458  if (ret < 0)
459  return ret;
460 
461  h->context_initialized = 0;
462 
463  return 0;
464 }
465 #endif
466 
467 /**
468  * instantaneous decoder refresh.
469  */
470 static void idr(H264Context *h)
471 {
472  int i;
474  h->poc.prev_frame_num =
475  h->poc.prev_frame_num_offset = 0;
476  h->poc.prev_poc_msb = 1<<16;
477  h->poc.prev_poc_lsb = 0;
478  for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
479  h->last_pocs[i] = INT_MIN;
480 }
481 
482 /* forget old pics after a seek */
484 {
485  int i, j;
486 
487  h->next_outputed_poc = INT_MIN;
488  h->prev_interlaced_frame = 1;
489  idr(h);
490 
491  h->poc.prev_frame_num = -1;
492  if (h->cur_pic_ptr) {
493  h->cur_pic_ptr->reference = 0;
494  for (j=i=0; h->delayed_pic[i]; i++)
495  if (h->delayed_pic[i] != h->cur_pic_ptr)
496  h->delayed_pic[j++] = h->delayed_pic[i];
497  h->delayed_pic[j] = NULL;
498  }
500 
501  h->first_field = 0;
502  h->recovery_frame = -1;
503  h->frame_recovered = 0;
504  h->current_slice = 0;
505  h->mmco_reset = 1;
506 }
507 
508 /* forget old pics after a seek */
509 static void flush_dpb(AVCodecContext *avctx)
510 {
511  H264Context *h = avctx->priv_data;
512  int i;
513 
514  memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
515 
517  ff_h264_sei_uninit(&h->sei);
518 
519  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
520  ff_h264_unref_picture(h, &h->DPB[i]);
521  h->cur_pic_ptr = NULL;
523 
524  h->mb_y = 0;
525 
527  h->context_initialized = 0;
528 }
529 
531 {
532  int nals_needed = 0;
533  int first_slice = 0;
534  int i, ret;
535 
536  for (i = 0; i < h->pkt.nb_nals; i++) {
537  H2645NAL *nal = &h->pkt.nals[i];
538  GetBitContext gb;
539 
540  /* packets can sometimes contain multiple PPS/SPS,
541  * e.g. two PAFF field pictures in one packet, or a demuxer
542  * which splits NALs strangely if so, when frame threading we
543  * can't start the next thread until we've read all of them */
544  switch (nal->type) {
545  case H264_NAL_SPS:
546  case H264_NAL_PPS:
547  nals_needed = i;
548  break;
549  case H264_NAL_DPA:
550  case H264_NAL_IDR_SLICE:
551  case H264_NAL_SLICE:
552  ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);
553  if (ret < 0) {
554  av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");
556  return ret;
557 
558  break;
559  }
560  if (!get_ue_golomb_long(&gb) || // first_mb_in_slice
561  !first_slice ||
562  first_slice != nal->type)
563  nals_needed = i;
564  if (!first_slice)
565  first_slice = nal->type;
566  }
567  }
568 
569  return nals_needed;
570 }
571 
572 static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
573 {
574  av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n");
575  av_log(logctx, AV_LOG_DEBUG, " green_metadata_type: %d\n", gm->green_metadata_type);
576 
577  if (gm->green_metadata_type == 0) {
578  av_log(logctx, AV_LOG_DEBUG, " green_metadata_period_type: %d\n", gm->period_type);
579 
580  if (gm->period_type == 2)
581  av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_seconds: %d\n", gm->num_seconds);
582  else if (gm->period_type == 3)
583  av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_pictures: %d\n", gm->num_pictures);
584 
585  av_log(logctx, AV_LOG_DEBUG, " SEI GREEN Complexity Metrics: %f %f %f %f\n",
586  (float)gm->percent_non_zero_macroblocks/255,
587  (float)gm->percent_intra_coded_macroblocks/255,
588  (float)gm->percent_six_tap_filtering/255,
590 
591  } else if (gm->green_metadata_type == 1) {
592  av_log(logctx, AV_LOG_DEBUG, " xsd_metric_type: %d\n", gm->xsd_metric_type);
593 
594  if (gm->xsd_metric_type == 0)
595  av_log(logctx, AV_LOG_DEBUG, " xsd_metric_value: %f\n",
596  (float)gm->xsd_metric_value/100);
597  }
598 }
599 
600 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
601 {
602  AVCodecContext *const avctx = h->avctx;
603  int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
604  int idr_cleared=0;
605  int i, ret = 0;
606 
607  h->has_slice = 0;
608  h->nal_unit_type= 0;
609 
610  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
611  h->current_slice = 0;
612  if (!h->first_field) {
613  h->cur_pic_ptr = NULL;
614  ff_h264_sei_uninit(&h->sei);
615  }
616  }
617 
618  if (h->nal_length_size == 4) {
619  if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
620  h->is_avc = 0;
621  }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
622  h->is_avc = 1;
623  }
624 
625  ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc, h->nal_length_size,
626  avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST, 0);
627  if (ret < 0) {
628  av_log(avctx, AV_LOG_ERROR,
629  "Error splitting the input into NAL units.\n");
630  return ret;
631  }
632 
633  if (avctx->active_thread_type & FF_THREAD_FRAME)
634  nals_needed = get_last_needed_nal(h);
635  if (nals_needed < 0)
636  return nals_needed;
637 
638  for (i = 0; i < h->pkt.nb_nals; i++) {
639  H2645NAL *nal = &h->pkt.nals[i];
640  int max_slice_ctx, err;
641 
642  if (avctx->skip_frame >= AVDISCARD_NONREF &&
643  nal->ref_idc == 0 && nal->type != H264_NAL_SEI)
644  continue;
645 
646  // FIXME these should stop being context-global variables
647  h->nal_ref_idc = nal->ref_idc;
648  h->nal_unit_type = nal->type;
649 
650  err = 0;
651  switch (nal->type) {
652  case H264_NAL_IDR_SLICE:
653  if ((nal->data[1] & 0xFC) == 0x98) {
654  av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");
655  h->next_outputed_poc = INT_MIN;
656  ret = -1;
657  goto end;
658  }
659  if(!idr_cleared) {
660  idr(h); // FIXME ensure we don't lose some frames if there is reordering
661  }
662  idr_cleared = 1;
663  h->has_recovery_point = 1;
664  case H264_NAL_SLICE:
665  h->has_slice = 1;
666 
667  if ((err = ff_h264_queue_decode_slice(h, nal))) {
669  sl->ref_count[0] = sl->ref_count[1] = 0;
670  break;
671  }
672 
673  if (h->current_slice == 1) {
674  if (avctx->active_thread_type & FF_THREAD_FRAME &&
675  i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {
676  ff_thread_finish_setup(avctx);
677  h->setup_finished = 1;
678  }
679 
680  if (h->avctx->hwaccel &&
681  (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)
682  goto end;
683  }
684 
685  max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;
686  if (h->nb_slice_ctx_queued == max_slice_ctx) {
687  if (h->avctx->hwaccel) {
688  ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
689  h->nb_slice_ctx_queued = 0;
690  } else
692  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
693  goto end;
694  }
695  break;
696  case H264_NAL_DPA:
697  case H264_NAL_DPB:
698  case H264_NAL_DPC:
699  avpriv_request_sample(avctx, "data partitioning");
700  break;
701  case H264_NAL_SEI:
702  ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
704  if (avctx->debug & FF_DEBUG_GREEN_MD)
706  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
707  goto end;
708  break;
709  case H264_NAL_SPS: {
710  GetBitContext tmp_gb = nal->gb;
711  if (avctx->hwaccel && avctx->hwaccel->decode_params) {
712  ret = avctx->hwaccel->decode_params(avctx,
713  nal->type,
714  nal->raw_data,
715  nal->raw_size);
716  if (ret < 0)
717  goto end;
718  }
719  if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
720  break;
722  "SPS decoding failure, trying again with the complete NAL\n");
723  init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
724  if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
725  break;
726  ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);
727  break;
728  }
729  case H264_NAL_PPS:
730  if (avctx->hwaccel && avctx->hwaccel->decode_params) {
731  ret = avctx->hwaccel->decode_params(avctx,
732  nal->type,
733  nal->raw_data,
734  nal->raw_size);
735  if (ret < 0)
736  goto end;
737  }
738  ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
739  nal->size_bits);
740  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
741  goto end;
742  break;
743  case H264_NAL_AUD:
745  case H264_NAL_END_STREAM:
747  case H264_NAL_SPS_EXT:
749  break;
750  default:
751  av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
752  nal->type, nal->size_bits);
753  }
754 
755  if (err < 0) {
756  av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
757  }
758  }
759 
761  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
762  goto end;
763 
764  ret = 0;
765 end:
766 
767 #if CONFIG_ERROR_RESILIENCE
768  /*
769  * FIXME: Error handling code does not seem to support interlaced
770  * when slices span multiple rows
771  * The ff_er_add_slice calls don't work right for bottom
772  * fields; they cause massive erroneous error concealing
773  * Error marking covers both fields (top and bottom).
774  * This causes a mismatched s->error_count
775  * and a bad error table. Further, the error count goes to
776  * INT_MAX when called for bottom field, because mb_y is
777  * past end by one (callers fault) and resync_mb_y != 0
778  * causes problems for the first MB line, too.
779  */
780  if (!FIELD_PICTURE(h) && h->current_slice &&
781  h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data &&
782  h->enable_er) {
783 
784  H264SliceContext *sl = h->slice_ctx;
785  int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
786 
788 
789  if (use_last_pic) {
791  sl->ref_list[0][0].parent = &h->last_pic_for_ec;
792  memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
793  memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
795  } else if (sl->ref_count[0]) {
796  ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
797  } else
799 
800  if (sl->ref_count[1])
801  ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);
802 
803  sl->er.ref_count = sl->ref_count[0];
804 
805  ff_er_frame_end(&sl->er);
806  if (use_last_pic)
807  memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
808  }
809 #endif /* CONFIG_ERROR_RESILIENCE */
810  /* clean up */
811  if (h->cur_pic_ptr && !h->droppable && h->has_slice) {
814  }
815 
816  return (ret < 0) ? ret : buf_size;
817 }
818 
819 /**
820  * Return the number of bytes consumed for building the current frame.
821  */
822 static int get_consumed_bytes(int pos, int buf_size)
823 {
824  if (pos == 0)
825  pos = 1; // avoid infinite loops (I doubt that is needed but...)
826  if (pos + 10 > buf_size)
827  pos = buf_size; // oops ;)
828 
829  return pos;
830 }
831 
833 {
834  AVFrame *src = srcp->f;
835  int ret;
836 
837  ret = av_frame_ref(dst, src);
838  if (ret < 0)
839  return ret;
840 
841  av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);
842 
843  if (srcp->sei_recovery_frame_cnt == 0)
844  dst->key_frame = 1;
845 
846  return 0;
847 }
848 
849 static int is_extra(const uint8_t *buf, int buf_size)
850 {
851  int cnt= buf[5]&0x1f;
852  const uint8_t *p= buf+6;
853  if (!cnt)
854  return 0;
855  while(cnt--){
856  int nalsize= AV_RB16(p) + 2;
857  if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
858  return 0;
859  p += nalsize;
860  }
861  cnt = *(p++);
862  if(!cnt)
863  return 0;
864  while(cnt--){
865  int nalsize= AV_RB16(p) + 2;
866  if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
867  return 0;
868  p += nalsize;
869  }
870  return 1;
871 }
872 
873 static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
874 {
875  int ret;
876 
879  out->recovered)) {
880 
881  if (!h->avctx->hwaccel &&
882  (out->field_poc[0] == INT_MAX ||
883  out->field_poc[1] == INT_MAX)
884  ) {
885  int p;
886  AVFrame *f = out->f;
887  int field = out->field_poc[0] == INT_MAX;
888  uint8_t *dst_data[4];
889  int linesizes[4];
890  const uint8_t *src_data[4];
891 
892  av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
893 
894  for (p = 0; p<4; p++) {
895  dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
896  src_data[p] = f->data[p] + field *f->linesize[p];
897  linesizes[p] = 2*f->linesize[p];
898  }
899 
900  av_image_copy(dst_data, linesizes, src_data, linesizes,
901  f->format, f->width, f->height>>1);
902  }
903 
904  ret = output_frame(h, dst, out);
905  if (ret < 0)
906  return ret;
907 
908  *got_frame = 1;
909 
910  if (CONFIG_MPEGVIDEO) {
912  out->mb_type,
913  out->qscale_table,
914  out->motion_val,
915  NULL,
916  h->mb_width, h->mb_height, h->mb_stride, 1);
917  }
918  }
919 
920  return 0;
921 }
922 
924  int *got_frame, int buf_index)
925 {
926  int ret, i, out_idx;
927  H264Picture *out = h->delayed_pic[0];
928 
929  h->cur_pic_ptr = NULL;
930  h->first_field = 0;
931 
932  out_idx = 0;
933  for (i = 1;
934  h->delayed_pic[i] &&
935  !h->delayed_pic[i]->f->key_frame &&
936  !h->delayed_pic[i]->mmco_reset;
937  i++)
938  if (h->delayed_pic[i]->poc < out->poc) {
939  out = h->delayed_pic[i];
940  out_idx = i;
941  }
942 
943  for (i = out_idx; h->delayed_pic[i]; i++)
944  h->delayed_pic[i] = h->delayed_pic[i + 1];
945 
946  if (out) {
947  out->reference &= ~DELAYED_PIC_REF;
948  ret = finalize_frame(h, dst_frame, out, got_frame);
949  if (ret < 0)
950  return ret;
951  }
952 
953  return buf_index;
954 }
955 
956 static int h264_decode_frame(AVCodecContext *avctx, void *data,
957  int *got_frame, AVPacket *avpkt)
958 {
959  const uint8_t *buf = avpkt->data;
960  int buf_size = avpkt->size;
961  H264Context *h = avctx->priv_data;
962  AVFrame *pict = data;
963  int buf_index;
964  int ret;
965 
966  h->flags = avctx->flags;
967  h->setup_finished = 0;
968  h->nb_slice_ctx_queued = 0;
969 
971 
972  /* end of stream, output what is still in the buffers */
973  if (buf_size == 0)
974  return send_next_delayed_frame(h, pict, got_frame, 0);
975 
977  int side_size;
978  uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
979  if (is_extra(side, 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_extra(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  },
1082  .flush = flush_dpb,
1083  .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1084  .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
1086  .priv_class = &h264_class,
1087 };
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
Definition: h264_ps.c:739
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:269
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
Definition: avcodec.h:2045
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
Definition: h264_slice.c:2078
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:923
int mb_num
Definition: h264dec.h:437
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:543
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
#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:572
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:139
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:459
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
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:85
int num
Numerator.
Definition: rational.h:59
int bipred_scratchpad_allocated
Definition: h264dec.h:286
int size
Definition: avcodec.h:1478
#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:191
AVBufferPool * mb_type_pool
Definition: h264dec.h:550
static void idr(H264Context *h)
instantaneous decoder refresh.
Definition: h264dec.c:470
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:483
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
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:942
#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:2725
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3477
int picture_structure
Definition: h264dec.h:407
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
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:1800
static void flush_dpb(AVCodecContext *avctx)
Definition: h264dec.c:509
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:1688
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:288
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:563
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3036
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
Definition: h264_slice.c:2789
H264SEIContext sei
Definition: h264dec.h:547
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
Definition: h264dec.c:60
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:1006
#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:822
ptrdiff_t b8_stride
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
const PPS * pps
Definition: h264_ps.h:145
#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:189
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:3721
AVOptions.
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
Definition: h264_picture.c:131
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:443
static int get_last_needed_nal(H264Context *h)
Definition: h264dec.c:530
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
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:388
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:512
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:449
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define height
uint8_t * data
Definition: avcodec.h:1477
#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:600
AVDictionary * metadata
metadata.
Definition: frame.h:554
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:303
H264Picture * parent
Definition: h264dec.h:174
high precision timer, useful to profile code
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:161
#define AVOnce
Definition: thread.h:159
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2203
#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:102
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:260
int width
Definition: frame.h:326
#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:1855
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: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:86
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:136
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:202
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:1030
Display matrix.
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2839
H2645Packet pkt
Definition: h264dec.h:354
#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:358
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:1645
static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
Definition: h264dec.c:873
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:3484
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:120
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
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:2690
#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:2831
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:66
int reference
Definition: h264dec.h:160
static int is_extra(const uint8_t *buf, int buf_size)
Definition: h264dec.c:849
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:1738
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:2832
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:2701
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:1697
int top_borders_allocated[2]
Definition: h264dec.h:288
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:827
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:65
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:2820
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:103
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1041
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:341
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1199
int mb_stride
Definition: h264dec.h:436
AVCodecContext * avctx
Definition: h264dec.h:339
#define AV_ONCE_INIT
Definition: thread.h:160
Libavcodec external API header.
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
enum AVCodecID codec_id
Definition: avcodec.h:1575
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:299
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:923
int debug
debug
Definition: avcodec.h:2646
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:1565
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:390
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:1667
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:2043
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
Definition: h264dec.c:832
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:275
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:2670
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:146
unsigned int sps_id
Definition: h264_ps.h:110
int width_from_caller
Definition: h264dec.h:542
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:151
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:3735
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
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:180
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:3707
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:807
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:154
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:1028
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:2595
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:316
#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:956
GetBitContext gb
Definition: h2645_parse.h:47
#define VD
Definition: h264dec.c:1029
void ff_h264_free_tables(H264Context *h)
Definition: h264dec.c:137
void * priv_data
Definition: avcodec.h:1592
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:858
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:1600
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:162
H2645NAL * nals
Definition: h2645_parse.h:77
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:346
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:1652
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:392
H264Picture last_pic_for_ec
Definition: h264dec.h:348
int height
Definition: frame.h:326
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:951
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:238
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:45
This structure stores compressed data.
Definition: avcodec.h:1454
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:981
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:58
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