1 /****************************************************************************** 2 * 3 * Copyright (C) 2015 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ***************************************************************************** 18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore 19 */ 20 /*! 21 *************************************************************************** 22 * \file ih264d_cabac.h 23 * 24 * \brief 25 * This file contains declarations of Binary decoding routines and tables. 26 * 27 * \date 28 * 04/02/2003 29 * 30 * \author NS 31 *************************************************************************** 32 */ 33 34 #ifndef _IH264D_CABAC_H_ 35 #define _IH264D_CABAC_H_ 36 37 #include "ih264_typedefs.h" 38 #include "ih264_macros.h" 39 #include "ih264_platform_macros.h" 40 #include "ih264d_bitstrm.h" 41 #include "ih264d_defs.h" 42 43 #define B_BITS 10 44 45 #define HALF (1 << (B_BITS-1)) 46 #define QUARTER (1 << (B_BITS-2)) 47 48 #define CTXT_UNUSED {0,64} 49 #define NUM_MB_SKIP_CTXT 6 50 #define NUM_MB_TYPE_CTXT 9 51 #define NUM_SUBMB_TYPE_CTXT 7 52 #define NUM_REF_IDX_CTXT 6 53 #define NUM_MB_QP_DELTA 4 54 #define NUM_PRED_MODE 6 55 #define NUM_MB_FIELD 3 56 #define NUM_CBP 12 57 #define NUM_CTX_MVD 14 58 59 /* Residual block cabac context parameters */ 60 #define NUM_CTX_CAT 6 61 #define NUM_LUMA_CTX_CAT 3 62 #define NUM_CTX_CODED_BLOCK 4 63 /* Luma CtxSigCoeff + CtxLastCoeff = 15 + 15 = 30 */ 64 #define NUM_LUMA_CTX_SIG_COEF 30 65 /* Chroma DC CtxSigCoeff + CtxLastCoeff = 3 + 3 = 6 */ 66 #define NUM_CTX_CHROMA_DC_SIG_COEF 6 67 /* Chroma AC CtxSigCoeff + CtxLastCoeff = 14 + 14 = 28 */ 68 #define NUM_CTX_CHROMA_AC_SIG_COEF 28 69 #define NUM_CTX_ABS_LEVEL 10 70 71 #define LUMA_DC_CTXCAT 0 72 #define LUMA_AC_CTXCAT 1 73 #define LUMA_4X4_CTXCAT 2 74 #define CHROMA_DC_CTXCAT 3 75 #define CHROMA_AC_CTXCAT 4 76 #define LUMA_8X8_CTXCAT 5 77 78 /*****************************************************************************/ 79 /* Constant Macros */ 80 /*****************************************************************************/ 81 #define NUM_CABAC_CTXTS 460 82 #define QP_RANGE 52 83 #define NUM_CAB_INIT_IDC_PLUS_ONE 4 84 #define LAST_COEFF_CTXT_MINUS_SIG_COEFF_CTXT 61 85 #define LAST_COEFF_CTXT_MINUS_SIG_COEFF_CTXT_8X8 15 86 87 /*bits 0 to 5 :state 88 bit 6:mps*/ 89 typedef struct 90 { 91 UWORD8 u1_mps_state; /* state number */ 92 } bin_ctxt_model_t; 93 94 typedef struct 95 96 { 97 /* Neighbour availability Variables needed to get CtxtInc, for CABAC */ 98 UWORD8 u1_mb_type; /** macroblock type: I/P/B/SI/SP */ 99 UWORD8 u1_cbp; /** Coded Block Pattern */ 100 UWORD8 u1_intra_chroma_pred_mode; 101 102 /*************************************************************************/ 103 /* Arrangnment of DC CSBP */ 104 /* bits: b7 b6 b5 b4 b3 b2 b1 b0 */ 105 /* CSBP: x x x x x Vdc Udc Ydc */ 106 /*************************************************************************/ 107 UWORD8 u1_yuv_dc_csbp; 108 WORD8 i1_ref_idx[4]; 109 UWORD8 u1_mv[4][4]; 110 UWORD8 u1_transform8x8_ctxt; 111 } ctxt_inc_mb_info_t; 112 113 #define ONE_RIGHT_SHIFTED_BY_8 1<<8 114 #define ONE_RIGHT_SHIFTED_BY_9 1<<9 115 #define ONE_RIGHT_SHIFTED_BY_14 1<<14 116 typedef struct 117 { 118 UWORD32 u4_code_int_range; 119 UWORD32 u4_code_int_val_ofst; 120 const void *cabac_table; 121 void * pv_codec_handle; /* For Error Handling */ 122 } decoding_envirnoment_t; 123 124 WORD32 ih264d_init_cabac_dec_envirnoment(decoding_envirnoment_t * ps_cab_env, 125 dec_bit_stream_t *ps_bitstrm); 126 127 UWORD32 ih264d_decode_bin(UWORD32 u4_ctx_inc, 128 bin_ctxt_model_t *ps_bin_ctxt, 129 dec_bit_stream_t *ps_bitstrm, 130 decoding_envirnoment_t *ps_cab_env); 131 UWORD8 ih264d_decode_terminate(decoding_envirnoment_t * ps_cab_env, 132 dec_bit_stream_t * ps_bitstrm); 133 134 UWORD32 ih264d_decode_bins_tunary(UWORD8 u1_max_bins, 135 UWORD32 u4_ctx_inc, 136 bin_ctxt_model_t *ps_src_bin_ctxt, 137 dec_bit_stream_t *ps_bitstrm, 138 decoding_envirnoment_t *ps_cab_env); 139 140 UWORD32 ih264d_decode_bins(UWORD8 u1_max_bins, 141 UWORD32 u4_ctx_inc, 142 bin_ctxt_model_t *ps_src_bin_ctxt, 143 dec_bit_stream_t *ps_bitstrm, 144 decoding_envirnoment_t *ps_cab_env); 145 UWORD32 ih264d_decode_bins_unary(UWORD8 u1_max_bins, 146 UWORD32 u4_ctx_inc, 147 bin_ctxt_model_t *ps_src_bin_ctxt, 148 dec_bit_stream_t *ps_bitstrm, 149 decoding_envirnoment_t *ps_cab_env); 150 151 UWORD32 ih264d_decode_bypass_bins_unary(decoding_envirnoment_t *ps_cab_env, 152 dec_bit_stream_t *ps_bitstrm); 153 154 UWORD32 ih264d_decode_bypass_bins(decoding_envirnoment_t *ps_cab_env, 155 UWORD8 u1_max_bins, 156 dec_bit_stream_t *ps_bitstrm); 157 158 /*****************************************************************************/ 159 /* Function Macros */ 160 /*****************************************************************************/ 161 162 /*****************************************************************************/ 163 /* Defining a macro for renormalization*/ 164 /*****************************************************************************/ 165 166 /*we renormalize every time the number bits(which are read ahead of time) we have 167 consumed in the u4_ofst exceeds 23*/ 168 169 #define RENORM_RANGE_OFFSET(u4_codeIntRange_m,u4_codeIntValOffset_m,u4_offset_m,pu4_buffer_m) \ 170 { \ 171 UWORD32 read_bits_m,u4_clz_m ; \ 172 u4_clz_m = CLZ(u4_codeIntRange_m); \ 173 NEXTBITS(read_bits_m,(u4_offset_m+23),pu4_buffer_m,u4_clz_m) \ 174 FLUSHBITS(u4_offset_m,(u4_clz_m)) \ 175 u4_codeIntRange_m = u4_codeIntRange_m << u4_clz_m; \ 176 u4_codeIntValOffset_m = (u4_codeIntValOffset_m << u4_clz_m) | read_bits_m; \ 177 } 178 179 /*****************************************************************************/ 180 /* Defining a macro for checking if the symbol is MPS*/ 181 /*****************************************************************************/ 182 183 #define CHECK_IF_LPS(u4_codeIntRange_m,u4_codeIntValOffset_m,u4_symbol_m, \ 184 u4_codeIntRangeLPS_m,u1_mps_state_m,table_lookup_m) \ 185 { \ 186 if(u4_codeIntValOffset_m >= u4_codeIntRange_m) \ 187 { \ 188 u4_symbol_m = 1 - u4_symbol_m; \ 189 u4_codeIntValOffset_m -= u4_codeIntRange_m; \ 190 u4_codeIntRange_m = u4_codeIntRangeLPS_m; \ 191 u1_mps_state_m = (table_lookup_m >> 15) & 0x7F; \ 192 } \ 193 } 194 195 /*! 196 ************************************************************************** 197 * \if Function name : DECODE_ONE_BIN_MACRO \endif 198 * 199 * \brief 200 * This function implements decoding process of a decision as defined 201 * in 9.3.3.2.2. 202 * 203 * \return 204 * Returns symbol decoded. 205 * 206 * \note 207 * It is specified in 9.3.3.2.3.2 that, one of the input to this function 208 * is CtxIdx. CtxIdx is used to identify state and MPS of that context 209 * (Refer Fig 9.11 - Flowchart for encoding a decision). To suffice that 210 * here we pass a pointer bin_ctxt_model_t which contains these values. 211 * 212 ************************************************************************** 213 */ 214 215 #define DECODE_ONE_BIN_MACRO(p_binCtxt_arg ,u4_code_int_range,u4_code_int_val_ofst, \ 216 pu4_table_arg, \ 217 p_DecBitStream_arg,u4_symbol) \ 218 { \ 219 bin_ctxt_model_t *p_binCtxt_m = (bin_ctxt_model_t *) p_binCtxt_arg; \ 220 dec_bit_stream_t *p_DecBitStream_m = (dec_bit_stream_t *) p_DecBitStream_arg; \ 221 const UWORD32 *pu4_table_m = (const UWORD32 *) pu4_table_arg; \ 222 \ 223 UWORD32 u4_quantCodeIntRange_m,u4_codeIntRangeLPS_m; \ 224 UWORD32 u1_mps_state_m; \ 225 UWORD32 table_lookup_m; \ 226 UWORD32 u4_clz_m; \ 227 \ 228 u1_mps_state_m = (p_binCtxt_m->u1_mps_state); \ 229 u4_clz_m = CLZ(u4_code_int_range); \ 230 u4_quantCodeIntRange_m = u4_code_int_range << u4_clz_m; \ 231 u4_quantCodeIntRange_m = (u4_quantCodeIntRange_m >> 29) & 0x3; \ 232 table_lookup_m = pu4_table_m[(u1_mps_state_m << 2)+u4_quantCodeIntRange_m]; \ 233 u4_codeIntRangeLPS_m = table_lookup_m & 0xff; \ 234 \ 235 u4_codeIntRangeLPS_m = u4_codeIntRangeLPS_m << (23 - u4_clz_m); \ 236 u4_code_int_range = u4_code_int_range - u4_codeIntRangeLPS_m; \ 237 u4_symbol = ((u1_mps_state_m>> 6) & 0x1); \ 238 /*if mps*/ \ 239 u1_mps_state_m = (table_lookup_m >> 8) & 0x7F; \ 240 if(u4_code_int_val_ofst >= u4_code_int_range) \ 241 { \ 242 \ 243 u4_symbol = 1 - u4_symbol; \ 244 u4_code_int_val_ofst -= u4_code_int_range; \ 245 u4_code_int_range = u4_codeIntRangeLPS_m; \ 246 u1_mps_state_m = (table_lookup_m >> 15) & 0x7F; \ 247 } \ 248 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8) \ 249 { \ 250 UWORD32 *pu4_buffer,u4_offset; \ 251 UWORD32 read_bits,u4_clz_m ; \ 252 \ 253 pu4_buffer = p_DecBitStream_m->pu4_buffer; \ 254 u4_offset = p_DecBitStream_m->u4_ofst; \ 255 u4_clz_m = CLZ(u4_code_int_range); \ 256 NEXTBITS(read_bits,(u4_offset+23),pu4_buffer,u4_clz_m) \ 257 FLUSHBITS(u4_offset,(u4_clz_m)) \ 258 u4_code_int_range = u4_code_int_range << u4_clz_m; \ 259 u4_code_int_val_ofst= (u4_code_int_val_ofst << u4_clz_m) | read_bits; \ 260 \ 261 \ 262 p_DecBitStream_m->u4_ofst = u4_offset; \ 263 } \ 264 p_binCtxt_m->u1_mps_state = u1_mps_state_m; \ 265 } 266 267 #endif /* _IH264D_CABAC_H_ */ 268