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