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