Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
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 32
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 
68 #define MAX_SLICES 32
69 
70 #ifdef ALLOW_INTERLACE
71 #define MB_MBAFF(h) h->mb_mbaff
72 #define MB_FIELD(h) h->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(h) 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 CHROMA422(h) (h->ps.sps->chroma_format_idc == 2)
98 #define CHROMA444(h) (h->ps.sps->chroma_format_idc == 3)
99 
100 #define MB_TYPE_REF0 MB_TYPE_ACPRED // dirty but it fits in 16 bit
101 #define MB_TYPE_8x8DCT 0x01000000
102 #define IS_REF0(a) ((a) & MB_TYPE_REF0)
103 #define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT)
104 
108 typedef enum MMCOOpcode {
109  MMCO_END = 0,
116 } MMCOOpcode;
117 
121 typedef struct MMCO {
124  int long_arg;
125 } MMCO;
126 
127 typedef struct H264Picture {
130 
132  int8_t *qscale_table;
133 
134  AVBufferRef *motion_val_buf[2];
135  int16_t (*motion_val[2])[2];
136 
138  uint32_t *mb_type;
139 
142 
143  AVBufferRef *ref_index_buf[2];
144  int8_t *ref_index[2];
145 
146  int field_poc[2];
147  int poc;
148  int frame_num;
151  int pic_id;
153  int long_ref;
154  int ref_poc[2][2][32];
155  int ref_count[2][2];
156  int mbaff;
158 
160  int recovered;
161 } H264Picture;
162 
163 typedef struct H264Ref {
165  int linesize[3];
166 
168  int poc;
169  int pic_id;
170 
172 } H264Ref;
173 
174 typedef struct H264SliceContext {
175  struct H264Context *h264;
178 
183 
184  int qscale;
185  int chroma_qp[2]; // QPc
186  int qp_thresh;
188 
189  // deblock
193 
195 
198 
201 
202  int8_t intra4x4_pred_mode_cache[5 * 8];
204 
208  int left_mb_xy[LEFT_MBS];
209 
211  int top_type;
213  int left_type[LEFT_MBS];
214 
217 
219  unsigned int top_samples_available;
222 
223  ptrdiff_t linesize, uvlinesize;
224  ptrdiff_t mb_linesize;
225  ptrdiff_t mb_uvlinesize;
226 
227  int mb_x, mb_y;
228  int mb_xy;
231  unsigned int first_mb_addr;
232  // index of the first MB of the next slice
236 
239  int mb_mbaff;
240 
242 
247 
251 
252  int cbp;
253  int top_cbp;
254  int left_cbp;
255 
256  int dist_scale_factor[32];
257  int dist_scale_factor_field[2][32];
258  int map_col_to_list0[2][16 + 32];
259  int map_col_to_list0_field[2][2][16 + 32];
260 
264  unsigned int ref_count[2];
265  unsigned int list_count;
266  H264Ref ref_list[2][48];
269  struct {
271  uint32_t val;
272  } ref_modifications[2][32];
273  int nb_ref_modifications[2];
274 
275  unsigned int pps_id;
276 
278  int16_t *dc_val_base;
279 
282  uint8_t (*top_borders[2])[(16 * 3) * 2];
285  int top_borders_allocated[2];
286 
291  DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
292 
296  DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
297  DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
298  DECLARE_ALIGNED(16, uint8_t, mvd_cache)[2][5 * 8][2];
299  uint8_t direct_cache[5 * 8];
300 
301  DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4];
302 
304  DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
305  DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
308  int16_t mb_padding[256 * 2];
309 
310  uint8_t (*mvd_table[2])[2];
311 
316  uint8_t cabac_state[1024];
318 
320  int nb_mmco;
322 
324  int poc_lsb;
326  int delta_poc[2];
330 
334 typedef struct H264Context {
335  const AVClass *class;
341 
345 
349 
351 
353 
354  /* coded dimensions -- 16 * mb w/h */
355  int width, height;
356  int chroma_x_shift, chroma_y_shift;
357 
360 
362  int flags;
365  /* Set when slice threading is used and at least one slice uses deblocking
366  * mode 1 (i.e. across slice boundaries). Then we disable the loop filter
367  * during normal MB decoding and execute it serially at the end.
368  */
370 
371  /*
372  * Set to 1 when the current picture is IDR, 0 otherwise.
373  */
375 
376  int8_t(*intra4x4_pred_mode);
378 
379  uint8_t (*non_zero_count)[48];
380 
381 #define LIST_NOT_USED -1 // FIXME rename?
382 #define PART_NOT_AVAILABLE -2
383 
388  int block_offset[2 * (16 * 3)];
389 
390  uint32_t *mb2b_xy; // FIXME are these 4 a good idea?
391  uint32_t *mb2br_xy;
392  int b_stride; // FIXME use s->b4_stride
393 
394  uint16_t *slice_table;
395 
396  // interlacing specific flags
400 
402 
403  /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
404  uint16_t *cbp_table;
405 
406  /* chroma_pred_mode for i4x4 or i16x16, else 0 */
408  uint8_t (*mvd_table[2])[2];
410 
411  uint8_t zigzag_scan[16];
412  uint8_t zigzag_scan8x8[64];
423 
424  int mb_y;
425  int mb_height, mb_width;
427  int mb_num;
428 
429  // =============================================================
430  // Things below are not used in the MB or more inner code
431 
434 
438  int is_avc;
440 
443 
445 
446  uint16_t *slice_table_base;
447 
449 
450  H264Picture *short_ref[32];
451  H264Picture *long_ref[32];
452  H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
453  int last_pocs[MAX_DELAYED_PIC_COUNT];
455 
460  int nb_mmco;
463 
466 
475 
485 
493 
498 #define FRAME_RECOVERED_IDR (1 << 0)
499 
503 #define FRAME_RECOVERED_SEI (1 << 1)
504 
506 
507  /* for frame threading, this is set to 1
508  * after finish_setup() has been called, so we cannot modify
509  * some context properties (which are supposed to stay constant between
510  * slices) anymore */
512 
513  /* This is set to 1 if h264_field_start() has been called successfully,
514  * so all per-field state is properly initialized and we can decode
515  * the slice data */
517 
519 
521 
523 
528  int ref2frm[MAX_SLICES][2][64];
529 } H264Context;
530 
531 extern const uint16_t ff_h264_mb_sizes[4];
532 
537 
543 
547 
552 
554  const H2645NAL *nal, void *logctx);
555 
558 void ff_h264_decode_init_vlc(void);
559 
565 
571 
573 
575 
579  int *mb_type);
580 
581 void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
582  uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
583  unsigned int linesize, unsigned int uvlinesize);
584 void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
585  uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
586  unsigned int linesize, unsigned int uvlinesize);
587 
588 /*
589  * o-o o-o
590  * / / /
591  * o-o o-o
592  * ,---'
593  * o-o o-o
594  * / / /
595  * o-o o-o
596  */
597 
598 /* Scan8 organization:
599  * 0 1 2 3 4 5 6 7
600  * 0 DY y y y y y
601  * 1 y Y Y Y Y
602  * 2 y Y Y Y Y
603  * 3 y Y Y Y Y
604  * 4 y Y Y Y Y
605  * 5 DU u u u u u
606  * 6 u U U U U
607  * 7 u U U U U
608  * 8 u U U U U
609  * 9 u U U U U
610  * 10 DV v v v v v
611  * 11 v V V V V
612  * 12 v V V V V
613  * 13 v V V V V
614  * 14 v V V V V
615  * DY/DU/DV are for luma/chroma DC.
616  */
617 
618 #define LUMA_DC_BLOCK_INDEX 48
619 #define CHROMA_DC_BLOCK_INDEX 49
620 
621 // This table must be here because scan8[constant] must be known at compiletime
622 static const uint8_t scan8[16 * 3 + 3] = {
623  4 + 1 * 8, 5 + 1 * 8, 4 + 2 * 8, 5 + 2 * 8,
624  6 + 1 * 8, 7 + 1 * 8, 6 + 2 * 8, 7 + 2 * 8,
625  4 + 3 * 8, 5 + 3 * 8, 4 + 4 * 8, 5 + 4 * 8,
626  6 + 3 * 8, 7 + 3 * 8, 6 + 4 * 8, 7 + 4 * 8,
627  4 + 6 * 8, 5 + 6 * 8, 4 + 7 * 8, 5 + 7 * 8,
628  6 + 6 * 8, 7 + 6 * 8, 6 + 7 * 8, 7 + 7 * 8,
629  4 + 8 * 8, 5 + 8 * 8, 4 + 9 * 8, 5 + 9 * 8,
630  6 + 8 * 8, 7 + 8 * 8, 6 + 9 * 8, 7 + 9 * 8,
631  4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
632  6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
633  4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
634  6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
635  0 + 0 * 8, 0 + 5 * 8, 0 + 10 * 8
636 };
637 
638 static av_always_inline uint32_t pack16to32(int a, int b)
639 {
640 #if HAVE_BIGENDIAN
641  return (b & 0xFFFF) + (a << 16);
642 #else
643  return (a & 0xFFFF) + (b << 16);
644 #endif
645 }
646 
647 static av_always_inline uint16_t pack8to16(int a, int b)
648 {
649 #if HAVE_BIGENDIAN
650  return (b & 0xFF) + (a << 8);
651 #else
652  return (a & 0xFF) + (b << 8);
653 #endif
654 }
655 
659 static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
660 {
661  return pps->chroma_qp_table[t][qscale];
662 }
663 
668  H264SliceContext *sl, int n)
669 {
670  const int index8 = scan8[n];
671  const int left = sl->intra4x4_pred_mode_cache[index8 - 1];
672  const int top = sl->intra4x4_pred_mode_cache[index8 - 8];
673  const int min = FFMIN(left, top);
674 
675  ff_tlog(h->avctx, "mode:%d %d min:%d\n", left, top, min);
676 
677  if (min < 0)
678  return DC_PRED;
679  else
680  return min;
681 }
682 
684  H264SliceContext *sl)
685 {
686  int8_t *i4x4 = sl->intra4x4_pred_mode + h->mb2br_xy[sl->mb_xy];
687  int8_t *i4x4_cache = sl->intra4x4_pred_mode_cache;
688 
689  AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
690  i4x4[4] = i4x4_cache[7 + 8 * 3];
691  i4x4[5] = i4x4_cache[7 + 8 * 2];
692  i4x4[6] = i4x4_cache[7 + 8 * 1];
693 }
694 
696  H264SliceContext *sl)
697 {
698  const int mb_xy = sl->mb_xy;
699  uint8_t *nnz = h->non_zero_count[mb_xy];
700  uint8_t *nnz_cache = sl->non_zero_count_cache;
701 
702  AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
703  AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
704  AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
705  AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
706  AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
707  AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
708  AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
709  AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
710 
711  if (!h->chroma_y_shift) {
712  AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
713  AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
714  AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
715  AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
716  }
717 }
718 
720  H264SliceContext *sl,
721  int b_stride,
722  int b_xy, int b8_xy,
723  int mb_type, int list)
724 {
725  int16_t(*mv_dst)[2] = &h->cur_pic.motion_val[list][b_xy];
726  int16_t(*mv_src)[2] = &sl->mv_cache[list][scan8[0]];
727  AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
728  AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
729  AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
730  AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
731  if (CABAC(h)) {
732  uint8_t (*mvd_dst)[2] = &sl->mvd_table[list][FMO ? 8 * sl->mb_xy
733  : h->mb2br_xy[sl->mb_xy]];
734  uint8_t(*mvd_src)[2] = &sl->mvd_cache[list][scan8[0]];
735  if (IS_SKIP(mb_type)) {
736  AV_ZERO128(mvd_dst);
737  } else {
738  AV_COPY64(mvd_dst, mvd_src + 8 * 3);
739  AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
740  AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
741  AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
742  }
743  }
744 
745  {
746  int8_t *ref_index = &h->cur_pic.ref_index[list][b8_xy];
747  int8_t *ref_cache = sl->ref_cache[list];
748  ref_index[0 + 0 * 2] = ref_cache[scan8[0]];
749  ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
750  ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
751  ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
752  }
753 }
754 
756  H264SliceContext *sl,
757  int mb_type)
758 {
759  const int b_stride = h->b_stride;
760  const int b_xy = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride; // try mb2b(8)_xy
761  const int b8_xy = 4 * sl->mb_xy;
762 
763  if (USES_LIST(mb_type, 0)) {
764  write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 0);
765  } else {
766  fill_rectangle(&h->cur_pic.ref_index[0][b8_xy],
767  2, 2, 2, (uint8_t)LIST_NOT_USED, 1);
768  }
769  if (USES_LIST(mb_type, 1))
770  write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 1);
771 
772  if (sl->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) {
773  if (IS_8X8(mb_type)) {
774  uint8_t *direct_table = &h->direct_table[4 * sl->mb_xy];
775  direct_table[1] = sl->sub_mb_type[1] >> 1;
776  direct_table[2] = sl->sub_mb_type[2] >> 1;
777  direct_table[3] = sl->sub_mb_type[3] >> 1;
778  }
779  }
780 }
781 
783 {
785  return !(AV_RN64A(sl->sub_mb_type) &
787  0x0001000100010001ULL));
788  else
789  return !(AV_RN64A(sl->sub_mb_type) &
791  0x0001000100010001ULL));
792 }
793 
794 int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup);
795 
798 
800 
801 void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height);
802 
812  const AVCodecContext *src);
813 
815 
817 
818 #endif /* AVCODEC_H264DEC_H */
void ff_h264_decode_init_vlc(void)
Definition: h264_cavlc.c:326
struct H264Context * h264
Definition: h264dec.h:175
const uint8_t * left_block
Definition: h264dec.h:215
#define ff_tlog(ctx,...)
Definition: internal.h:66
Memory management control operation.
Definition: h264dec.h:121
int nb_mmco
Definition: h264dec.h:460
int workaround_bugs
Definition: h264dec.h:363
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:153
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
Definition: h264_refs.c:738
int topright_mb_xy
Definition: h264dec.h:207
H264POCContext poc
Definition: h264dec.h:448
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:427
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
int mb_aff_frame
Definition: h264dec.h:397
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
Definition: h264_picture.c:66
int topleft_partition
Definition: h264dec.h:216
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:296
int neighbor_transform_size
number of neighbors (top and/or left) that used 8x8 dct
Definition: h264dec.h:246
int edge_emu_buffer_allocated
Definition: h264dec.h:284
int first_field
Definition: h264dec.h:399
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:552
int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
Decode a CABAC coded macroblock.
Definition: h264_cabac.c:1908
int ff_h264_build_ref_list(const H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:256
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:659
static const uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264_slice.c:96
unsigned int topleft_samples_available
Definition: h264dec.h:218
H264ChromaContext h264chroma
Definition: h264dec.h:339
uint16_t * cbp_table
Definition: h264dec.h:404
uint8_t mvd_cache[2][5 *8][2]
Definition: h264dec.h:298
int mb_y
Definition: h264dec.h:424
int coded_picture_number
Definition: h264dec.h:359
AVBufferRef * mb_type_buf
Definition: h264dec.h:137
int bipred_scratchpad_allocated
Definition: h264dec.h:283
AVBufferPool * mb_type_pool
Definition: h264dec.h:525
Picture parameter set.
Definition: h264_ps.h:106
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
Definition: h264dec.c:163
int prev_mb_skipped
Definition: h264dec.h:196
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:58
int16_t(*[2] motion_val)[2]
Definition: h264dec.h:135
int flags
Definition: h264dec.h:362
const uint8_t * field_scan8x8_q0
Definition: h264dec.h:421
int is_avc
Used to parse AVC variant of H.264.
Definition: h264dec.h:438
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
Definition: h264_picture.c:45
AVBufferPool * ref_index_pool
Definition: h264dec.h:527
int next_slice_idx
Definition: h264dec.h:233
H264Context.
Definition: h264dec.h:334
AVFrame * f
Definition: h264dec.h:128
#define CABAC(h)
Definition: h264dec.h:94
int picture_structure
Definition: h264dec.h:398
#define AV_COPY32(d, s)
Definition: intreadwrite.h:517
MMCOOpcode opcode
Definition: h264dec.h:122
H.264 DSP functions.
static const uint8_t field_scan8x8_cavlc[64]
Definition: h264_slice.c:76
uint8_t * chroma_pred_mode_table
Definition: h264dec.h:407
int setup_finished
Definition: h264dec.h:511
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
Definition: h264_slice.c:2495
H264SEIContext sei
Definition: h264dec.h:522
#define USES_LIST(a, list)
Definition: mpegutils.h:101
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:301
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:85
int short_pic_num
pic_num without wrapping (pic_num & max_pic_num)
Definition: h264dec.h:123
uint8_t
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:52
int slice_alpha_c0_offset
Definition: h264dec.h:191
int poc
Definition: h264dec.h:168
int field_picture
whether or not picture was encoded in separate fields
Definition: h264dec.h:157
int poc
frame POC
Definition: h264dec.h:147
void ff_h264_flush_change(H264Context *h)
Definition: h264dec.c:442
#define b
Definition: input.c:52
AVFrame * output_frame
Definition: h264dec.h:518
Context for storing H.264 prediction functions.
Definition: h264pred.h:92
void ff_h264_remove_all_refs(H264Context *h)
Definition: h264_refs.c:512
quarterpel DSP functions
int frame_recovered
Initial frame has been completely recovered.
Definition: h264dec.h:505
const char data[16]
Definition: mxf.c:70
uint8_t chroma_qp_table[2][64]
pre-scaled (with chroma_qp_index_offset) version of qp_table
Definition: h264_ps.h:124
int picture_structure
Definition: h264dec.h:237
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
Definition: h264dec.h:667
int chroma_y_shift
Definition: h264dec.h:356
AVBufferRef * qscale_table_buf
Definition: h264dec.h:131
H264Picture * parent
Definition: h264dec.h:171
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:160
#define AV_COPY64(d, s)
Definition: intreadwrite.h:521
The buffer pool.
int width
Definition: h264dec.h:355
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264dec.h:755
const uint8_t * zigzag_scan8x8_cavlc_q0
Definition: h264dec.h:419
#define src
Definition: vp8dsp.c:254
unsigned int topright_samples_available
Definition: h264dec.h:220
H.264 parameter set handling.
H264PredContext hpc
Definition: h264dec.h:377
int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
Init context Allocate buffers which are not shared amongst multiple threads.
Definition: h264dec.c:221
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
Definition: h264_direct.c:702
const uint8_t * zigzag_scan_q0
Definition: h264dec.h:417
int16_t * dc_val_base
Definition: h264dec.h:278
int context_initialized
Definition: h264dec.h:361
ERContext er
Definition: h264dec.h:177
int nal_unit_type
Definition: h264dec.h:433
void * hwaccel_picture_private
hardware accelerator private data
Definition: h264dec.h:141
int8_t intra4x4_pred_mode_cache[5 *8]
Definition: h264dec.h:202
H2645Packet pkt
Definition: h264dec.h:350
int picture_idr
Definition: h264dec.h:374
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
Definition: h264dec.h:190
int prev_interlaced_frame
Complement sei_pic_struct SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced...
Definition: h264dec.h:484
ThreadFrame tf
Definition: h264dec.h:129
#define IS_SKIP(a)
Definition: mpegutils.h:83
H264QpelContext h264qpel
Definition: h264dec.h:340
int direct_spatial_mv_pred
Definition: h264dec.h:248
unsigned int top_samples_available
Definition: h264dec.h:219
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:148
MMCOOpcode
Memory management control operation opcode.
Definition: h264dec.h:108
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
Definition: h264_refs.c:370
static const uint8_t field_scan8x8[64]
Definition: h264_slice.c:57
uint8_t * list_counts
Array of list_count per MB specifying the slice type.
Definition: h264dec.h:401
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
Definition: h264_slice.c:1928
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:181
AVBufferRef * hwaccel_priv_buf
Definition: h264dec.h:140
int pic_id
Definition: h264dec.h:169
void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl)
Definition: h264_cabac.c:1263
uint8_t * direct_table
Definition: h264dec.h:409
static av_always_inline uint16_t pack8to16(int a, int b)
Definition: h264dec.h:647
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:782
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: h264dec.h:439
useful rectangle filling function
static const uint8_t field_scan[16]
Definition: h264_slice.c:50
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:111
Context for storing H.264 DSP functions.
Definition: h264dsp.h:41
int chroma_pred_mode
Definition: h264dec.h:199
#define AV_COPY16(d, s)
Definition: intreadwrite.h:513
int x264_build
Definition: h264dec.h:364
uint32_t * mb2br_xy
Definition: h264dec.h:391
#define MB_TYPE_DIRECT2
Definition: avcodec.h:1090
#define FFMIN(a, b)
Definition: common.h:66
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264dec.h:394
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:315
unsigned int first_mb_addr
Definition: h264dec.h:231
int reference
Definition: h264dec.h:159
#define LEFT_MBS
Definition: h264dec.h:75
int redundant_pic_count
Definition: h264dec.h:241
int nb_slice_ctx
Definition: h264dec.h:347
H264PredWeightTable pwt
Definition: h264dec.h:194
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:145
int field_started
Definition: h264dec.h:516
int long_ref_count
number of actual long term references
Definition: h264dec.h:464
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:699
uint32_t * mb_type
Definition: h264dec.h:138
int next_mb_skipped
Definition: h264dec.h:197
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color)
Definition: avplay.c:392
int mmco_reset
Definition: h264dec.h:461
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
Definition: h264_slice.c:1859
H264SliceContext * slice_ctx
Definition: h264dec.h:346
int direct_8x8_inference_flag
Definition: h264_ps.h:63
int reference
Definition: h264dec.h:167
const uint16_t ff_h264_mb_sizes[4]
Definition: h264dec.c:56
const uint8_t * zigzag_scan8x8_q0
Definition: h264dec.h:418
uint8_t * edge_emu_buffer
Definition: h264dec.h:281
int bit_depth_luma
luma bit depth from sps to detect changes
Definition: h264dec.h:441
int chroma_format_idc
chroma format from sps to detect changes
Definition: h264dec.h:442
VideoDSPContext vdsp
Definition: h264dec.h:337
int intra16x16_pred_mode
Definition: h264dec.h:200
int mb_stride
Definition: h264dec.h:426
int postpone_filter
Definition: h264dec.h:369
AVCodecContext * avctx
Definition: h264dec.h:336
#define MB_TYPE_8x16
Definition: avcodec.h:1087
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
int last_qscale_diff
Definition: h264dec.h:187
int next_outputed_poc
Definition: h264dec.h:454
int explicit_ref_marking
Definition: h264dec.h:462
int recovery_frame
recovery_frame is the frame_num at which the next frame should be fully constructed.
Definition: h264dec.h:492
main external API structure.
Definition: avcodec.h:1409
int qp_thresh
QP threshold to skip loopfilter.
Definition: h264dec.h:186
int explicit_ref_marking
Definition: h264dec.h:321
static av_always_inline uint32_t pack16to32(int a, int b)
Definition: h264dec.h:638
int8_t * qscale_table
Definition: h264dec.h:132
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:622
Describe the class of an AVClass context structure.
Definition: log.h:34
const uint8_t * field_scan8x8_cavlc_q0
Definition: h264dec.h:422
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:291
int8_t * ref_index[2]
Definition: h264dec.h:144
int pixel_shift
0 for 8-bit H.264, 1 for high-bit-depth H.264
Definition: h264dec.h:352
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:149
H264Picture * cur_pic_ptr
Definition: h264dec.h:343
#define LIST_NOT_USED
Definition: h264dec.h:381
ptrdiff_t mb_uvlinesize
Definition: h264dec.h:225
refcounted data buffer API
#define FMO
Definition: h264dec.h:62
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:239
int enable_er
Definition: h264dec.h:520
ptrdiff_t mb_linesize
may be equal to s->linesize or s->linesize * 2, for mbaff
Definition: h264dec.h:224
ptrdiff_t uvlinesize
Definition: h264dec.h:223
H.264 / AVC / MPEG-4 prediction functions.
unsigned int list_count
Definition: h264dec.h:265
Definition: vp9.h:58
#define AV_ZERO128(d)
Definition: intreadwrite.h:553
int height
Definition: gxfenc.c:72
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:313
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
Definition: h264_mb.c:798
int mbaff
1 -> MBAFF frame 0-> not MBAFF
Definition: h264dec.h:156
A reference to a data buffer.
Definition: buffer.h:81
int nb_slice_ctx_queued
Definition: h264dec.h:348
AVBufferPool * qscale_table_pool
Definition: h264dec.h:524
AVBufferPool * motion_val_pool
Definition: h264dec.h:526
static av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:695
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num) ...
Definition: h264dec.h:151
int delta_poc_bottom
Definition: h264dec.h:325
#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:719
#define AV_COPY128(d, s)
Definition: intreadwrite.h:525
uint16_t * slice_table_base
Definition: h264dec.h:446
#define MB_TYPE_8x8
Definition: avcodec.h:1088
H264ParamSets ps
Definition: h264dec.h:444
void ff_h264_free_tables(H264Context *h)
Definition: h264dec.c:120
Bi-dir predicted.
Definition: avutil.h:262
uint8_t op
Definition: h264dec.h:270
int8_t * intra4x4_pred_mode
Definition: h264dec.h:203
int long_arg
index, pic_num, or num long refs depending on opcode
Definition: h264dec.h:124
#define MB_TYPE_16x8
Definition: avcodec.h:1086
Core video DSP helper functions.
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:297
Decoded Picture Buffer (DPB).
Definition: vaapi_h264.c:82
unsigned int pps_id
Definition: h264dec.h:275
#define IS_8X8(a)
Definition: mpegutils.h:91
H264Picture cur_pic
Definition: h264dec.h:344
int mb_width
Definition: h264dec.h:425
int current_slice
current slice number, used to initialize slice_num of each thread/context
Definition: h264dec.h:474
uint32_t * mb2b_xy
Definition: h264dec.h:390
const uint8_t * intra_pcm_ptr
Definition: h264dec.h:277
const uint8_t * field_scan_q0
Definition: h264dec.h:420
SPS * sps
Definition: h264_ps.h:140
H264DSPContext h264dsp
Definition: h264dec.h:338
unsigned int left_samples_available
Definition: h264dec.h:221
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:310
int slice_type_fixed
Definition: h264dec.h:182
#define av_always_inline
Definition: attributes.h:40
int slice_beta_offset
Definition: h264dec.h:192
int8_t * intra4x4_pred_mode
Definition: h264dec.h:376
int ff_h264_decode_init(AVCodecContext *avctx)
Definition: h264dec.c:365
#define AV_RN64A(p)
Definition: intreadwrite.h:461
void ff_h264_init_dequant_tables(H264Context *h)
int mb_field_decoding_flag
Definition: h264dec.h:238
uint8_t(* non_zero_count)[48]
Definition: h264dec.h:379
H.264 decoder/parser shared code.
uint8_t * bipred_scratchpad
Definition: h264dec.h:280
float min
int droppable
Definition: h264dec.h:358
int nal_ref_idc
Definition: h264dec.h:432
GetBitContext gb
Definition: h264dec.h:176
uint32_t val
Definition: h264dec.h:271
int cabac_init_idc
Definition: h264dec.h:317
int b_stride
Definition: h264dec.h:392
Context Adaptive Binary Arithmetic Coder.
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
Definition: h264dec.h:683
#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:465