FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/h264dec.h
Date: 2022-01-27 16:04:32
Exec Total Coverage
Lines: 79 79 100.0%
Branches: 16 16 100.0%

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