1 /* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef VP9_COMMON_VP9_ENTROPY_H_ 12 #define VP9_COMMON_VP9_ENTROPY_H_ 13 14 #include "vpx/vpx_integer.h" 15 16 #include "vp9/common/vp9_blockd.h" 17 #include "vp9/common/vp9_common.h" 18 #include "vp9/common/vp9_scan.h" 19 #include "vp9/common/vp9_treecoder.h" 20 21 #define DIFF_UPDATE_PROB 252 22 23 /* Coefficient token alphabet */ 24 25 #define ZERO_TOKEN 0 /* 0 Extra Bits 0+0 */ 26 #define ONE_TOKEN 1 /* 1 Extra Bits 0+1 */ 27 #define TWO_TOKEN 2 /* 2 Extra Bits 0+1 */ 28 #define THREE_TOKEN 3 /* 3 Extra Bits 0+1 */ 29 #define FOUR_TOKEN 4 /* 4 Extra Bits 0+1 */ 30 #define DCT_VAL_CATEGORY1 5 /* 5-6 Extra Bits 1+1 */ 31 #define DCT_VAL_CATEGORY2 6 /* 7-10 Extra Bits 2+1 */ 32 #define DCT_VAL_CATEGORY3 7 /* 11-18 Extra Bits 3+1 */ 33 #define DCT_VAL_CATEGORY4 8 /* 19-34 Extra Bits 4+1 */ 34 #define DCT_VAL_CATEGORY5 9 /* 35-66 Extra Bits 5+1 */ 35 #define DCT_VAL_CATEGORY6 10 /* 67+ Extra Bits 14+1 */ 36 #define DCT_EOB_TOKEN 11 /* EOB Extra Bits 0+0 */ 37 #define MAX_ENTROPY_TOKENS 12 38 #define ENTROPY_NODES 11 39 #define EOSB_TOKEN 127 /* Not signalled, encoder only */ 40 41 #define INTER_MODE_CONTEXTS 7 42 43 extern DECLARE_ALIGNED(16, const uint8_t, 44 vp9_pt_energy_class[MAX_ENTROPY_TOKENS]); 45 46 extern const vp9_tree_index vp9_coef_tree[TREE_SIZE(MAX_ENTROPY_TOKENS)]; 47 48 #define DCT_EOB_MODEL_TOKEN 3 /* EOB Extra Bits 0+0 */ 49 extern const vp9_tree_index vp9_coefmodel_tree[]; 50 51 extern struct vp9_token vp9_coef_encodings[MAX_ENTROPY_TOKENS]; 52 53 typedef struct { 54 const vp9_tree_index *tree; 55 const vp9_prob *prob; 56 int len; 57 int base_val; 58 } vp9_extra_bit; 59 60 // indexed by token value 61 extern const vp9_extra_bit vp9_extra_bits[MAX_ENTROPY_TOKENS]; 62 63 #define MAX_PROB 255 64 #define DCT_MAX_VALUE 16384 65 66 /* Coefficients are predicted via a 3-dimensional probability table. */ 67 68 /* Outside dimension. 0 = Y with DC, 1 = UV */ 69 #define BLOCK_TYPES 2 70 #define REF_TYPES 2 // intra=0, inter=1 71 72 /* Middle dimension reflects the coefficient position within the transform. */ 73 #define COEF_BANDS 6 74 75 /* Inside dimension is measure of nearby complexity, that reflects the energy 76 of nearby coefficients are nonzero. For the first coefficient (DC, unless 77 block type is 0), we look at the (already encoded) blocks above and to the 78 left of the current block. The context index is then the number (0,1,or 2) 79 of these blocks having nonzero coefficients. 80 After decoding a coefficient, the measure is determined by the size of the 81 most recently decoded coefficient. 82 Note that the intuitive meaning of this measure changes as coefficients 83 are decoded, e.g., prior to the first token, a zero means that my neighbors 84 are empty while, after the first token, because of the use of end-of-block, 85 a zero means we just decoded a zero and hence guarantees that a non-zero 86 coefficient will appear later in this block. However, this shift 87 in meaning is perfectly OK because our context depends also on the 88 coefficient band (and since zigzag positions 0, 1, and 2 are in 89 distinct bands). */ 90 91 #define PREV_COEF_CONTEXTS 6 92 93 // #define ENTROPY_STATS 94 95 typedef unsigned int vp9_coeff_count[REF_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS] 96 [MAX_ENTROPY_TOKENS]; 97 typedef unsigned int vp9_coeff_stats[REF_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS] 98 [ENTROPY_NODES][2]; 99 100 #define SUBEXP_PARAM 4 /* Subexponential code parameter */ 101 #define MODULUS_PARAM 13 /* Modulus parameter */ 102 103 struct VP9Common; 104 void vp9_default_coef_probs(struct VP9Common *cm); 105 106 void vp9_coef_tree_initialize(); 107 void vp9_adapt_coef_probs(struct VP9Common *cm); 108 109 static INLINE void reset_skip_context(MACROBLOCKD *xd, BLOCK_SIZE bsize) { 110 int i; 111 for (i = 0; i < MAX_MB_PLANE; i++) { 112 struct macroblockd_plane *const pd = &xd->plane[i]; 113 const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); 114 vpx_memset(pd->above_context, 0, sizeof(ENTROPY_CONTEXT) * 115 num_4x4_blocks_wide_lookup[plane_bsize]); 116 vpx_memset(pd->left_context, 0, sizeof(ENTROPY_CONTEXT) * 117 num_4x4_blocks_high_lookup[plane_bsize]); 118 } 119 } 120 121 // This is the index in the scan order beyond which all coefficients for 122 // 8x8 transform and above are in the top band. 123 // This macro is currently unused but may be used by certain implementations 124 #define MAXBAND_INDEX 21 125 126 extern const uint8_t vp9_coefband_trans_8x8plus[1024]; 127 extern const uint8_t vp9_coefband_trans_4x4[16]; 128 129 static const uint8_t *get_band_translate(TX_SIZE tx_size) { 130 return tx_size == TX_4X4 ? vp9_coefband_trans_4x4 131 : vp9_coefband_trans_8x8plus; 132 } 133 134 // 128 lists of probabilities are stored for the following ONE node probs: 135 // 1, 3, 5, 7, ..., 253, 255 136 // In between probabilities are interpolated linearly 137 138 #define COEFPROB_MODELS 128 139 140 #define UNCONSTRAINED_NODES 3 141 142 #define PIVOT_NODE 2 // which node is pivot 143 144 typedef vp9_prob vp9_coeff_probs_model[REF_TYPES][COEF_BANDS] 145 [PREV_COEF_CONTEXTS] 146 [UNCONSTRAINED_NODES]; 147 148 typedef unsigned int vp9_coeff_count_model[REF_TYPES][COEF_BANDS] 149 [PREV_COEF_CONTEXTS] 150 [UNCONSTRAINED_NODES + 1]; 151 152 void vp9_model_to_full_probs(const vp9_prob *model, vp9_prob *full); 153 154 static int get_entropy_context(TX_SIZE tx_size, const ENTROPY_CONTEXT *a, 155 const ENTROPY_CONTEXT *l) { 156 ENTROPY_CONTEXT above_ec = 0, left_ec = 0; 157 158 switch (tx_size) { 159 case TX_4X4: 160 above_ec = a[0] != 0; 161 left_ec = l[0] != 0; 162 break; 163 case TX_8X8: 164 above_ec = !!*(const uint16_t *)a; 165 left_ec = !!*(const uint16_t *)l; 166 break; 167 case TX_16X16: 168 above_ec = !!*(const uint32_t *)a; 169 left_ec = !!*(const uint32_t *)l; 170 break; 171 case TX_32X32: 172 above_ec = !!*(const uint64_t *)a; 173 left_ec = !!*(const uint64_t *)l; 174 break; 175 default: 176 assert(!"Invalid transform size."); 177 } 178 179 return combine_entropy_contexts(above_ec, left_ec); 180 } 181 182 static void get_scan(const MACROBLOCKD *xd, TX_SIZE tx_size, 183 PLANE_TYPE type, int block_idx, 184 const int16_t **scan, const int16_t **scan_nb) { 185 switch (tx_size) { 186 case TX_4X4: 187 get_scan_nb_4x4(get_tx_type_4x4(type, xd, block_idx), scan, scan_nb); 188 break; 189 case TX_8X8: 190 get_scan_nb_8x8(get_tx_type_8x8(type, xd), scan, scan_nb); 191 break; 192 case TX_16X16: 193 get_scan_nb_16x16(get_tx_type_16x16(type, xd), scan, scan_nb); 194 break; 195 case TX_32X32: 196 *scan = vp9_default_scan_32x32; 197 *scan_nb = vp9_default_scan_32x32_neighbors; 198 break; 199 default: 200 assert(!"Invalid transform size."); 201 } 202 } 203 204 #endif // VP9_COMMON_VP9_ENTROPY_H_ 205
