Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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