FFmpeg
h264dec.h
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... encoder/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 #ifndef AVCODEC_H264DEC_H
29 #define AVCODEC_H264DEC_H
30 
31 #include "libavutil/buffer.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/thread.h"
34 
35 #include "cabac.h"
36 #include "error_resilience.h"
37 #include "h264_parse.h"
38 #include "h264_ps.h"
39 #include "h264_sei.h"
40 #include "h2645_parse.h"
41 #include "h264chroma.h"
42 #include "h264dsp.h"
43 #include "h264pred.h"
44 #include "h264qpel.h"
45 #include "internal.h"
46 #include "mpegutils.h"
47 #include "parser.h"
48 #include "qpeldsp.h"
49 #include "rectangle.h"
50 #include "videodsp.h"
51 
52 #define H264_MAX_PICTURE_COUNT 36
53 
54 #define MAX_MMCO_COUNT 66
55 
56 #define MAX_DELAYED_PIC_COUNT 16
57 
58 /* Compiling in interlaced support reduces the speed
59  * of progressive decoding by about 2%. */
60 #define ALLOW_INTERLACE
61 
62 #define FMO 0
63 
64 /**
65  * The maximum number of slices supported by the decoder.
66  * must be a power of 2
67  */
68 #define MAX_SLICES 32
69 
70 #ifdef ALLOW_INTERLACE
71 #define MB_MBAFF(h) (h)->mb_mbaff
72 #define MB_FIELD(sl) (sl)->mb_field_decoding_flag
73 #define FRAME_MBAFF(h) (h)->mb_aff_frame
74 #define FIELD_PICTURE(h) ((h)->picture_structure != PICT_FRAME)
75 #define LEFT_MBS 2
76 #define LTOP 0
77 #define LBOT 1
78 #define LEFT(i) (i)
79 #else
80 #define MB_MBAFF(h) 0
81 #define MB_FIELD(sl) 0
82 #define FRAME_MBAFF(h) 0
83 #define FIELD_PICTURE(h) 0
84 #undef IS_INTERLACED
85 #define IS_INTERLACED(mb_type) 0
86 #define LEFT_MBS 1
87 #define LTOP 0
88 #define LBOT 0
89 #define LEFT(i) 0
90 #endif
91 #define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h))
92 
93 #ifndef CABAC
94 #define CABAC(h) (h)->ps.pps->cabac
95 #endif
96 
97 #define CHROMA(h) ((h)->ps.sps->chroma_format_idc)
98 #define CHROMA422(h) ((h)->ps.sps->chroma_format_idc == 2)
99 #define CHROMA444(h) ((h)->ps.sps->chroma_format_idc == 3)
100 
101 #define MB_TYPE_REF0 MB_TYPE_ACPRED // dirty but it fits in 16 bit
102 #define MB_TYPE_8x8DCT 0x01000000
103 #define IS_REF0(a) ((a) & MB_TYPE_REF0)
104 #define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT)
105 
106 /**
107  * Memory management control operation opcode.
108  */
109 typedef enum MMCOOpcode {
110  MMCO_END = 0,
117 } MMCOOpcode;
118 
119 /**
120  * Memory management control operation.
121  */
122 typedef struct MMCO {
124  int short_pic_num; ///< pic_num without wrapping (pic_num & max_pic_num)
125  int long_arg; ///< index, pic_num, or num long refs depending on opcode
126 } MMCO;
127 
128 typedef struct H264Picture {
131 
133  int8_t *qscale_table;
134 
135  AVBufferRef *motion_val_buf[2];
136  int16_t (*motion_val[2])[2];
137 
139  uint32_t *mb_type;
140 
142  void *hwaccel_picture_private; ///< hardware accelerator private data
143 
144  AVBufferRef *ref_index_buf[2];
145  int8_t *ref_index[2];
146 
147  int field_poc[2]; ///< top/bottom POC
148  int poc; ///< frame POC
149  int frame_num; ///< frame_num (raw frame_num from slice header)
150  int mmco_reset; /**< MMCO_RESET set this 1. Reordering code must
151  not mix pictures before and after MMCO_RESET. */
152  int pic_id; /**< pic_num (short -> no wrap version of pic_num,
153  pic_num & max_pic_num; long -> long_pic_num) */
154  int long_ref; ///< 1->long term reference 0->short term reference
155  int ref_poc[2][2][32]; ///< POCs of the frames/fields used as reference (FIXME need per slice)
156  int ref_count[2][2]; ///< number of entries in ref_poc (FIXME need per slice)
157  int mbaff; ///< 1 -> MBAFF frame 0-> not MBAFF
158  int field_picture; ///< whether or not picture was encoded in separate fields
159 
161  int recovered; ///< picture at IDR or recovery point + recovery count
164 } H264Picture;
165 
166 typedef struct H264Ref {
168  int linesize[3];
169 
171  int poc;
172  int pic_id;
173 
175 } H264Ref;
176 
177 typedef struct H264SliceContext {
178  struct H264Context *h264;
181 
184  int slice_type_nos; ///< S free slice type (SI/SP are remapped to I/P)
186 
187  int qscale;
188  int chroma_qp[2]; // QPc
189  int qp_thresh; ///< QP threshold to skip loopfilter
191 
192  // deblock
193  int deblocking_filter; ///< disable_deblocking_filter_idc with 1 <-> 0
196 
198 
201 
204 
205  int8_t intra4x4_pred_mode_cache[5 * 8];
207 
211  int left_mb_xy[LEFT_MBS];
212 
214  int top_type;
216  int left_type[LEFT_MBS];
217 
220 
222  unsigned int top_samples_available;
225 
226  ptrdiff_t linesize, uvlinesize;
227  ptrdiff_t mb_linesize; ///< may be equal to s->linesize or s->linesize * 2, for mbaff
228  ptrdiff_t mb_uvlinesize;
229 
230  int mb_x, mb_y;
231  int mb_xy;
234  unsigned int first_mb_addr;
235  // index of the first MB of the next slice
239 
242  int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag
243 
245 
246  /**
247  * number of neighbors (top and/or left) that used 8x8 dct
248  */
250 
254 
255  int cbp;
256  int top_cbp;
257  int left_cbp;
258 
259  int dist_scale_factor[32];
260  int dist_scale_factor_field[2][32];
261  int map_col_to_list0[2][16 + 32];
262  int map_col_to_list0_field[2][2][16 + 32];
263 
264  /**
265  * num_ref_idx_l0/1_active_minus1 + 1
266  */
267  unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode
268  unsigned int list_count;
269  H264Ref ref_list[2][48]; /**< 0..15: frame refs, 16..47: mbaff field refs.
270  * Reordered version of default_ref_list
271  * according to picture reordering in slice header */
272  struct {
274  uint32_t val;
275  } ref_modifications[2][32];
276  int nb_ref_modifications[2];
277 
278  unsigned int pps_id;
279 
281  int16_t *dc_val_base;
282 
285  uint8_t (*top_borders[2])[(16 * 3) * 2];
288  int top_borders_allocated[2];
289 
290  /**
291  * non zero coeff count cache.
292  * is 64 if not available.
293  */
294  DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
295 
296  /**
297  * Motion vector cache.
298  */
299  DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
300  DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
301  DECLARE_ALIGNED(16, uint8_t, mvd_cache)[2][5 * 8][2];
302  uint8_t direct_cache[5 * 8];
303 
304  DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4];
305 
306  ///< as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
307  DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
308  DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
309  ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either
310  ///< check that i is not too large or ensure that there is some unused stuff after mb
311  int16_t mb_padding[256 * 2];
312 
313  uint8_t (*mvd_table[2])[2];
314 
315  /**
316  * Cabac
317  */
319  uint8_t cabac_state[1024];
321 
323  int nb_mmco;
325 
327  int poc_lsb;
329  int delta_poc[2];
333 
334 /**
335  * H264Context
336  */
337 typedef struct H264Context {
338  const AVClass *class;
344 
349 
353 
355 
356  int pixel_shift; ///< 0 for 8-bit H.264, 1 for high-bit-depth H.264
357 
358  /* coded dimensions -- 16 * mb w/h */
359  int width, height;
360  int chroma_x_shift, chroma_y_shift;
361 
364 
366  int flags;
369  /* Set when slice threading is used and at least one slice uses deblocking
370  * mode 1 (i.e. across slice boundaries). Then we disable the loop filter
371  * during normal MB decoding and execute it serially at the end.
372  */
374 
375  /*
376  * Set to 1 when the current picture is IDR, 0 otherwise.
377  */
379 
382  int crop_top;
384 
385  int8_t(*intra4x4_pred_mode);
387 
388  uint8_t (*non_zero_count)[48];
389 
390 #define LIST_NOT_USED -1 // FIXME rename?
391 #define PART_NOT_AVAILABLE -2
392 
393  /**
394  * block_offset[ 0..23] for frame macroblocks
395  * block_offset[24..47] for field macroblocks
396  */
397  int block_offset[2 * (16 * 3)];
398 
399  uint32_t *mb2b_xy; // FIXME are these 4 a good idea?
400  uint32_t *mb2br_xy;
401  int b_stride; // FIXME use s->b4_stride
402 
403  uint16_t *slice_table; ///< slice_table_base + 2*mb_stride + 1
404 
405  // interlacing specific flags
409 
410  uint8_t *list_counts; ///< Array of list_count per MB specifying the slice type
411 
412  /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
413  uint16_t *cbp_table;
414 
415  /* chroma_pred_mode for i4x4 or i16x16, else 0 */
417  uint8_t (*mvd_table[2])[2];
419 
420  uint8_t scan_padding[16];
421  uint8_t zigzag_scan[16];
422  uint8_t zigzag_scan8x8[64];
427  uint8_t zigzag_scan_q0[16];
428  uint8_t zigzag_scan8x8_q0[64];
429  uint8_t zigzag_scan8x8_cavlc_q0[64];
430  uint8_t field_scan_q0[16];
431  uint8_t field_scan8x8_q0[64];
432  uint8_t field_scan8x8_cavlc_q0[64];
433 
434  int mb_y;
435  int mb_height, mb_width;
437  int mb_num;
438 
439  // =============================================================
440  // Things below are not used in the MB or more inner code
441 
444 
445  int has_slice; ///< slice NAL is found in the packet, set by decode_nal_units, its state does not need to be preserved outside h264_decode_frame()
446 
447  /**
448  * Used to parse AVC variant of H.264
449  */
450  int is_avc; ///< this flag is != 0 if codec is avc1
451  int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)
452 
453  int bit_depth_luma; ///< luma bit depth from sps to detect changes
454  int chroma_format_idc; ///< chroma format from sps to detect changes
455 
457 
458  uint16_t *slice_table_base;
459 
461 
462  H264Ref default_ref[2];
463  H264Picture *short_ref[32];
464  H264Picture *long_ref[32];
465  H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
466  int last_pocs[MAX_DELAYED_PIC_COUNT];
469 
470  /**
471  * memory management control operations buffer.
472  */
474  int nb_mmco;
477 
478  int long_ref_count; ///< number of actual long term references
479  int short_ref_count; ///< number of actual short term references
480 
481  /**
482  * @name Members for slice based multithreading
483  * @{
484  */
485  /**
486  * current slice number, used to initialize slice_num of each thread/context
487  */
489 
490  /** @} */
491 
492  /**
493  * Complement sei_pic_struct
494  * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
495  * However, soft telecined frames may have these values.
496  * This is used in an attempt to flag soft telecine progressive.
497  */
499 
500  /**
501  * Are the SEI recovery points looking valid.
502  */
504 
505  /**
506  * recovery_frame is the frame_num at which the next frame should
507  * be fully constructed.
508  *
509  * Set to -1 when not expecting a recovery point.
510  */
512 
513 /**
514  * We have seen an IDR, so all the following frames in coded order are correctly
515  * decodable.
516  */
517 #define FRAME_RECOVERED_IDR (1 << 0)
518 /**
519  * Sufficient number of frames have been decoded since a SEI recovery point,
520  * so all the following frames in presentation order are correct.
521  */
522 #define FRAME_RECOVERED_SEI (1 << 1)
523 
524  int frame_recovered; ///< Initial frame has been completely recovered
525 
527 
529 
530  /* for frame threading, this is set to 1
531  * after finish_setup() has been called, so we cannot modify
532  * some context properties (which are supposed to stay constant between
533  * slices) anymore */
535 
538  int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
539 
540  /* original AVCodecContext dimensions, used to handle container
541  * cropping */
544 
546 
548 
553  int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
554 } H264Context;
555 
556 extern const uint16_t ff_h264_mb_sizes[4];
557 
558 /**
559  * Reconstruct bitstream slice_type.
560  */
562 
563 /**
564  * Allocate tables.
565  * needs width/height
566  */
568 
572 
573 /**
574  * Execute the reference picture marking (memory management control operations).
575  */
577 
579  const H2645NAL *nal, void *logctx);
580 
582 void ff_h264_decode_init_vlc(void);
583 
584 /**
585  * Decode a macroblock
586  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
587  */
589 
590 /**
591  * Decode a CABAC coded macroblock
592  * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
593  */
595 
597 
601  int *mb_type);
602 
603 void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
604  uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
605  unsigned int linesize, unsigned int uvlinesize);
606 void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
607  uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
608  unsigned int linesize, unsigned int uvlinesize);
609 
610 /*
611  * o-o o-o
612  * / / /
613  * o-o o-o
614  * ,---'
615  * o-o o-o
616  * / / /
617  * o-o o-o
618  */
619 
620 /* Scan8 organization:
621  * 0 1 2 3 4 5 6 7
622  * 0 DY y y y y y
623  * 1 y Y Y Y Y
624  * 2 y Y Y Y Y
625  * 3 y Y Y Y Y
626  * 4 y Y Y Y Y
627  * 5 DU u u u u u
628  * 6 u U U U U
629  * 7 u U U U U
630  * 8 u U U U U
631  * 9 u U U U U
632  * 10 DV v v v v v
633  * 11 v V V V V
634  * 12 v V V V V
635  * 13 v V V V V
636  * 14 v V V V V
637  * DY/DU/DV are for luma/chroma DC.
638  */
639 
640 #define LUMA_DC_BLOCK_INDEX 48
641 #define CHROMA_DC_BLOCK_INDEX 49
642 
643 // This table must be here because scan8[constant] must be known at compiletime
644 static const uint8_t scan8[16 * 3 + 3] = {
645  4 + 1 * 8, 5 + 1 * 8, 4 + 2 * 8, 5 + 2 * 8,
646  6 + 1 * 8, 7 + 1 * 8, 6 + 2 * 8, 7 + 2 * 8,
647  4 + 3 * 8, 5 + 3 * 8, 4 + 4 * 8, 5 + 4 * 8,
648  6 + 3 * 8, 7 + 3 * 8, 6 + 4 * 8, 7 + 4 * 8,
649  4 + 6 * 8, 5 + 6 * 8, 4 + 7 * 8, 5 + 7 * 8,
650  6 + 6 * 8, 7 + 6 * 8, 6 + 7 * 8, 7 + 7 * 8,
651  4 + 8 * 8, 5 + 8 * 8, 4 + 9 * 8, 5 + 9 * 8,
652  6 + 8 * 8, 7 + 8 * 8, 6 + 9 * 8, 7 + 9 * 8,
653  4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
654  6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
655  4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
656  6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
657  0 + 0 * 8, 0 + 5 * 8, 0 + 10 * 8
658 };
659 
660 static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
661 {
662 #if HAVE_BIGENDIAN
663  return (b & 0xFFFF) + (a << 16);
664 #else
665  return (a & 0xFFFF) + (b << 16);
666 #endif
667 }
668 
669 static av_always_inline uint16_t pack8to16(unsigned a, unsigned b)
670 {
671 #if HAVE_BIGENDIAN
672  return (b & 0xFF) + (a << 8);
673 #else
674  return (a & 0xFF) + (b << 8);
675 #endif
676 }
677 
678 /**
679  * Get the chroma qp.
680  */
681 static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
682 {
683  return pps->chroma_qp_table[t][qscale];
684 }
685 
686 /**
687  * Get the predicted intra4x4 prediction mode.
688  */
690  H264SliceContext *sl, int n)
691 {
692  const int index8 = scan8[n];
693  const int left = sl->intra4x4_pred_mode_cache[index8 - 1];
694  const int top = sl->intra4x4_pred_mode_cache[index8 - 8];
695  const int min = FFMIN(left, top);
696 
697  ff_tlog(h->avctx, "mode:%d %d min:%d\n", left, top, min);
698 
699  if (min < 0)
700  return DC_PRED;
701  else
702  return min;
703 }
704 
706  H264SliceContext *sl)
707 {
708  int8_t *i4x4 = sl->intra4x4_pred_mode + h->mb2br_xy[sl->mb_xy];
709  int8_t *i4x4_cache = sl->intra4x4_pred_mode_cache;
710 
711  AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
712  i4x4[4] = i4x4_cache[7 + 8 * 3];
713  i4x4[5] = i4x4_cache[7 + 8 * 2];
714  i4x4[6] = i4x4_cache[7 + 8 * 1];
715 }
716 
718  H264SliceContext *sl)
719 {
720  const int mb_xy = sl->mb_xy;
721  uint8_t *nnz = h->non_zero_count[mb_xy];
722  uint8_t *nnz_cache = sl->non_zero_count_cache;
723 
724  AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
725  AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
726  AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
727  AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
728  AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
729  AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
730  AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
731  AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
732 
733  if (!h->chroma_y_shift) {
734  AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
735  AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
736  AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
737  AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
738  }
739 }
740 
742  H264SliceContext *sl,
743  int b_stride,
744  int b_xy, int b8_xy,
745  int mb_type, int list)
746 {
747  int16_t(*mv_dst)[2] = &h->cur_pic.motion_val[list][b_xy];
748  int16_t(*mv_src)[2] = &sl->mv_cache[list][scan8[0]];
749  AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
750  AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
751  AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
752  AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
753  if (CABAC(h)) {
754  uint8_t (*mvd_dst)[2] = &sl->mvd_table[list][FMO ? 8 * sl->mb_xy
755  : h->mb2br_xy[sl->mb_xy]];
756  uint8_t(*mvd_src)[2] = &sl->mvd_cache[list][scan8[0]];
757  if (IS_SKIP(mb_type)) {
758  AV_ZERO128(mvd_dst);
759  } else {
760  AV_COPY64(mvd_dst, mvd_src + 8 * 3);
761  AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
762  AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
763  AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
764  }
765  }
766 
767  {
768  int8_t *ref_index = &h->cur_pic.ref_index[list][b8_xy];
769  int8_t *ref_cache = sl->ref_cache[list];
770  ref_index[0 + 0 * 2] = ref_cache[scan8[0]];
771  ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
772  ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
773  ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
774  }
775 }
776 
778  H264SliceContext *sl,
779  int mb_type)
780 {
781  const int b_stride = h->b_stride;
782  const int b_xy = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride; // try mb2b(8)_xy
783  const int b8_xy = 4 * sl->mb_xy;
784 
785  if (USES_LIST(mb_type, 0)) {
786  write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 0);
787  } else {
788  fill_rectangle(&h->cur_pic.ref_index[0][b8_xy],
789  2, 2, 2, (uint8_t)LIST_NOT_USED, 1);
790  }
791  if (USES_LIST(mb_type, 1))
792  write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 1);
793 
794  if (sl->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) {
795  if (IS_8X8(mb_type)) {
796  uint8_t *direct_table = &h->direct_table[4 * sl->mb_xy];
797  direct_table[1] = sl->sub_mb_type[1] >> 1;
798  direct_table[2] = sl->sub_mb_type[2] >> 1;
799  direct_table[3] = sl->sub_mb_type[3] >> 1;
800  }
801  }
802 }
803 
805 {
807  return !(AV_RN64A(sl->sub_mb_type) &
809  0x0001000100010001ULL));
810  else
811  return !(AV_RN64A(sl->sub_mb_type) &
813  0x0001000100010001ULL));
814 }
815 
816 static inline int find_start_code(const uint8_t *buf, int buf_size,
817  int buf_index, int next_avc)
818 {
819  uint32_t state = -1;
820 
821  buf_index = avpriv_find_start_code(buf + buf_index, buf + next_avc + 1, &state) - buf - 1;
822 
823  return FFMIN(buf_index, buf_size);
824 }
825 
826 int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup);
827 
830 
832 
833 void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height);
834 
836  const H2645NAL *nal);
837 /**
838  * Submit a slice for decoding.
839  *
840  * Parse the slice header, starting a new field/frame if necessary. If any
841  * slices are queued for the previous field, they are decoded.
842  */
846  const AVCodecContext *src);
847 
849 
851 
852 void ff_h264_set_erpic(ERPicture *dst, H264Picture *src);
853 
854 #endif /* AVCODEC_H264DEC_H */
void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:327
struct H264Context * h264
Definition: h264dec.h:178
const uint8_t * left_block
Definition: h264dec.h:218
#define ff_tlog(ctx,...)
Definition: internal.h:75
Memory management control operation.
Definition: h264dec.h:122
int nb_mmco
Definition: h264dec.h:474
int workaround_bugs
Definition: h264dec.h:367
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:154
int sei_recovery_frame_cnt
Definition: h264dec.h:163
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
Definition: h264_refs.c:834
int topright_mb_xy
Definition: h264dec.h:210
H264POCContext poc
Definition: h264dec.h:460
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
int mb_num
Definition: h264dec.h:437
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int mb_aff_frame
Definition: h264dec.h:406
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
Definition: h264_picture.c:66
int topleft_partition
Definition: h264dec.h:219
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:299
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int neighbor_transform_size
number of neighbors (top and/or left) that used 8x8 dct
Definition: h264dec.h:249
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:59
int edge_emu_buffer_allocated
Definition: h264dec.h:287
int first_field
Definition: h264dec.h:408
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:610
int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
Decode a CABAC coded macroblock.
Definition: h264_cabac.c:1914
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:681
unsigned int topleft_samples_available
Definition: h264dec.h:221
H264ChromaContext h264chroma
Definition: h264dec.h:342
uint16_t * cbp_table
Definition: h264dec.h:413
uint8_t mvd_cache[2][5 *8][2]
Definition: h264dec.h:301
int mb_y
Definition: h264dec.h:434
int coded_picture_number
Definition: h264dec.h:363
AVBufferRef * mb_type_buf
Definition: h264dec.h:138
int bipred_scratchpad_allocated
Definition: h264dec.h:286
AVBufferPool * mb_type_pool
Definition: h264dec.h:550
Picture parameter set.
Definition: h264_ps.h:109
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
Definition: h264dec.c:180
int prev_mb_skipped
Definition: h264dec.h:199
int16_t(*[2] motion_val)[2]
Definition: h264dec.h:136
int flags
Definition: h264dec.h:366
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
static int find_start_code(const uint8_t *buf, int buf_size, int buf_index, int next_avc)
Definition: h264dec.h:816
#define MB_TYPE_16x8
Definition: mpegutils.h:55
int is_avc
Used to parse AVC variant of H.264.
Definition: h264dec.h:450
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
Definition: h264_picture.c:45
AVBufferPool * ref_index_pool
Definition: h264dec.h:552
int height_from_caller
Definition: h264dec.h:543
int next_slice_idx
Definition: h264dec.h:236
static const uint8_t zigzag_scan8x8_cavlc[64+1]
Definition: h264_slice.c:97
H264Context.
Definition: h264dec.h:337
AVFrame * f
Definition: h264dec.h:129
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
Definition: h264_picture.c:131
static const uint8_t field_scan[16+1]
Definition: h264_slice.c:51
#define src
Definition: vp8dsp.c:254
#define CABAC(h)
Definition: h264dec.h:94
int picture_structure
Definition: h264dec.h:407
#define AV_COPY32(d, s)
Definition: intreadwrite.h:601
MMCOOpcode opcode
Definition: h264dec.h:123
H.264 DSP functions.
uint8_t * chroma_pred_mode_table
Definition: h264dec.h:416
int setup_finished
Definition: h264dec.h:534
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
#define USES_LIST(a, list)
Definition: mpegutils.h:99
uint16_t sub_mb_type[4]
as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
Definition: h264dec.h:304
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:102
int short_pic_num
pic_num without wrapping (pic_num & max_pic_num)
Definition: h264dec.h:124
uint8_t
#define mb
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:62
int slice_alpha_c0_offset
Definition: h264dec.h:194
int poc
Definition: h264dec.h:171
int field_picture
whether or not picture was encoded in separate fields
Definition: h264dec.h:158
int poc
frame POC
Definition: h264dec.h:148
void ff_h264_flush_change(H264Context *h)
Definition: h264dec.c:483
int invalid_gap
Definition: h264dec.h:162
Context for storing H.264 prediction functions.
Definition: h264pred.h:92
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:565
quarterpel DSP functions
int frame_recovered
Initial frame has been completely recovered.
Definition: h264dec.h:524
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
#define height
int picture_structure
Definition: h264dec.h:240
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264dec.h:689
int chroma_y_shift
Definition: h264dec.h:360
AVBufferRef * qscale_table_buf
Definition: h264dec.h:132
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
H264Picture * parent
Definition: h264dec.h:174
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:161
#define AV_COPY64(d, s)
Definition: intreadwrite.h:605
The buffer pool.
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
int width
Definition: h264dec.h:359
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264dec.h:777
unsigned int topright_samples_available
Definition: h264dec.h:223
H.264 parameter set handling.
H264PredContext hpc
Definition: h264dec.h:386
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
#define MB_TYPE_8x16
Definition: mpegutils.h:56
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
Definition: h264_direct.c:721
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
void * hwaccel_picture_private
hardware accelerator private data
Definition: h264dec.h:142
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264dec.h:205
static const uint8_t field_scan8x8[64+1]
Definition: h264_slice.c:58
H2645Packet pkt
Definition: h264dec.h:354
int picture_idr
Definition: h264dec.h:378
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
Definition: h264dec.h:193
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
ThreadFrame tf
Definition: h264dec.h:130
#define IS_SKIP(a)
Definition: mpegutils.h:81
H264QpelContext h264qpel
Definition: h264dec.h:343
int direct_spatial_mv_pred
Definition: h264dec.h:251
unsigned int top_samples_available
Definition: h264dec.h:222
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:149
MMCOOpcode
Memory management control operation opcode.
Definition: h264dec.h:109
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
Definition: h264_refs.c:423
int valid_recovery_point
Are the SEI recovery points looking valid.
Definition: h264dec.h:503
uint8_t * list_counts
Array of list_count per MB specifying the slice type.
Definition: h264dec.h:410
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
Definition: h264_slice.c:2203
static av_always_inline uint16_t pack8to16(unsigned a, unsigned b)
Definition: h264dec.h:669
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:184
AVBufferRef * hwaccel_priv_buf
Definition: h264dec.h:141
int crop_bottom
Definition: h264dec.h:383
int pic_id
Definition: h264dec.h:172
void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl)
Definition: h264_cabac.c:1263
uint8_t * direct_table
Definition: h264dec.h:418
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:804
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: h264dec.h:451
useful rectangle filling function
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:121
#define b
Definition: input.c:41
Context for storing H.264 DSP functions.
Definition: h264dsp.h:42
int chroma_pred_mode
Definition: h264dec.h:202
#define AV_COPY16(d, s)
Definition: intreadwrite.h:597
int x264_build
Definition: h264dec.h:368
uint32_t * mb2br_xy
Definition: h264dec.h:400
#define FFMIN(a, b)
Definition: common.h:96
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264dec.h:403
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
CABACContext cabac
Cabac.
Definition: h264dec.h:318
unsigned int first_mb_addr
Definition: h264dec.h:234
int reference
Definition: h264dec.h:160
#define LEFT_MBS
Definition: h264dec.h:75
int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, const H2645NAL *nal)
int redundant_pic_count
Definition: h264dec.h:244
int nb_slice_ctx
Definition: h264dec.h:351
H264PredWeightTable pwt
Definition: h264dec.h:197
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:154
int long_ref_count
number of actual long term references
Definition: h264dec.h:478
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:702
uint32_t * mb_type
Definition: h264dec.h:139
int next_mb_skipped
Definition: h264dec.h:200
uint8_t chroma_qp_table[2][QP_MAX_NUM+1]
pre-scaled (with chroma_qp_index_offset) version of qp_table
Definition: h264_ps.h:127
int mmco_reset
Definition: h264dec.h:475
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
Definition: h264_slice.c:2078
H264SliceContext * slice_ctx
Definition: h264dec.h:350
int direct_8x8_inference_flag
Definition: h264_ps.h:64
int n
Definition: avisynth_c.h:760
int reference
Definition: h264dec.h:170
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:827
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:58
uint8_t * edge_emu_buffer
Definition: h264dec.h:284
#define MB_TYPE_8x8
Definition: mpegutils.h:57
int bit_depth_luma
luma bit depth from sps to detect changes
Definition: h264dec.h:453
int chroma_format_idc
chroma format from sps to detect changes
Definition: h264dec.h:454
VideoDSPContext vdsp
Definition: h264dec.h:340
int intra16x16_pred_mode
Definition: h264dec.h:203
int mb_stride
Definition: h264dec.h:436
int postpone_filter
Definition: h264dec.h:373
AVCodecContext * avctx
Definition: h264dec.h:339
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:299
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
static struct @320 state
int last_qscale_diff
Definition: h264dec.h:190
int crop_left
Definition: h264dec.h:380
int next_outputed_poc
Definition: h264dec.h:468
int explicit_ref_marking
Definition: h264dec.h:476
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:1568
int qp_thresh
QP threshold to skip loopfilter.
Definition: h264dec.h:189
int explicit_ref_marking
Definition: h264dec.h:324
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 list
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
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
static const uint8_t field_scan8x8_cavlc[64+1]
Definition: h264_slice.c:77
Describe the class of an AVClass context structure.
Definition: log.h:67
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:294
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:660
int8_t * ref_index[2]
Definition: h264dec.h:145
int pixel_shift
0 for 8-bit H.264, 1 for high-bit-depth H.264
Definition: h264dec.h:356
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:150
H264Picture * cur_pic_ptr
Definition: h264dec.h:346
#define LIST_NOT_USED
Definition: h264dec.h:390
ptrdiff_t mb_uvlinesize
Definition: h264dec.h:228
refcounted data buffer API
#define FMO
Definition: h264dec.h:62
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:242
int enable_er
Definition: h264dec.h:545
const SPS * sps
Definition: h264_ps.h:146
int width_from_caller
Definition: h264dec.h:542
ptrdiff_t mb_linesize
may be equal to s->linesize or s->linesize * 2, for mbaff
Definition: h264dec.h:227
ptrdiff_t uvlinesize
Definition: h264dec.h:226
H.264 / AVC / MPEG-4 prediction functions.
unsigned int list_count
Definition: h264dec.h:268
Definition: vp9.h:48
#define AV_ZERO128(d)
Definition: intreadwrite.h:637
int has_recovery_point
Definition: h264dec.h:526
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:288
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
Definition: h264_mb.c:799
int mbaff
1 -> MBAFF frame 0-> not MBAFF
Definition: h264dec.h:157
A reference to a data buffer.
Definition: buffer.h:81
int nb_slice_ctx_queued
Definition: h264dec.h:352
AVBufferPool * qscale_table_pool
Definition: h264dec.h:549
H264Picture * next_output_pic
Definition: h264dec.h:467
AVBufferPool * motion_val_pool
Definition: h264dec.h:551
static av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:717
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num) ...
Definition: h264dec.h:152
int delta_poc_bottom
Definition: h264dec.h:328
#define MAX_SLICES
The maximum number of slices supported by the decoder.
Definition: h264dec.h:68
common internal api header.
static av_always_inline void write_back_motion_list(const H264Context *h, H264SliceContext *sl, int b_stride, int b_xy, int b8_xy, int mb_type, int list)
Definition: h264dec.h:741
#define AV_COPY128(d, s)
Definition: intreadwrite.h:609
uint16_t * slice_table_base
Definition: h264dec.h:458
int missing_fields
Definition: h264dec.h:528
H264ParamSets ps
Definition: h264dec.h:456
void ff_h264_free_tables(H264Context *h)
Definition: h264dec.c:137
Bi-dir predicted.
Definition: avutil.h:276
uint8_t op
Definition: h264dec.h:273
int cur_chroma_format_idc
Definition: h264dec.h:536
int8_t * intra4x4_pred_mode
Definition: h264dec.h:206
int long_arg
index, pic_num, or num long refs depending on opcode
Definition: h264dec.h:125
Core video DSP helper functions.
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:300
Decoded Picture Buffer (DPB).
Definition: vaapi_h264.c:82
unsigned int pps_id
Definition: h264dec.h:278
#define IS_8X8(a)
Definition: mpegutils.h:89
H264Picture cur_pic
Definition: h264dec.h:347
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
uint32_t * mb2b_xy
Definition: h264dec.h:399
int cur_bit_depth_luma
Definition: h264dec.h:537
int crop_top
Definition: h264dec.h:382
H264Picture last_pic_for_ec
Definition: h264dec.h:348
const uint8_t * intra_pcm_ptr
Definition: h264dec.h:280
H264DSPContext h264dsp
Definition: h264dec.h:341
unsigned int left_samples_available
Definition: h264dec.h:224
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:313
int slice_type_fixed
Definition: h264dec.h:185
#define av_always_inline
Definition: attributes.h:39
int slice_beta_offset
Definition: h264dec.h:195
int8_t * intra4x4_pred_mode
Definition: h264dec.h:385
#define AV_RN64A(p)
Definition: intreadwrite.h:530
int mb_field_decoding_flag
Definition: h264dec.h:241
uint8_t(* non_zero_count)[48]
Definition: h264dec.h:388
H.264 decoder/parser shared code.
uint8_t * bipred_scratchpad
Definition: h264dec.h:283
float min
int droppable
Definition: h264dec.h:362
int crop_right
Definition: h264dec.h:381
int nal_ref_idc
Definition: h264dec.h:442
GetBitContext gb
Definition: h264dec.h:179
uint32_t val
Definition: h264dec.h:274
int cabac_init_idc
Definition: h264dec.h:320
int b_stride
Definition: h264dec.h:401
Context Adaptive Binary Arithmetic Coder.
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:705
#define H264_MAX_PICTURE_COUNT
Definition: h264dec.h:52
#define MAX_MMCO_COUNT
Definition: h264dec.h:54
int short_ref_count
number of actual short term references
Definition: h264dec.h:479