FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
136  int16_t (*motion_val[2])[2];
137 
139  uint32_t *mb_type;
140 
142  void *hwaccel_picture_private; ///< hardware accelerator private data
143 
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 
207 
212 
214  int top_type;
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 
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];
277 
278  unsigned int pps_id;
279 
281  int16_t *dc_val_base;
282 
285  uint8_t (*top_borders[2])[(16 * 3) * 2];
289 
290  /**
291  * non zero coeff count cache.
292  * is 64 if not available.
293  */
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];
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  */
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;
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 
387 
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 
433 
434  int mb_y;
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 
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 
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:830
int16_t mb[16 *48 *2]
Definition: h264dec.h:307
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:201
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:101
int neighbor_transform_size
number of neighbors (top and/or left) that used 8x8 dct
Definition: h264dec.h:249
int dist_scale_factor[32]
Definition: h264dec.h:259
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:59
int edge_emu_buffer_allocated
Definition: h264dec.h:287
int first_field
Definition: h264dec.h:408
uint8_t field_scan8x8_q0[64]
Definition: h264dec.h:431
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:608
int left_mb_xy[LEFT_MBS]
Definition: h264dec.h:211
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
MMCO mmco[MAX_MMCO_COUNT]
memory management control operations buffer.
Definition: h264dec.h:473
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
const char * b
Definition: vf_curves.c:113
AVBufferPool * mb_type_pool
Definition: h264dec.h:550
int chroma_x_shift
Definition: h264dec.h:360
Picture parameter set.
Definition: h264_ps.h:108
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
int mb_height
Definition: h264dec.h:435
static int find_start_code(const uint8_t *buf, int buf_size, int buf_index, int next_avc)
Definition: h264dec.h:816
H264Picture * delayed_pic[MAX_DELAYED_PIC_COUNT+2]
Definition: h264dec.h:465
#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
H264Ref default_ref[2]
Definition: h264dec.h:462
AVBufferPool * ref_index_pool
Definition: h264dec.h:552
int height_from_caller
Definition: h264dec.h:543
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264dec.h:423
int next_slice_idx
Definition: h264dec.h:236
H264Context.
Definition: h264dec.h:337
int16_t mb_padding[256 *2]
Definition: h264dec.h:311
AVFrame * f
Definition: h264dec.h:129
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
Definition: h264_picture.c:131
int nb_ref_modifications[2]
Definition: h264dec.h:276
H264Picture * long_ref[32]
Definition: h264dec.h:464
#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:586
MMCOOpcode opcode
Definition: h264dec.h:123
H.264 DSP functions.
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:267
MMCO mmco[MAX_MMCO_COUNT]
Definition: h264dec.h:322
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:2725
H264SEIContext sei
Definition: h264dec.h:547
#define USES_LIST(a, list)
Definition: mpegutils.h:99
int ref2frm[MAX_SLICES][2][64]
reference to frame number lists, used in the loop filter, the first 2 are for -2,-1 ...
Definition: h264dec.h:553
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
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:484
static struct @281 state
uint8_t(*[2] top_borders)[(16 *3)*2]
Definition: h264dec.h:285
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:563
quarterpel DSP functions
int frame_recovered
Initial frame has been completely recovered.
Definition: h264dec.h:524
int map_col_to_list0_field[2][2][16+32]
Definition: h264dec.h:262
int height
Definition: h264dec.h:359
#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:590
int chroma_qp[2]
Definition: h264dec.h:188
The buffer pool.
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
int last_pocs[MAX_DELAYED_PIC_COUNT]
Definition: h264dec.h:466
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
int map_col_to_list0[2][16+32]
Definition: h264dec.h:261
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264dec.h:205
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
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:417
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 ref_poc[2][2][32]
POCs of the frames/fields used as reference (FIXME need per slice)
Definition: h264dec.h:155
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:421
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:2139
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
uint8_t zigzag_scan8x8[64]
Definition: h264dec.h:422
AVBufferRef * hwaccel_priv_buf
Definition: h264dec.h:141
uint8_t cabac_state[1024]
Definition: h264dec.h:319
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
int16_t mb_luma_dc[3][16 *2]
as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too lar...
Definition: h264dec.h:308
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
AVBufferRef * motion_val_buf[2]
Definition: h264dec.h:135
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:582
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)
uint8_t field_scan8x8_cavlc[64]
Definition: h264dec.h:426
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:126
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:2014
H264SliceContext * slice_ctx
Definition: h264dec.h:350
int direct_8x8_inference_flag
Definition: h264_ps.h:63
int n
Definition: avisynth_c.h:684
int reference
Definition: h264dec.h:170
int top_borders_allocated[2]
Definition: h264dec.h:288
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:822
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:58
uint8_t * edge_emu_buffer
Definition: h264dec.h:284
uint8_t zigzag_scan_q0[16]
Definition: h264dec.h:427
#define MB_TYPE_8x8
Definition: mpegutils.h:57
int bit_depth_luma
luma bit depth from sps to detect changes
Definition: h264dec.h:453
uint8_t scan_padding[16]
Definition: h264dec.h:420
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
uint8_t zigzag_scan8x8_q0[64]
Definition: h264dec.h:428
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:299
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
int last_qscale_diff
Definition: h264dec.h:190
int crop_left
Definition: h264dec.h:380
H264Picture * short_ref[32]
Definition: h264dec.h:463
int next_outputed_poc
Definition: h264dec.h:468
int explicit_ref_marking
Definition: h264dec.h:476
int field_poc[2]
top/bottom POC
Definition: h264dec.h:147
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:1502
int qp_thresh
QP threshold to skip loopfilter.
Definition: h264dec.h:189
int explicit_ref_marking
Definition: h264dec.h:324
void * buf
Definition: avisynth_c.h:690
int8_t * qscale_table
Definition: h264dec.h:133
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:644
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
uint8_t direct_cache[5 *8]
Definition: h264dec.h:302
int enable_er
Definition: h264dec.h:545
const SPS * sps
Definition: h264_ps.h:145
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
int16_t slice_row[MAX_SLICES]
to detect when MAX_SLICES is too low
Definition: h264dec.h:538
ptrdiff_t linesize
Definition: h264dec.h:226
int block_offset[2 *(16 *3)]
block_offset[ 0..23] for frame macroblocks block_offset[24..47] for field macroblocks ...
Definition: h264dec.h:397
int linesize[3]
Definition: h264dec.h:168
ptrdiff_t uvlinesize
Definition: h264dec.h:226
H.264 / AVC / MPEG-4 prediction functions.
uint8_t zigzag_scan[16]
Definition: h264dec.h:421
unsigned int list_count
Definition: h264dec.h:268
Definition: vp9.h:48
#define AV_ZERO128(d)
Definition: intreadwrite.h:622
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 left_type[LEFT_MBS]
Definition: h264dec.h:216
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:594
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.
uint8_t zigzag_scan8x8_cavlc_q0[64]
Definition: h264dec.h:429
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
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:269
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264dec.h:432
int cur_bit_depth_luma
Definition: h264dec.h:537
int crop_top
Definition: h264dec.h:382
struct H264SliceContext::@80 ref_modifications[2][32]
AVBufferRef * ref_index_buf[2]
Definition: h264dec.h:144
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
int ref_count[2][2]
number of entries in ref_poc (FIXME need per slice)
Definition: h264dec.h:156
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:313
uint8_t field_scan8x8[64]
Definition: h264dec.h:425
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
int dist_scale_factor_field[2][32]
Definition: h264dec.h:260
int delta_poc[2]
Definition: h264dec.h:329
#define AV_RN64A(p)
Definition: intreadwrite.h:530
uint8_t field_scan_q0[16]
Definition: h264dec.h:430
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
uint8_t field_scan[16]
Definition: h264dec.h:424
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