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