1/*
2 * HEVC video decoder
3 *
4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23#ifndef AVCODEC_HEVC_H
24#define AVCODEC_HEVC_H
25
26#include "libavutil/buffer.h"
27#include "libavutil/md5.h"
28
29#include "avcodec.h"
30#include "bswapdsp.h"
31#include "cabac.h"
32#include "get_bits.h"
33#include "hevcpred.h"
34#include "hevcdsp.h"
35#include "internal.h"
36#include "thread.h"
37#include "videodsp.h"
38
39#define MAX_DPB_SIZE 16 // A.4.1
40#define MAX_REFS 16
41
42#define MAX_NB_THREADS 16
43#define SHIFT_CTB_WPP 2
44
45/**
46 * 7.4.2.1
47 */
48#define MAX_SUB_LAYERS 7
49#define MAX_VPS_COUNT 16
50#define MAX_SPS_COUNT 32
51#define MAX_PPS_COUNT 256
52#define MAX_SHORT_TERM_RPS_COUNT 64
53#define MAX_CU_SIZE 128
54
55//TODO: check if this is really the maximum
56#define MAX_TRANSFORM_DEPTH 5
57
58#define MAX_TB_SIZE 32
59#define MAX_PB_SIZE 64
60#define MAX_LOG2_CTB_SIZE 6
61#define MAX_QP 51
62#define DEFAULT_INTRA_TC_OFFSET 2
63
64#define HEVC_CONTEXTS 199
65
66#define MRG_MAX_NUM_CANDS     5
67
68#define L0 0
69#define L1 1
70
71#define EPEL_EXTRA_BEFORE 1
72#define EPEL_EXTRA_AFTER  2
73#define EPEL_EXTRA        3
74#define QPEL_EXTRA_BEFORE 3
75#define QPEL_EXTRA_AFTER  4
76#define QPEL_EXTRA        7
77
78#define EDGE_EMU_BUFFER_STRIDE 80
79
80/**
81 * Value of the luma sample at position (x, y) in the 2D array tab.
82 */
83#define SAMPLE(tab, x, y) ((tab)[(y) * s->sps->width + (x)])
84#define SAMPLE_CTB(tab, x, y) ((tab)[(y) * min_cb_width + (x)])
85#define SAMPLE_CBF(tab, x, y) ((tab)[((y) & ((1<<log2_trafo_size)-1)) * MAX_CU_SIZE + ((x) & ((1<<log2_trafo_size)-1))])
86#define SAMPLE_CBF2(tab, x, y) ((tab)[(y) * MAX_CU_SIZE +  (x)])
87
88#define IS_IDR(s) ((s)->nal_unit_type == NAL_IDR_W_RADL || (s)->nal_unit_type == NAL_IDR_N_LP)
89#define IS_BLA(s) ((s)->nal_unit_type == NAL_BLA_W_RADL || (s)->nal_unit_type == NAL_BLA_W_LP || \
90                   (s)->nal_unit_type == NAL_BLA_N_LP)
91#define IS_IRAP(s) ((s)->nal_unit_type >= 16 && (s)->nal_unit_type <= 23)
92
93/**
94 * Table 7-3: NAL unit type codes
95 */
96enum NALUnitType {
97    NAL_TRAIL_N    = 0,
98    NAL_TRAIL_R    = 1,
99    NAL_TSA_N      = 2,
100    NAL_TSA_R      = 3,
101    NAL_STSA_N     = 4,
102    NAL_STSA_R     = 5,
103    NAL_RADL_N     = 6,
104    NAL_RADL_R     = 7,
105    NAL_RASL_N     = 8,
106    NAL_RASL_R     = 9,
107    NAL_BLA_W_LP   = 16,
108    NAL_BLA_W_RADL = 17,
109    NAL_BLA_N_LP   = 18,
110    NAL_IDR_W_RADL = 19,
111    NAL_IDR_N_LP   = 20,
112    NAL_CRA_NUT    = 21,
113    NAL_VPS        = 32,
114    NAL_SPS        = 33,
115    NAL_PPS        = 34,
116    NAL_AUD        = 35,
117    NAL_EOS_NUT    = 36,
118    NAL_EOB_NUT    = 37,
119    NAL_FD_NUT     = 38,
120    NAL_SEI_PREFIX = 39,
121    NAL_SEI_SUFFIX = 40,
122};
123
124enum RPSType {
125    ST_CURR_BEF = 0,
126    ST_CURR_AFT,
127    ST_FOLL,
128    LT_CURR,
129    LT_FOLL,
130    NB_RPS_TYPE,
131};
132
133enum SliceType {
134    B_SLICE = 0,
135    P_SLICE = 1,
136    I_SLICE = 2,
137};
138
139enum SyntaxElement {
140    SAO_MERGE_FLAG = 0,
141    SAO_TYPE_IDX,
142    SAO_EO_CLASS,
143    SAO_BAND_POSITION,
144    SAO_OFFSET_ABS,
145    SAO_OFFSET_SIGN,
146    END_OF_SLICE_FLAG,
147    SPLIT_CODING_UNIT_FLAG,
148    CU_TRANSQUANT_BYPASS_FLAG,
149    SKIP_FLAG,
150    CU_QP_DELTA,
151    PRED_MODE_FLAG,
152    PART_MODE,
153    PCM_FLAG,
154    PREV_INTRA_LUMA_PRED_FLAG,
155    MPM_IDX,
156    REM_INTRA_LUMA_PRED_MODE,
157    INTRA_CHROMA_PRED_MODE,
158    MERGE_FLAG,
159    MERGE_IDX,
160    INTER_PRED_IDC,
161    REF_IDX_L0,
162    REF_IDX_L1,
163    ABS_MVD_GREATER0_FLAG,
164    ABS_MVD_GREATER1_FLAG,
165    ABS_MVD_MINUS2,
166    MVD_SIGN_FLAG,
167    MVP_LX_FLAG,
168    NO_RESIDUAL_DATA_FLAG,
169    SPLIT_TRANSFORM_FLAG,
170    CBF_LUMA,
171    CBF_CB_CR,
172    TRANSFORM_SKIP_FLAG,
173    EXPLICIT_RDPCM_FLAG,
174    EXPLICIT_RDPCM_DIR_FLAG,
175    LAST_SIGNIFICANT_COEFF_X_PREFIX,
176    LAST_SIGNIFICANT_COEFF_Y_PREFIX,
177    LAST_SIGNIFICANT_COEFF_X_SUFFIX,
178    LAST_SIGNIFICANT_COEFF_Y_SUFFIX,
179    SIGNIFICANT_COEFF_GROUP_FLAG,
180    SIGNIFICANT_COEFF_FLAG,
181    COEFF_ABS_LEVEL_GREATER1_FLAG,
182    COEFF_ABS_LEVEL_GREATER2_FLAG,
183    COEFF_ABS_LEVEL_REMAINING,
184    COEFF_SIGN_FLAG,
185    LOG2_RES_SCALE_ABS,
186    RES_SCALE_SIGN_FLAG,
187    CU_CHROMA_QP_OFFSET_FLAG,
188    CU_CHROMA_QP_OFFSET_IDX,
189};
190
191enum PartMode {
192    PART_2Nx2N = 0,
193    PART_2NxN  = 1,
194    PART_Nx2N  = 2,
195    PART_NxN   = 3,
196    PART_2NxnU = 4,
197    PART_2NxnD = 5,
198    PART_nLx2N = 6,
199    PART_nRx2N = 7,
200};
201
202enum PredMode {
203    MODE_INTER = 0,
204    MODE_INTRA,
205    MODE_SKIP,
206};
207
208enum InterPredIdc {
209    PRED_L0 = 0,
210    PRED_L1,
211    PRED_BI,
212};
213
214enum PredFlag {
215    PF_INTRA = 0,
216    PF_L0,
217    PF_L1,
218    PF_BI,
219};
220
221enum IntraPredMode {
222    INTRA_PLANAR = 0,
223    INTRA_DC,
224    INTRA_ANGULAR_2,
225    INTRA_ANGULAR_3,
226    INTRA_ANGULAR_4,
227    INTRA_ANGULAR_5,
228    INTRA_ANGULAR_6,
229    INTRA_ANGULAR_7,
230    INTRA_ANGULAR_8,
231    INTRA_ANGULAR_9,
232    INTRA_ANGULAR_10,
233    INTRA_ANGULAR_11,
234    INTRA_ANGULAR_12,
235    INTRA_ANGULAR_13,
236    INTRA_ANGULAR_14,
237    INTRA_ANGULAR_15,
238    INTRA_ANGULAR_16,
239    INTRA_ANGULAR_17,
240    INTRA_ANGULAR_18,
241    INTRA_ANGULAR_19,
242    INTRA_ANGULAR_20,
243    INTRA_ANGULAR_21,
244    INTRA_ANGULAR_22,
245    INTRA_ANGULAR_23,
246    INTRA_ANGULAR_24,
247    INTRA_ANGULAR_25,
248    INTRA_ANGULAR_26,
249    INTRA_ANGULAR_27,
250    INTRA_ANGULAR_28,
251    INTRA_ANGULAR_29,
252    INTRA_ANGULAR_30,
253    INTRA_ANGULAR_31,
254    INTRA_ANGULAR_32,
255    INTRA_ANGULAR_33,
256    INTRA_ANGULAR_34,
257};
258
259enum SAOType {
260    SAO_NOT_APPLIED = 0,
261    SAO_BAND,
262    SAO_EDGE,
263};
264
265enum SAOEOClass {
266    SAO_EO_HORIZ = 0,
267    SAO_EO_VERT,
268    SAO_EO_135D,
269    SAO_EO_45D,
270};
271
272enum ScanType {
273    SCAN_DIAG = 0,
274    SCAN_HORIZ,
275    SCAN_VERT,
276};
277
278typedef struct ShortTermRPS {
279    unsigned int num_negative_pics;
280    int num_delta_pocs;
281    int32_t delta_poc[32];
282    uint8_t used[32];
283} ShortTermRPS;
284
285typedef struct LongTermRPS {
286    int     poc[32];
287    uint8_t used[32];
288    uint8_t nb_refs;
289} LongTermRPS;
290
291typedef struct RefPicList {
292    struct HEVCFrame *ref[MAX_REFS];
293    int list[MAX_REFS];
294    int isLongTerm[MAX_REFS];
295    int nb_refs;
296} RefPicList;
297
298typedef struct RefPicListTab {
299    RefPicList refPicList[2];
300} RefPicListTab;
301
302typedef struct HEVCWindow {
303    int left_offset;
304    int right_offset;
305    int top_offset;
306    int bottom_offset;
307} HEVCWindow;
308
309typedef struct VUI {
310    AVRational sar;
311
312    int overscan_info_present_flag;
313    int overscan_appropriate_flag;
314
315    int video_signal_type_present_flag;
316    int video_format;
317    int video_full_range_flag;
318    int colour_description_present_flag;
319    uint8_t colour_primaries;
320    uint8_t transfer_characteristic;
321    uint8_t matrix_coeffs;
322
323    int chroma_loc_info_present_flag;
324    int chroma_sample_loc_type_top_field;
325    int chroma_sample_loc_type_bottom_field;
326    int neutra_chroma_indication_flag;
327
328    int field_seq_flag;
329    int frame_field_info_present_flag;
330
331    int default_display_window_flag;
332    HEVCWindow def_disp_win;
333
334    int vui_timing_info_present_flag;
335    uint32_t vui_num_units_in_tick;
336    uint32_t vui_time_scale;
337    int vui_poc_proportional_to_timing_flag;
338    int vui_num_ticks_poc_diff_one_minus1;
339    int vui_hrd_parameters_present_flag;
340
341    int bitstream_restriction_flag;
342    int tiles_fixed_structure_flag;
343    int motion_vectors_over_pic_boundaries_flag;
344    int restricted_ref_pic_lists_flag;
345    int min_spatial_segmentation_idc;
346    int max_bytes_per_pic_denom;
347    int max_bits_per_min_cu_denom;
348    int log2_max_mv_length_horizontal;
349    int log2_max_mv_length_vertical;
350} VUI;
351
352typedef struct PTLCommon {
353    uint8_t profile_space;
354    uint8_t tier_flag;
355    uint8_t profile_idc;
356    uint8_t profile_compatibility_flag[32];
357    uint8_t level_idc;
358    uint8_t progressive_source_flag;
359    uint8_t interlaced_source_flag;
360    uint8_t non_packed_constraint_flag;
361    uint8_t frame_only_constraint_flag;
362} PTLCommon;
363
364typedef struct PTL {
365    PTLCommon general_ptl;
366    PTLCommon sub_layer_ptl[MAX_SUB_LAYERS];
367
368    uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS];
369    uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS];
370} PTL;
371
372typedef struct HEVCVPS {
373    uint8_t vps_temporal_id_nesting_flag;
374    int vps_max_layers;
375    int vps_max_sub_layers; ///< vps_max_temporal_layers_minus1 + 1
376
377    PTL ptl;
378    int vps_sub_layer_ordering_info_present_flag;
379    unsigned int vps_max_dec_pic_buffering[MAX_SUB_LAYERS];
380    unsigned int vps_num_reorder_pics[MAX_SUB_LAYERS];
381    unsigned int vps_max_latency_increase[MAX_SUB_LAYERS];
382    int vps_max_layer_id;
383    int vps_num_layer_sets; ///< vps_num_layer_sets_minus1 + 1
384    uint8_t vps_timing_info_present_flag;
385    uint32_t vps_num_units_in_tick;
386    uint32_t vps_time_scale;
387    uint8_t vps_poc_proportional_to_timing_flag;
388    int vps_num_ticks_poc_diff_one; ///< vps_num_ticks_poc_diff_one_minus1 + 1
389    int vps_num_hrd_parameters;
390} HEVCVPS;
391
392typedef struct ScalingList {
393    /* This is a little wasteful, since sizeID 0 only needs 8 coeffs,
394     * and size ID 3 only has 2 arrays, not 6. */
395    uint8_t sl[4][6][64];
396    uint8_t sl_dc[2][6];
397} ScalingList;
398
399typedef struct HEVCSPS {
400    unsigned vps_id;
401    int chroma_format_idc;
402    uint8_t separate_colour_plane_flag;
403
404    ///< output (i.e. cropped) values
405    int output_width, output_height;
406    HEVCWindow output_window;
407
408    HEVCWindow pic_conf_win;
409
410    int bit_depth;
411    int pixel_shift;
412    enum AVPixelFormat pix_fmt;
413
414    unsigned int log2_max_poc_lsb;
415    int pcm_enabled_flag;
416
417    int max_sub_layers;
418    struct {
419        int max_dec_pic_buffering;
420        int num_reorder_pics;
421        int max_latency_increase;
422    } temporal_layer[MAX_SUB_LAYERS];
423
424    VUI vui;
425    PTL ptl;
426
427    uint8_t scaling_list_enable_flag;
428    ScalingList scaling_list;
429
430    unsigned int nb_st_rps;
431    ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT];
432
433    uint8_t amp_enabled_flag;
434    uint8_t sao_enabled;
435
436    uint8_t long_term_ref_pics_present_flag;
437    uint16_t lt_ref_pic_poc_lsb_sps[32];
438    uint8_t used_by_curr_pic_lt_sps_flag[32];
439    uint8_t num_long_term_ref_pics_sps;
440
441    struct {
442        uint8_t bit_depth;
443        uint8_t bit_depth_chroma;
444        unsigned int log2_min_pcm_cb_size;
445        unsigned int log2_max_pcm_cb_size;
446        uint8_t loop_filter_disable_flag;
447    } pcm;
448    uint8_t sps_temporal_mvp_enabled_flag;
449    uint8_t sps_strong_intra_smoothing_enable_flag;
450
451    unsigned int log2_min_cb_size;
452    unsigned int log2_diff_max_min_coding_block_size;
453    unsigned int log2_min_tb_size;
454    unsigned int log2_max_trafo_size;
455    unsigned int log2_ctb_size;
456    unsigned int log2_min_pu_size;
457
458    int max_transform_hierarchy_depth_inter;
459    int max_transform_hierarchy_depth_intra;
460
461    int transform_skip_rotation_enabled_flag;
462    int transform_skip_context_enabled_flag;
463    int implicit_rdpcm_enabled_flag;
464    int explicit_rdpcm_enabled_flag;
465    int intra_smoothing_disabled_flag;
466    int persistent_rice_adaptation_enabled_flag;
467
468    ///< coded frame dimension in various units
469    int width;
470    int height;
471    int ctb_width;
472    int ctb_height;
473    int ctb_size;
474    int min_cb_width;
475    int min_cb_height;
476    int min_tb_width;
477    int min_tb_height;
478    int min_pu_width;
479    int min_pu_height;
480    int tb_mask;
481
482    int hshift[3];
483    int vshift[3];
484
485    int qp_bd_offset;
486} HEVCSPS;
487
488typedef struct HEVCPPS {
489    unsigned int sps_id; ///< seq_parameter_set_id
490
491    uint8_t sign_data_hiding_flag;
492
493    uint8_t cabac_init_present_flag;
494
495    int num_ref_idx_l0_default_active; ///< num_ref_idx_l0_default_active_minus1 + 1
496    int num_ref_idx_l1_default_active; ///< num_ref_idx_l1_default_active_minus1 + 1
497    int pic_init_qp_minus26;
498
499    uint8_t constrained_intra_pred_flag;
500    uint8_t transform_skip_enabled_flag;
501
502    uint8_t cu_qp_delta_enabled_flag;
503    int diff_cu_qp_delta_depth;
504
505    int cb_qp_offset;
506    int cr_qp_offset;
507    uint8_t pic_slice_level_chroma_qp_offsets_present_flag;
508    uint8_t weighted_pred_flag;
509    uint8_t weighted_bipred_flag;
510    uint8_t output_flag_present_flag;
511    uint8_t transquant_bypass_enable_flag;
512
513    uint8_t dependent_slice_segments_enabled_flag;
514    uint8_t tiles_enabled_flag;
515    uint8_t entropy_coding_sync_enabled_flag;
516
517    int num_tile_columns;   ///< num_tile_columns_minus1 + 1
518    int num_tile_rows;      ///< num_tile_rows_minus1 + 1
519    uint8_t uniform_spacing_flag;
520    uint8_t loop_filter_across_tiles_enabled_flag;
521
522    uint8_t seq_loop_filter_across_slices_enabled_flag;
523
524    uint8_t deblocking_filter_control_present_flag;
525    uint8_t deblocking_filter_override_enabled_flag;
526    uint8_t disable_dbf;
527    int beta_offset;    ///< beta_offset_div2 * 2
528    int tc_offset;      ///< tc_offset_div2 * 2
529
530    uint8_t scaling_list_data_present_flag;
531    ScalingList scaling_list;
532
533    uint8_t lists_modification_present_flag;
534    int log2_parallel_merge_level; ///< log2_parallel_merge_level_minus2 + 2
535    int num_extra_slice_header_bits;
536    uint8_t slice_header_extension_present_flag;
537    uint8_t log2_max_transform_skip_block_size;
538    uint8_t cross_component_prediction_enabled_flag;
539    uint8_t chroma_qp_offset_list_enabled_flag;
540    uint8_t diff_cu_chroma_qp_offset_depth;
541    uint8_t chroma_qp_offset_list_len_minus1;
542    int8_t  cb_qp_offset_list[5];
543    int8_t  cr_qp_offset_list[5];
544    uint8_t log2_sao_offset_scale_luma;
545    uint8_t log2_sao_offset_scale_chroma;
546
547    // Inferred parameters
548    unsigned int *column_width;  ///< ColumnWidth
549    unsigned int *row_height;    ///< RowHeight
550    unsigned int *col_bd;        ///< ColBd
551    unsigned int *row_bd;        ///< RowBd
552    int *col_idxX;
553
554    int *ctb_addr_rs_to_ts; ///< CtbAddrRSToTS
555    int *ctb_addr_ts_to_rs; ///< CtbAddrTSToRS
556    int *tile_id;           ///< TileId
557    int *tile_pos_rs;       ///< TilePosRS
558    int *min_tb_addr_zs;    ///< MinTbAddrZS
559    int *min_tb_addr_zs_tab;///< MinTbAddrZS
560} HEVCPPS;
561
562typedef struct SliceHeader {
563    unsigned int pps_id;
564
565    ///< address (in raster order) of the first block in the current slice segment
566    unsigned int   slice_segment_addr;
567    ///< address (in raster order) of the first block in the current slice
568    unsigned int   slice_addr;
569
570    enum SliceType slice_type;
571
572    int pic_order_cnt_lsb;
573
574    uint8_t first_slice_in_pic_flag;
575    uint8_t dependent_slice_segment_flag;
576    uint8_t pic_output_flag;
577    uint8_t colour_plane_id;
578
579    ///< RPS coded in the slice header itself is stored here
580    ShortTermRPS slice_rps;
581    const ShortTermRPS *short_term_rps;
582    LongTermRPS long_term_rps;
583    unsigned int list_entry_lx[2][32];
584
585    uint8_t rpl_modification_flag[2];
586    uint8_t no_output_of_prior_pics_flag;
587    uint8_t slice_temporal_mvp_enabled_flag;
588
589    unsigned int nb_refs[2];
590
591    uint8_t slice_sample_adaptive_offset_flag[3];
592    uint8_t mvd_l1_zero_flag;
593
594    uint8_t cabac_init_flag;
595    uint8_t disable_deblocking_filter_flag; ///< slice_header_disable_deblocking_filter_flag
596    uint8_t slice_loop_filter_across_slices_enabled_flag;
597    uint8_t collocated_list;
598
599    unsigned int collocated_ref_idx;
600
601    int slice_qp_delta;
602    int slice_cb_qp_offset;
603    int slice_cr_qp_offset;
604
605    uint8_t cu_chroma_qp_offset_enabled_flag;
606
607    int beta_offset;    ///< beta_offset_div2 * 2
608    int tc_offset;      ///< tc_offset_div2 * 2
609
610    unsigned int max_num_merge_cand; ///< 5 - 5_minus_max_num_merge_cand
611
612    int *entry_point_offset;
613    int * offset;
614    int * size;
615    int num_entry_point_offsets;
616
617    int8_t slice_qp;
618
619    uint8_t luma_log2_weight_denom;
620    int16_t chroma_log2_weight_denom;
621
622    int16_t luma_weight_l0[16];
623    int16_t chroma_weight_l0[16][2];
624    int16_t chroma_weight_l1[16][2];
625    int16_t luma_weight_l1[16];
626
627    int16_t luma_offset_l0[16];
628    int16_t chroma_offset_l0[16][2];
629
630    int16_t luma_offset_l1[16];
631    int16_t chroma_offset_l1[16][2];
632
633    int slice_ctb_addr_rs;
634} SliceHeader;
635
636typedef struct CodingTree {
637    int depth; ///< ctDepth
638} CodingTree;
639
640typedef struct CodingUnit {
641    int x;
642    int y;
643
644    enum PredMode pred_mode;    ///< PredMode
645    enum PartMode part_mode;    ///< PartMode
646
647    uint8_t rqt_root_cbf;
648
649    uint8_t pcm_flag;
650
651    // Inferred parameters
652    uint8_t intra_split_flag;   ///< IntraSplitFlag
653    uint8_t max_trafo_depth;    ///< MaxTrafoDepth
654    uint8_t cu_transquant_bypass_flag;
655} CodingUnit;
656
657typedef struct Mv {
658    int16_t x;  ///< horizontal component of motion vector
659    int16_t y;  ///< vertical component of motion vector
660} Mv;
661
662typedef struct MvField {
663    Mv mv[2];
664    int8_t ref_idx[2];
665    int8_t pred_flag;
666} MvField;
667
668typedef struct NeighbourAvailable {
669    int cand_bottom_left;
670    int cand_left;
671    int cand_up;
672    int cand_up_left;
673    int cand_up_right;
674    int cand_up_right_sap;
675} NeighbourAvailable;
676
677typedef struct PredictionUnit {
678    int mpm_idx;
679    int rem_intra_luma_pred_mode;
680    uint8_t intra_pred_mode[4];
681    Mv mvd;
682    uint8_t merge_flag;
683    uint8_t intra_pred_mode_c[4];
684    uint8_t chroma_mode_c[4];
685} PredictionUnit;
686
687typedef struct TransformTree {
688    uint8_t cbf_cb[MAX_TRANSFORM_DEPTH][MAX_CU_SIZE * MAX_CU_SIZE];
689    uint8_t cbf_cr[MAX_TRANSFORM_DEPTH][MAX_CU_SIZE * MAX_CU_SIZE];
690    uint8_t cbf_luma;
691
692    // Inferred parameters
693    uint8_t inter_split_flag;
694} TransformTree;
695
696typedef struct TransformUnit {
697    DECLARE_ALIGNED(32, int16_t, coeffs[2][MAX_TB_SIZE * MAX_TB_SIZE]);
698    int cu_qp_delta;
699
700    int res_scale_val;
701
702    // Inferred parameters;
703    int intra_pred_mode;
704    int intra_pred_mode_c;
705    int chroma_mode_c;
706    uint8_t is_cu_qp_delta_coded;
707    uint8_t is_cu_chroma_qp_offset_coded;
708    int8_t  cu_qp_offset_cb;
709    int8_t  cu_qp_offset_cr;
710    uint8_t cross_pf;
711} TransformUnit;
712
713typedef struct DBParams {
714    int beta_offset;
715    int tc_offset;
716} DBParams;
717
718#define HEVC_FRAME_FLAG_OUTPUT    (1 << 0)
719#define HEVC_FRAME_FLAG_SHORT_REF (1 << 1)
720#define HEVC_FRAME_FLAG_LONG_REF  (1 << 2)
721
722typedef struct HEVCFrame {
723    AVFrame *frame;
724    ThreadFrame tf;
725    MvField *tab_mvf;
726    RefPicList *refPicList;
727    RefPicListTab **rpl_tab;
728    int ctb_count;
729    int poc;
730    struct HEVCFrame *collocated_ref;
731
732    HEVCWindow window;
733
734    AVBufferRef *tab_mvf_buf;
735    AVBufferRef *rpl_tab_buf;
736    AVBufferRef *rpl_buf;
737
738    /**
739     * A sequence counter, so that old frames are output first
740     * after a POC reset
741     */
742    uint16_t sequence;
743
744    /**
745     * A combination of HEVC_FRAME_FLAG_*
746     */
747    uint8_t flags;
748} HEVCFrame;
749
750typedef struct HEVCNAL {
751    uint8_t *rbsp_buffer;
752    int rbsp_buffer_size;
753
754    int size;
755    const uint8_t *data;
756} HEVCNAL;
757
758typedef struct HEVCLocalContext {
759    DECLARE_ALIGNED(16, int16_t, mc_buffer[(MAX_PB_SIZE + 7) * MAX_PB_SIZE]);
760    uint8_t cabac_state[HEVC_CONTEXTS];
761
762    uint8_t stat_coeff[4];
763
764    uint8_t first_qp_group;
765
766    GetBitContext gb;
767    CABACContext cc;
768    TransformTree tt;
769
770    int8_t qp_y;
771    int8_t curr_qp_y;
772
773    int qPy_pred;
774
775    TransformUnit tu;
776
777    uint8_t ctb_left_flag;
778    uint8_t ctb_up_flag;
779    uint8_t ctb_up_right_flag;
780    uint8_t ctb_up_left_flag;
781    int     end_of_tiles_x;
782    int     end_of_tiles_y;
783    /* +7 is for subpixel interpolation, *2 for high bit depths */
784    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2];
785    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer2)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2];
786
787    CodingTree ct;
788    CodingUnit cu;
789    PredictionUnit pu;
790    NeighbourAvailable na;
791
792    uint8_t slice_or_tiles_left_boundary;
793    uint8_t slice_or_tiles_up_boundary;
794} HEVCLocalContext;
795
796typedef struct HEVCContext {
797    const AVClass *c;  // needed by private avoptions
798    AVCodecContext *avctx;
799
800    struct HEVCContext  *sList[MAX_NB_THREADS];
801
802    HEVCLocalContext    *HEVClcList[MAX_NB_THREADS];
803    HEVCLocalContext    *HEVClc;
804
805    uint8_t             threads_type;
806    uint8_t             threads_number;
807
808    int                 width;
809    int                 height;
810
811    uint8_t *cabac_state;
812
813    /** 1 if the independent slice segment header was successfully parsed */
814    uint8_t slice_initialized;
815
816    AVFrame *frame;
817    AVFrame *sao_frame;
818    AVFrame *tmp_frame;
819    AVFrame *output_frame;
820
821    const HEVCVPS *vps;
822    const HEVCSPS *sps;
823    const HEVCPPS *pps;
824    AVBufferRef *vps_list[MAX_VPS_COUNT];
825    AVBufferRef *sps_list[MAX_SPS_COUNT];
826    AVBufferRef *pps_list[MAX_PPS_COUNT];
827
828    AVBufferRef *current_sps;
829
830    AVBufferPool *tab_mvf_pool;
831    AVBufferPool *rpl_tab_pool;
832
833    ///< candidate references for the current frame
834    RefPicList rps[5];
835
836    SliceHeader sh;
837    SAOParams *sao;
838    DBParams *deblock;
839    enum NALUnitType nal_unit_type;
840    int temporal_id;  ///< temporal_id_plus1 - 1
841    HEVCFrame *ref;
842    HEVCFrame DPB[32];
843    int poc;
844    int pocTid0;
845    int slice_idx; ///< number of the slice being currently decoded
846    int eos;       ///< current packet contains an EOS/EOB NAL
847    int last_eos;  ///< last packet contains an EOS/EOB NAL
848    int max_ra;
849    int bs_width;
850    int bs_height;
851
852    int is_decoded;
853
854    HEVCPredContext hpc;
855    HEVCDSPContext hevcdsp;
856    VideoDSPContext vdsp;
857    BswapDSPContext bdsp;
858    int8_t *qp_y_tab;
859    uint8_t *horizontal_bs;
860    uint8_t *vertical_bs;
861
862    int32_t *tab_slice_address;
863
864    //  CU
865    uint8_t *skip_flag;
866    uint8_t *tab_ct_depth;
867    // PU
868    uint8_t *tab_ipm;
869
870    uint8_t *cbf_luma; // cbf_luma of colocated TU
871    uint8_t *is_pcm;
872
873    // CTB-level flags affecting loop filter operation
874    uint8_t *filter_slice_edges;
875
876    /** used on BE to byteswap the lines for checksumming */
877    uint8_t *checksum_buf;
878    int      checksum_buf_size;
879
880    /**
881     * Sequence counters for decoded and output frames, so that old
882     * frames are output first after a POC reset
883     */
884    uint16_t seq_decode;
885    uint16_t seq_output;
886
887    int enable_parallel_tiles;
888    int wpp_err;
889    int skipped_bytes;
890    int *skipped_bytes_pos;
891    int skipped_bytes_pos_size;
892
893    int *skipped_bytes_nal;
894    int **skipped_bytes_pos_nal;
895    int *skipped_bytes_pos_size_nal;
896
897    const uint8_t *data;
898
899    HEVCNAL *nals;
900    int nb_nals;
901    int nals_allocated;
902    // type of the first VCL NAL of the current frame
903    enum NALUnitType first_nal_type;
904
905    // for checking the frame checksums
906    struct AVMD5 *md5_ctx;
907    uint8_t       md5[3][16];
908    uint8_t is_md5;
909
910    uint8_t context_initialized;
911    uint8_t is_nalff;       ///< this flag is != 0 if bitstream is encapsulated
912                            ///< as a format defined in 14496-15
913    int apply_defdispwin;
914
915    int active_seq_parameter_set_id;
916
917    int nal_length_size;    ///< Number of bytes used for nal length (1, 2 or 4)
918    int nuh_layer_id;
919
920    /** frame packing arrangement variables */
921    int sei_frame_packing_present;
922    int frame_packing_arrangement_type;
923    int content_interpretation_type;
924    int quincunx_subsampling;
925
926    /** display orientation */
927    int sei_display_orientation_present;
928    int sei_anticlockwise_rotation;
929    int sei_hflip, sei_vflip;
930
931    int picture_struct;
932} HEVCContext;
933
934int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps,
935                                  const HEVCSPS *sps, int is_slice_header);
936int ff_hevc_decode_nal_vps(HEVCContext *s);
937int ff_hevc_decode_nal_sps(HEVCContext *s);
938int ff_hevc_decode_nal_pps(HEVCContext *s);
939int ff_hevc_decode_nal_sei(HEVCContext *s);
940
941int ff_hevc_extract_rbsp(HEVCContext *s, const uint8_t *src, int length,
942                         HEVCNAL *nal);
943
944/**
945 * Mark all frames in DPB as unused for reference.
946 */
947void ff_hevc_clear_refs(HEVCContext *s);
948
949/**
950 * Drop all frames currently in DPB.
951 */
952void ff_hevc_flush_dpb(HEVCContext *s);
953
954/**
955 * Compute POC of the current frame and return it.
956 */
957int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb);
958
959RefPicList *ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *frame,
960                                 int x0, int y0);
961
962/**
963 * Construct the reference picture sets for the current frame.
964 */
965int ff_hevc_frame_rps(HEVCContext *s);
966
967/**
968 * Construct the reference picture list(s) for the current slice.
969 */
970int ff_hevc_slice_rpl(HEVCContext *s);
971
972void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts);
973void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts);
974int ff_hevc_sao_merge_flag_decode(HEVCContext *s);
975int ff_hevc_sao_type_idx_decode(HEVCContext *s);
976int ff_hevc_sao_band_position_decode(HEVCContext *s);
977int ff_hevc_sao_offset_abs_decode(HEVCContext *s);
978int ff_hevc_sao_offset_sign_decode(HEVCContext *s);
979int ff_hevc_sao_eo_class_decode(HEVCContext *s);
980int ff_hevc_end_of_slice_flag_decode(HEVCContext *s);
981int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s);
982int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0,
983                             int x_cb, int y_cb);
984int ff_hevc_pred_mode_decode(HEVCContext *s);
985int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth,
986                                          int x0, int y0);
987int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size);
988int ff_hevc_pcm_flag_decode(HEVCContext *s);
989int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s);
990int ff_hevc_mpm_idx_decode(HEVCContext *s);
991int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s);
992int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s);
993int ff_hevc_merge_idx_decode(HEVCContext *s);
994int ff_hevc_merge_flag_decode(HEVCContext *s);
995int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH);
996int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx);
997int ff_hevc_mvp_lx_flag_decode(HEVCContext *s);
998int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s);
999int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size);
1000int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth);
1001int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth);
1002int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx);
1003int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx);
1004
1005/**
1006 * Get the number of candidate references for the current frame.
1007 */
1008int ff_hevc_frame_nb_refs(HEVCContext *s);
1009
1010int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc);
1011
1012/**
1013 * Find next frame in output order and put a reference to it in frame.
1014 * @return 1 if a frame was output, 0 otherwise
1015 */
1016int ff_hevc_output_frame(HEVCContext *s, AVFrame *frame, int flush);
1017
1018void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags);
1019
1020void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0,
1021                                     int nPbW, int nPbH);
1022void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0,
1023                                int nPbW, int nPbH, int log2_cb_size,
1024                                int part_idx, int merge_idx, MvField *mv);
1025void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0,
1026                              int nPbW, int nPbH, int log2_cb_size,
1027                              int part_idx, int merge_idx,
1028                              MvField *mv, int mvp_lx_flag, int LX);
1029void ff_hevc_set_qPy(HEVCContext *s, int xC, int yC, int xBase, int yBase,
1030                     int log2_cb_size);
1031void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0,
1032                                           int log2_trafo_size);
1033int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s);
1034int ff_hevc_cu_qp_delta_abs(HEVCContext *s);
1035int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s);
1036int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s);
1037void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size);
1038void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size);
1039void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
1040                                 int log2_trafo_size, enum ScanType scan_idx,
1041                                 int c_idx);
1042
1043void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size);
1044
1045
1046extern const uint8_t ff_hevc_qpel_extra_before[4];
1047extern const uint8_t ff_hevc_qpel_extra_after[4];
1048extern const uint8_t ff_hevc_qpel_extra[4];
1049
1050extern const uint8_t ff_hevc_diag_scan4x4_x[16];
1051extern const uint8_t ff_hevc_diag_scan4x4_y[16];
1052extern const uint8_t ff_hevc_diag_scan8x8_x[64];
1053extern const uint8_t ff_hevc_diag_scan8x8_y[64];
1054
1055#endif /* AVCODEC_HEVC_H */
1056