From b8b3f1a46d756bef73cb4f3cd6990a01cbacaa25 Mon Sep 17 00:00:00 2001 From: Deb Mukherjee Date: Wed, 8 May 2013 10:04:14 -0700 Subject: [PATCH] Balancing coef-tree to reduce bool decodes This patch changes the coefficient tree to move the EOB to below the ZERO node in order to save number of bool decodes. The advantages of moving EOB one step down as opposed to two steps down in the other parallel patch are: 1. The coef modeling based on the One-node becomes independent of the tree structure above it, and 2. Fewer conext/counter increases are needed. The drawback is that the potential savings in bool decodes will be less, but assuming that 0s are much more predominant than 1's the potential savings is still likely to be substantial. Results on derf300: -0.237% Change-Id: Ie784be13dc98291306b338e8228703a4c2ea2242 --- configure | 1 + vp9/common/vp9_default_coef_probs.h | 687 ++++++++++++++++++++++++++++ vp9/common/vp9_entropy.c | 27 +- vp9/common/vp9_entropy.h | 4 +- vp9/decoder/vp9_decodframe.c | 3 - vp9/decoder/vp9_detokenize.c | 24 + vp9/encoder/vp9_bitstream.c | 29 +- vp9/encoder/vp9_block.h | 4 + vp9/encoder/vp9_boolhuff.c | 1 + vp9/encoder/vp9_encodemb.c | 38 +- vp9/encoder/vp9_onyx_if.c | 4 - vp9/encoder/vp9_rdopt.c | 66 ++- vp9/encoder/vp9_tokenize.c | 10 + 13 files changed, 873 insertions(+), 25 deletions(-) diff --git a/configure b/configure index f22a2dd4d..4a97889ec 100755 --- a/configure +++ b/configure @@ -244,6 +244,7 @@ EXPERIMENT_LIST=" multiple_arf non420 alpha + balanced_coeftree " CONFIG_LIST=" external_build diff --git a/vp9/common/vp9_default_coef_probs.h b/vp9/common/vp9_default_coef_probs.h index 3e8211954..15f9e97dd 100644 --- a/vp9/common/vp9_default_coef_probs.h +++ b/vp9/common/vp9_default_coef_probs.h @@ -11,6 +11,692 @@ /*Generated file, included by vp9_entropy.c*/ +#if CONFIG_BALANCED_COEFTREE +static const vp9_coeff_probs_model default_coef_probs_4x4[BLOCK_TYPES] = { + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 6, 213, 178 }, + { 26, 113, 132 }, + { 34, 17, 68 } + }, { /* Coeff Band 1 */ + { 66, 96, 178 }, + { 63, 96, 174 }, + { 67, 54, 154 }, + { 62, 28, 126 }, + { 48, 9, 84 }, + { 20, 1, 32 } + }, { /* Coeff Band 2 */ + { 64, 144, 206 }, + { 70, 99, 191 }, + { 69, 36, 152 }, + { 55, 9, 106 }, + { 35, 1, 60 }, + { 14, 1, 22 } + }, { /* Coeff Band 3 */ + { 82, 154, 222 }, + { 83, 112, 205 }, + { 81, 31, 164 }, + { 62, 7, 118 }, + { 42, 1, 74 }, + { 18, 1, 30 } + }, { /* Coeff Band 4 */ + { 52, 179, 233 }, + { 64, 132, 214 }, + { 73, 36, 170 }, + { 59, 8, 116 }, + { 38, 1, 65 }, + { 15, 1, 26 } + }, { /* Coeff Band 5 */ + { 29, 175, 238 }, + { 26, 169, 223 }, + { 41, 80, 182 }, + { 39, 32, 127 }, + { 26, 10, 69 }, + { 11, 2, 28 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 21, 226, 234 }, + { 52, 182, 212 }, + { 80, 112, 177 } + }, { /* Coeff Band 1 */ + { 111, 164, 243 }, + { 88, 152, 231 }, + { 90, 43, 186 }, + { 70, 12, 132 }, + { 44, 2, 76 }, + { 19, 1, 33 } + }, { /* Coeff Band 2 */ + { 96, 185, 246 }, + { 99, 127, 231 }, + { 88, 21, 177 }, + { 64, 5, 122 }, + { 38, 1, 69 }, + { 18, 1, 30 } + }, { /* Coeff Band 3 */ + { 84, 206, 249 }, + { 94, 147, 237 }, + { 95, 33, 187 }, + { 71, 8, 131 }, + { 47, 1, 83 }, + { 26, 1, 44 } + }, { /* Coeff Band 4 */ + { 38, 221, 252 }, + { 58, 177, 241 }, + { 78, 46, 188 }, + { 59, 9, 122 }, + { 34, 1, 66 }, + { 18, 1, 34 } + }, { /* Coeff Band 5 */ + { 21, 216, 253 }, + { 21, 206, 244 }, + { 42, 93, 200 }, + { 43, 41, 146 }, + { 36, 13, 93 }, + { 31, 1, 55 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 7, 213, 219 }, + { 23, 139, 182 }, + { 38, 60, 125 } + }, { /* Coeff Band 1 */ + { 69, 156, 220 }, + { 52, 178, 213 }, + { 69, 111, 190 }, + { 69, 58, 155 }, + { 58, 21, 104 }, + { 39, 7, 60 } + }, { /* Coeff Band 2 */ + { 68, 189, 228 }, + { 70, 158, 221 }, + { 83, 64, 189 }, + { 73, 18, 141 }, + { 48, 4, 88 }, + { 23, 1, 41 } + }, { /* Coeff Band 3 */ + { 99, 194, 236 }, + { 91, 138, 224 }, + { 91, 53, 189 }, + { 74, 20, 142 }, + { 48, 6, 90 }, + { 22, 1, 41 } + }, { /* Coeff Band 4 */ + { 52, 203, 244 }, + { 60, 168, 231 }, + { 75, 62, 189 }, + { 61, 18, 132 }, + { 38, 4, 72 }, + { 17, 1, 39 } + }, { /* Coeff Band 5 */ + { 33, 192, 247 }, + { 31, 185, 234 }, + { 46, 85, 185 }, + { 39, 35, 132 }, + { 28, 15, 80 }, + { 13, 5, 38 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 5, 247, 246 }, + { 28, 209, 228 }, + { 65, 137, 203 } + }, { /* Coeff Band 1 */ + { 69, 208, 250 }, + { 54, 207, 242 }, + { 81, 92, 204 }, + { 70, 54, 153 }, + { 58, 40, 108 }, + { 58, 35, 71 } + }, { /* Coeff Band 2 */ + { 65, 215, 250 }, + { 72, 185, 239 }, + { 92, 50, 197 }, + { 75, 14, 147 }, + { 49, 2, 99 }, + { 26, 1, 53 } + }, { /* Coeff Band 3 */ + { 70, 220, 251 }, + { 76, 186, 241 }, + { 90, 65, 198 }, + { 75, 26, 151 }, + { 58, 12, 112 }, + { 34, 6, 49 } + }, { /* Coeff Band 4 */ + { 34, 224, 253 }, + { 44, 204, 245 }, + { 69, 85, 204 }, + { 64, 31, 150 }, + { 44, 2, 78 }, + { 1, 1, 128 } + }, { /* Coeff Band 5 */ + { 25, 216, 253 }, + { 21, 215, 248 }, + { 47, 108, 214 }, + { 47, 48, 160 }, + { 26, 20, 90 }, + { 64, 171, 128 } + } + } + } +}; +static const vp9_coeff_probs_model default_coef_probs_8x8[BLOCK_TYPES] = { + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 9, 203, 199 }, + { 26, 92, 128 }, + { 28, 11, 55 } + }, { /* Coeff Band 1 */ + { 99, 54, 160 }, + { 78, 99, 155 }, + { 80, 44, 138 }, + { 71, 17, 115 }, + { 51, 5, 80 }, + { 27, 1, 40 } + }, { /* Coeff Band 2 */ + { 135, 81, 190 }, + { 113, 61, 182 }, + { 93, 16, 153 }, + { 70, 4, 115 }, + { 41, 1, 68 }, + { 16, 1, 27 } + }, { /* Coeff Band 3 */ + { 155, 103, 214 }, + { 129, 48, 199 }, + { 95, 10, 159 }, + { 63, 1, 110 }, + { 32, 1, 58 }, + { 12, 1, 21 } + }, { /* Coeff Band 4 */ + { 163, 149, 231 }, + { 137, 69, 213 }, + { 95, 11, 164 }, + { 62, 3, 108 }, + { 32, 1, 57 }, + { 13, 1, 22 } + }, { /* Coeff Band 5 */ + { 136, 189, 239 }, + { 123, 102, 223 }, + { 97, 19, 170 }, + { 66, 4, 111 }, + { 38, 1, 60 }, + { 18, 1, 26 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 24, 226, 244 }, + { 54, 178, 211 }, + { 80, 74, 152 } + }, { /* Coeff Band 1 */ + { 145, 153, 236 }, + { 101, 163, 223 }, + { 108, 50, 187 }, + { 90, 22, 145 }, + { 66, 8, 97 }, + { 42, 4, 50 } + }, { /* Coeff Band 2 */ + { 150, 159, 238 }, + { 128, 90, 218 }, + { 94, 9, 163 }, + { 64, 3, 110 }, + { 34, 1, 61 }, + { 13, 1, 24 } + }, { /* Coeff Band 3 */ + { 151, 162, 242 }, + { 135, 80, 222 }, + { 93, 9, 166 }, + { 61, 3, 111 }, + { 31, 1, 59 }, + { 12, 1, 22 } + }, { /* Coeff Band 4 */ + { 161, 170, 245 }, + { 140, 84, 228 }, + { 99, 8, 174 }, + { 64, 1, 116 }, + { 34, 1, 63 }, + { 14, 1, 26 } + }, { /* Coeff Band 5 */ + { 138, 197, 246 }, + { 127, 109, 233 }, + { 100, 16, 179 }, + { 66, 3, 119 }, + { 37, 1, 66 }, + { 16, 1, 30 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 6, 216, 212 }, + { 25, 134, 171 }, + { 43, 48, 118 } + }, { /* Coeff Band 1 */ + { 93, 112, 209 }, + { 66, 159, 206 }, + { 82, 78, 184 }, + { 75, 28, 148 }, + { 46, 4, 82 }, + { 18, 1, 28 } + }, { /* Coeff Band 2 */ + { 108, 148, 220 }, + { 90, 130, 216 }, + { 92, 40, 186 }, + { 73, 10, 135 }, + { 46, 1, 79 }, + { 20, 1, 35 } + }, { /* Coeff Band 3 */ + { 125, 173, 232 }, + { 109, 117, 223 }, + { 97, 31, 183 }, + { 71, 7, 127 }, + { 44, 1, 76 }, + { 21, 1, 36 } + }, { /* Coeff Band 4 */ + { 133, 195, 236 }, + { 112, 121, 224 }, + { 97, 23, 178 }, + { 69, 3, 122 }, + { 42, 1, 72 }, + { 19, 1, 34 } + }, { /* Coeff Band 5 */ + { 132, 180, 238 }, + { 119, 102, 225 }, + { 101, 18, 179 }, + { 71, 3, 124 }, + { 42, 1, 70 }, + { 17, 1, 28 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 5, 242, 250 }, + { 26, 198, 226 }, + { 58, 98, 168 } + }, { /* Coeff Band 1 */ + { 82, 201, 246 }, + { 50, 219, 237 }, + { 94, 107, 205 }, + { 89, 61, 167 }, + { 77, 31, 131 }, + { 57, 14, 91 } + }, { /* Coeff Band 2 */ + { 99, 202, 247 }, + { 96, 165, 234 }, + { 100, 31, 190 }, + { 72, 8, 131 }, + { 41, 1, 72 }, + { 14, 1, 24 } + }, { /* Coeff Band 3 */ + { 108, 204, 248 }, + { 107, 156, 235 }, + { 103, 27, 186 }, + { 71, 4, 124 }, + { 39, 1, 66 }, + { 14, 1, 19 } + }, { /* Coeff Band 4 */ + { 120, 211, 248 }, + { 118, 149, 234 }, + { 107, 19, 182 }, + { 72, 3, 126 }, + { 40, 1, 69 }, + { 16, 1, 24 } + }, { /* Coeff Band 5 */ + { 127, 199, 245 }, + { 122, 125, 232 }, + { 112, 20, 186 }, + { 82, 3, 136 }, + { 55, 1, 88 }, + { 10, 1, 38 } + } + } + } +}; +static const vp9_coeff_probs_model default_coef_probs_16x16[BLOCK_TYPES] = { + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 25, 9, 101 }, + { 25, 2, 67 }, + { 15, 1, 28 } + }, { /* Coeff Band 1 */ + { 67, 30, 118 }, + { 61, 56, 116 }, + { 60, 31, 105 }, + { 52, 11, 85 }, + { 34, 2, 54 }, + { 14, 1, 22 } + }, { /* Coeff Band 2 */ + { 107, 58, 149 }, + { 92, 53, 147 }, + { 78, 14, 123 }, + { 56, 3, 87 }, + { 35, 1, 56 }, + { 17, 1, 27 } + }, { /* Coeff Band 3 */ + { 142, 61, 171 }, + { 111, 30, 162 }, + { 80, 4, 128 }, + { 53, 1, 87 }, + { 31, 1, 52 }, + { 14, 1, 24 } + }, { /* Coeff Band 4 */ + { 171, 73, 200 }, + { 129, 28, 184 }, + { 86, 3, 140 }, + { 54, 1, 90 }, + { 28, 1, 49 }, + { 12, 1, 21 } + }, { /* Coeff Band 5 */ + { 193, 129, 227 }, + { 148, 28, 200 }, + { 90, 2, 144 }, + { 53, 1, 90 }, + { 28, 1, 50 }, + { 13, 1, 22 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 60, 7, 234 }, + { 64, 4, 184 }, + { 56, 1, 104 } + }, { /* Coeff Band 1 */ + { 150, 111, 210 }, + { 87, 185, 202 }, + { 101, 81, 177 }, + { 90, 34, 142 }, + { 67, 11, 95 }, + { 38, 2, 51 } + }, { /* Coeff Band 2 */ + { 153, 139, 218 }, + { 120, 72, 195 }, + { 90, 11, 147 }, + { 63, 3, 101 }, + { 39, 1, 61 }, + { 20, 1, 33 } + }, { /* Coeff Band 3 */ + { 171, 132, 223 }, + { 131, 56, 200 }, + { 92, 6, 147 }, + { 58, 1, 95 }, + { 32, 1, 52 }, + { 14, 1, 23 } + }, { /* Coeff Band 4 */ + { 183, 137, 227 }, + { 139, 48, 204 }, + { 91, 3, 148 }, + { 55, 1, 91 }, + { 28, 1, 47 }, + { 13, 1, 21 } + }, { /* Coeff Band 5 */ + { 198, 149, 234 }, + { 153, 32, 208 }, + { 95, 2, 148 }, + { 55, 1, 90 }, + { 30, 1, 51 }, + { 16, 1, 25 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 7, 209, 217 }, + { 31, 106, 151 }, + { 40, 21, 86 } + }, { /* Coeff Band 1 */ + { 101, 71, 184 }, + { 74, 131, 177 }, + { 88, 50, 158 }, + { 78, 16, 129 }, + { 51, 2, 82 }, + { 18, 1, 29 } + }, { /* Coeff Band 2 */ + { 116, 115, 199 }, + { 102, 88, 191 }, + { 94, 22, 160 }, + { 74, 6, 122 }, + { 47, 1, 77 }, + { 18, 1, 30 } + }, { /* Coeff Band 3 */ + { 157, 124, 210 }, + { 130, 53, 201 }, + { 102, 10, 165 }, + { 73, 1, 120 }, + { 42, 1, 69 }, + { 16, 1, 27 } + }, { /* Coeff Band 4 */ + { 174, 147, 225 }, + { 134, 67, 212 }, + { 100, 10, 168 }, + { 66, 1, 111 }, + { 36, 1, 60 }, + { 16, 1, 27 } + }, { /* Coeff Band 5 */ + { 185, 165, 232 }, + { 147, 56, 214 }, + { 105, 5, 165 }, + { 66, 1, 108 }, + { 35, 1, 59 }, + { 16, 1, 27 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 3, 232, 245 }, + { 18, 162, 210 }, + { 38, 64, 131 } + }, { /* Coeff Band 1 */ + { 84, 187, 239 }, + { 35, 231, 231 }, + { 82, 150, 209 }, + { 87, 97, 181 }, + { 81, 64, 151 }, + { 67, 60, 119 } + }, { /* Coeff Band 2 */ + { 107, 185, 239 }, + { 100, 149, 224 }, + { 107, 34, 185 }, + { 83, 12, 141 }, + { 49, 4, 92 }, + { 21, 1, 40 } + }, { /* Coeff Band 3 */ + { 125, 184, 243 }, + { 121, 127, 228 }, + { 113, 25, 185 }, + { 82, 6, 134 }, + { 48, 1, 82 }, + { 26, 1, 38 } + }, { /* Coeff Band 4 */ + { 143, 185, 245 }, + { 133, 115, 231 }, + { 114, 14, 184 }, + { 77, 3, 126 }, + { 43, 1, 68 }, + { 34, 1, 40 } + }, { /* Coeff Band 5 */ + { 170, 194, 241 }, + { 151, 80, 226 }, + { 118, 9, 180 }, + { 81, 1, 130 }, + { 51, 1, 78 }, + { 18, 1, 49 } + } + } + } +}; +static const vp9_coeff_probs_model default_coef_probs_32x32[BLOCK_TYPES] = { + { /* block Type 0 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 29, 42, 137 }, + { 26, 3, 60 }, + { 13, 1, 23 } + }, { /* Coeff Band 1 */ + { 69, 36, 122 }, + { 63, 57, 123 }, + { 60, 33, 112 }, + { 52, 11, 90 }, + { 32, 2, 52 }, + { 10, 1, 15 } + }, { /* Coeff Band 2 */ + { 107, 55, 143 }, + { 86, 69, 143 }, + { 74, 24, 116 }, + { 52, 5, 78 }, + { 29, 1, 44 }, + { 12, 1, 18 } + }, { /* Coeff Band 3 */ + { 137, 71, 160 }, + { 107, 34, 152 }, + { 73, 6, 114 }, + { 44, 1, 69 }, + { 25, 1, 40 }, + { 12, 1, 18 } + }, { /* Coeff Band 4 */ + { 165, 70, 174 }, + { 118, 24, 159 }, + { 74, 3, 117 }, + { 45, 1, 73 }, + { 26, 1, 43 }, + { 12, 1, 19 } + }, { /* Coeff Band 5 */ + { 220, 93, 223 }, + { 153, 10, 187 }, + { 86, 2, 131 }, + { 49, 1, 79 }, + { 26, 1, 43 }, + { 12, 1, 20 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 30, 58, 227 }, + { 35, 10, 172 }, + { 24, 23, 112 } + }, { /* Coeff Band 1 */ + { 117, 145, 219 }, + { 51, 221, 216 }, + { 75, 169, 196 }, + { 88, 96, 165 }, + { 77, 43, 117 }, + { 53, 18, 60 } + }, { /* Coeff Band 2 */ + { 128, 176, 225 }, + { 108, 114, 202 }, + { 92, 19, 152 }, + { 65, 4, 103 }, + { 38, 1, 61 }, + { 19, 1, 30 } + }, { /* Coeff Band 3 */ + { 146, 184, 228 }, + { 122, 95, 205 }, + { 92, 11, 149 }, + { 62, 1, 98 }, + { 35, 1, 57 }, + { 17, 1, 26 } + }, { /* Coeff Band 4 */ + { 165, 192, 230 }, + { 132, 81, 206 }, + { 93, 6, 147 }, + { 58, 1, 94 }, + { 32, 1, 52 }, + { 15, 1, 24 } + }, { /* Coeff Band 5 */ + { 204, 223, 234 }, + { 156, 49, 204 }, + { 97, 3, 145 }, + { 59, 1, 92 }, + { 33, 1, 52 }, + { 15, 1, 24 } + } + } + }, { /* block Type 1 */ + { /* Intra */ + { /* Coeff Band 0 */ + { 7, 184, 200 }, + { 25, 67, 113 }, + { 30, 9, 59 } + }, { /* Coeff Band 1 */ + { 92, 42, 158 }, + { 65, 121, 159 }, + { 77, 56, 146 }, + { 70, 22, 120 }, + { 47, 4, 76 }, + { 18, 1, 26 } + }, { /* Coeff Band 2 */ + { 113, 81, 177 }, + { 96, 75, 167 }, + { 84, 24, 136 }, + { 63, 8, 100 }, + { 37, 1, 58 }, + { 13, 1, 19 } + }, { /* Coeff Band 3 */ + { 147, 85, 194 }, + { 119, 36, 178 }, + { 88, 8, 139 }, + { 59, 1, 93 }, + { 31, 1, 49 }, + { 10, 1, 18 } + }, { /* Coeff Band 4 */ + { 169, 108, 210 }, + { 131, 41, 191 }, + { 92, 5, 144 }, + { 56, 1, 88 }, + { 29, 1, 47 }, + { 14, 1, 22 } + }, { /* Coeff Band 5 */ + { 210, 106, 223 }, + { 148, 14, 192 }, + { 89, 2, 138 }, + { 52, 1, 84 }, + { 29, 1, 47 }, + { 14, 1, 23 } + } + }, { /* Inter */ + { /* Coeff Band 0 */ + { 3, 207, 245 }, + { 12, 102, 213 }, + { 18, 33, 144 } + }, { /* Coeff Band 1 */ + { 85, 205, 245 }, + { 18, 249, 242 }, + { 59, 221, 229 }, + { 91, 166, 213 }, + { 88, 117, 183 }, + { 70, 95, 149 } + }, { /* Coeff Band 2 */ + { 114, 193, 241 }, + { 104, 155, 221 }, + { 100, 33, 181 }, + { 78, 10, 132 }, + { 43, 2, 75 }, + { 15, 1, 48 } + }, { /* Coeff Band 3 */ + { 118, 198, 244 }, + { 117, 142, 224 }, + { 111, 25, 179 }, + { 83, 4, 134 }, + { 57, 1, 84 }, + { 1, 1, 1 } + }, { /* Coeff Band 4 */ + { 144, 201, 248 }, + { 136, 130, 234 }, + { 124, 12, 188 }, + { 83, 1, 130 }, + { 61, 1, 66 }, + { 64, 171, 128 } + }, { /* Coeff Band 5 */ + { 174, 227, 250 }, + { 165, 118, 242 }, + { 132, 21, 197 }, + { 84, 3, 134 }, + { 70, 1, 69 }, + { 1, 1, 1 } + } + } + } +}; +#else static const vp9_coeff_probs_model default_coef_probs_4x4[BLOCK_TYPES] = { { /* block Type 0 */ { /* Intra */ @@ -695,3 +1381,4 @@ static const vp9_coeff_probs_model default_coef_probs_32x32[BLOCK_TYPES] = { } } }; +#endif diff --git a/vp9/common/vp9_entropy.c b/vp9/common/vp9_entropy.c index 1ae35864c..5a1e91a9d 100644 --- a/vp9/common/vp9_entropy.c +++ b/vp9/common/vp9_entropy.c @@ -201,11 +201,16 @@ DECLARE_ALIGNED(16, const int, vp9_default_scan_32x32[1024]) = { const vp9_tree_index vp9_coef_tree[ 22] = /* corresponding _CONTEXT_NODEs */ { - -DCT_EOB_TOKEN, 2, /* 0 = EOB */ - -ZERO_TOKEN, 4, /* 1 = ZERO */ - -ONE_TOKEN, 6, /* 2 = ONE */ - 8, 12, /* 3 = LOW_VAL */ - -TWO_TOKEN, 10, /* 4 = TWO */ +#if CONFIG_BALANCED_COEFTREE + -ZERO_TOKEN, 2, /* 0 = ZERO */ + -DCT_EOB_TOKEN, 4, /* 1 = EOB */ +#else + -DCT_EOB_TOKEN, 2, /* 0 = EOB */ + -ZERO_TOKEN, 4, /* 1 = ZERO */ +#endif + -ONE_TOKEN, 6, /* 2 = ONE */ + 8, 12, /* 3 = LOW_VAL */ + -TWO_TOKEN, 10, /* 4 = TWO */ -THREE_TOKEN, -FOUR_TOKEN, /* 5 = THREE */ 14, 16, /* 6 = HIGH_LOW */ -DCT_VAL_CATEGORY1, -DCT_VAL_CATEGORY2, /* 7 = CAT_ONE */ @@ -229,9 +234,14 @@ static const vp9_prob Pcat6[] = { }; const vp9_tree_index vp9_coefmodel_tree[6] = { +#if CONFIG_BALANCED_COEFTREE + -ZERO_TOKEN, 2, + -DCT_EOB_MODEL_TOKEN, 4, +#else -DCT_EOB_MODEL_TOKEN, 2, /* 0 = EOB */ -ZERO_TOKEN, 4, /* 1 = ZERO */ - -ONE_TOKEN, -TWO_TOKEN, /* 2 = ONE */ +#endif + -ONE_TOKEN, -TWO_TOKEN, }; // Model obtained from a 2-sided zero-centerd distribuition derived @@ -690,8 +700,13 @@ static void adapt_coef_probs( vp9_coefmodel_tree, coef_probs, branch_ct, coef_counts[i][j][k][l], 0); +#if CONFIG_BALANCED_COEFTREE + branch_ct[1][1] = eob_branch_count[i][j][k][l] - branch_ct[1][0]; + coef_probs[1] = get_binary_prob(branch_ct[1][0], branch_ct[1][1]); +#else branch_ct[0][1] = eob_branch_count[i][j][k][l] - branch_ct[0][0]; coef_probs[0] = get_binary_prob(branch_ct[0][0], branch_ct[0][1]); +#endif for (t = 0; t < entropy_nodes_adapt; ++t) { count = branch_ct[t][0] + branch_ct[t][1]; count = count > count_sat ? count_sat : count; diff --git a/vp9/common/vp9_entropy.h b/vp9/common/vp9_entropy.h index e76211a7c..27e3bec5a 100644 --- a/vp9/common/vp9_entropy.h +++ b/vp9/common/vp9_entropy.h @@ -85,8 +85,7 @@ extern vp9_extra_bit vp9_extra_bits[12]; /* indexed by token value */ /*# define DC_TOKEN_CONTEXTS 3*/ /* 00, 0!0, !0!0 */ #define PREV_COEF_CONTEXTS 6 -// Disables backward coef probs adaption -// #define DISABLE_COEF_ADAPT +// #define ENTROPY_STATS typedef unsigned int vp9_coeff_count[REF_TYPES][COEF_BANDS][PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS]; @@ -162,6 +161,7 @@ const int *vp9_get_coef_neighbors_handle(const int *scan, int *pad); #define UNCONSTRAINED_NODES 3 #define MODEL_NODES (ENTROPY_NODES - UNCONSTRAINED_NODES) + #define PIVOT_NODE 2 // which node is pivot typedef vp9_prob vp9_coeff_probs_model[REF_TYPES][COEF_BANDS] diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c index a4a8226a0..4e78ebf30 100644 --- a/vp9/decoder/vp9_decodframe.c +++ b/vp9/decoder/vp9_decodframe.c @@ -1073,9 +1073,6 @@ int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) { if (vp9_read(&header_bc, 252)) pc->fc.vp9_mode_contexts[i][j] = vp9_read_prob(&header_bc); } - // Is this needed ? - if (keyframe) - vp9_default_coef_probs(pc); update_frame_context(&pc->fc); diff --git a/vp9/decoder/vp9_detokenize.c b/vp9/decoder/vp9_detokenize.c index 890d5d0d6..6f6c88a27 100644 --- a/vp9/decoder/vp9_detokenize.c +++ b/vp9/decoder/vp9_detokenize.c @@ -17,8 +17,13 @@ #include "vp9/decoder/vp9_detokenize.h" #include "vp9/common/vp9_seg_common.h" +#if CONFIG_BALANCED_COEFTREE +#define ZERO_CONTEXT_NODE 0 +#define EOB_CONTEXT_NODE 1 +#else #define EOB_CONTEXT_NODE 0 #define ZERO_CONTEXT_NODE 1 +#endif #define ONE_CONTEXT_NODE 2 #define LOW_VAL_CONTEXT_NODE 3 #define TWO_CONTEXT_NODE 4 @@ -111,6 +116,9 @@ static int decode_coefs(VP9D_COMP *dx, const MACROBLOCKD *xd, const int *scan, *nb; uint8_t token_cache[1024]; const uint8_t * band_translate; +#if CONFIG_BALANCED_COEFTREE + int skip_eob_node = 0; +#endif switch (txfm_size) { default: @@ -182,11 +190,13 @@ static int decode_coefs(VP9D_COMP *dx, const MACROBLOCKD *xd, c, default_eob); band = get_coef_band(band_translate, c); prob = coef_probs[band][pt]; +#if !CONFIG_BALANCED_COEFTREE fc->eob_branch_counts[txfm_size][type][ref][band][pt]++; if (!vp9_read(r, prob[EOB_CONTEXT_NODE])) break; SKIP_START: +#endif if (c >= seg_eob) break; if (c) @@ -198,8 +208,22 @@ SKIP_START: if (!vp9_read(r, prob[ZERO_CONTEXT_NODE])) { INCREMENT_COUNT(ZERO_TOKEN); ++c; +#if CONFIG_BALANCED_COEFTREE + skip_eob_node = 1; + continue; +#else goto SKIP_START; +#endif } +#if CONFIG_BALANCED_COEFTREE + if (!skip_eob_node) { + fc->eob_branch_counts[txfm_size][type][ref][band][pt]++; + if (!vp9_read(r, prob[EOB_CONTEXT_NODE])) + break; + } + skip_eob_node = 0; +#endif + // ONE_CONTEXT_NODE_0_ if (!vp9_read(r, prob[ONE_CONTEXT_NODE])) { WRITE_COEF_CONTINUE(1, ONE_TOKEN); diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c index 13bfe2134..cf3307b33 100644 --- a/vp9/encoder/vp9_bitstream.c +++ b/vp9/encoder/vp9_bitstream.c @@ -473,7 +473,6 @@ static void pack_mb_tokens(vp9_writer* const bc, const vp9_prob *pp; int v = a->value; int n = a->len; - int ncount = n; vp9_prob probs[ENTROPY_NODES]; if (t == EOSB_TOKEN) { @@ -489,18 +488,25 @@ static void pack_mb_tokens(vp9_writer* const bc, assert(pp != 0); /* skip one or two nodes */ +#if !CONFIG_BALANCED_COEFTREE if (p->skip_eob_node) { n -= p->skip_eob_node; i = 2 * p->skip_eob_node; - ncount -= p->skip_eob_node; } +#endif do { const int bb = (v >> --n) & 1; +#if CONFIG_BALANCED_COEFTREE + if (i == 2 && p->skip_eob_node) { + i += 2; + assert(bb == 1); + continue; + } +#endif vp9_write(bc, bb, pp[i >> 1]); i = vp9_coef_tree[i + bb]; - ncount--; - } while (n && ncount); + } while (n); if (b->base_val) { const int e = p->extra, l = b->len; @@ -871,8 +877,11 @@ static void write_mb_modes_kf(const VP9_COMP *cpi, const MB_PREDICTION_MODE A = above_block_mode(m, i, mis); const MB_PREDICTION_MODE L = (xd->left_available || idx) ? left_block_mode(m, i) : DC_PRED; - write_kf_bmode(bc, m->bmi[i].as_mode.first, - c->kf_bmode_prob[A][L]); + const int bm = m->bmi[i].as_mode.first; +#ifdef ENTROPY_STATS + ++intra_mode_stats[A][L][bm]; +#endif + write_kf_bmode(bc, bm, c->kf_bmode_prob[A][L]); } } } @@ -1075,11 +1084,19 @@ static void build_tree_distribution(vp9_coeff_probs_model *coef_probs, coef_probs[i][j][k][l], coef_branch_ct[i][j][k][l], model_counts, 0); +#if CONFIG_BALANCED_COEFTREE + coef_branch_ct[i][j][k][l][1][1] = eob_branch_ct[i][j][k][l] - + coef_branch_ct[i][j][k][l][1][0]; + coef_probs[i][j][k][l][1] = + get_binary_prob(coef_branch_ct[i][j][k][l][1][0], + coef_branch_ct[i][j][k][l][1][1]); +#else coef_branch_ct[i][j][k][l][0][1] = eob_branch_ct[i][j][k][l] - coef_branch_ct[i][j][k][l][0][0]; coef_probs[i][j][k][l][0] = get_binary_prob(coef_branch_ct[i][j][k][l][0][0], coef_branch_ct[i][j][k][l][0][1]); +#endif #ifdef ENTROPY_STATS if (!cpi->dummy_packing) { for (t = 0; t < MAX_ENTROPY_TOKENS; ++t) diff --git a/vp9/encoder/vp9_block.h b/vp9/encoder/vp9_block.h index 0e9b6804c..cf34cc1f7 100644 --- a/vp9/encoder/vp9_block.h +++ b/vp9/encoder/vp9_block.h @@ -133,7 +133,11 @@ struct macroblock { unsigned char *active_ptr; + // note that token_costs is the cost when eob node is skipped vp9_coeff_count token_costs[TX_SIZE_MAX_SB][BLOCK_TYPES]; +#if CONFIG_BALANCED_COEFTREE + vp9_coeff_count token_costs_noskip[TX_SIZE_MAX_SB][BLOCK_TYPES]; +#endif int optimize; diff --git a/vp9/encoder/vp9_boolhuff.c b/vp9/encoder/vp9_boolhuff.c index 0fcb2579f..86143ca57 100644 --- a/vp9/encoder/vp9_boolhuff.c +++ b/vp9/encoder/vp9_boolhuff.c @@ -10,6 +10,7 @@ #include #include "vp9/encoder/vp9_boolhuff.h" +#include "vp9/common/vp9_entropy.h" #if defined(SECTIONBITS_OUTPUT) unsigned __int64 Sectionbits[500]; diff --git a/vp9/encoder/vp9_encodemb.c b/vp9/encoder/vp9_encodemb.c index 755ff21bf..98ea98031 100644 --- a/vp9/encoder/vp9_encodemb.c +++ b/vp9/encoder/vp9_encodemb.c @@ -215,10 +215,21 @@ static void optimize_b(VP9_COMMON *const cm, MACROBLOCK *mb, band = get_coef_band(band_translate, i + 1); pt = trellis_get_coeff_context(scan, nb, i, t0, token_cache, pad, default_eob); +#if CONFIG_BALANCED_COEFTREE rate0 += - mb->token_costs[tx_size][type][ref][band][pt][tokens[next][0].token]; + mb->token_costs_noskip[tx_size][type][ref][band][pt] + [tokens[next][0].token]; rate1 += - mb->token_costs[tx_size][type][ref][band][pt][tokens[next][1].token]; + mb->token_costs_noskip[tx_size][type][ref][band][pt] + [tokens[next][1].token]; +#else + rate0 += + mb->token_costs[tx_size][type][ref][band][pt] + [tokens[next][0].token]; + rate1 += + mb->token_costs[tx_size][type][ref][band][pt] + [tokens[next][1].token]; +#endif } UPDATE_RD_COST(); /* And pick the best. */ @@ -266,14 +277,32 @@ static void optimize_b(VP9_COMMON *const cm, MACROBLOCK *mb, if (t0 != DCT_EOB_TOKEN) { pt = trellis_get_coeff_context(scan, nb, i, t0, token_cache, pad, default_eob); +#if CONFIG_BALANCED_COEFTREE + if (!x) + rate0 += mb->token_costs[tx_size][type][ref][band][pt][ + tokens[next][0].token]; + else + rate0 += mb->token_costs_noskip[tx_size][type][ref][band][pt][ + tokens[next][0].token]; +#else rate0 += mb->token_costs[tx_size][type][ref][band][pt][ tokens[next][0].token]; +#endif } if (t1 != DCT_EOB_TOKEN) { pt = trellis_get_coeff_context(scan, nb, i, t1, token_cache, pad, default_eob); +#if CONFIG_BALANCED_COEFTREE + if (!x) + rate1 += mb->token_costs[tx_size][type][ref][band][pt][ + tokens[next][1].token]; + else + rate1 += mb->token_costs_noskip[tx_size][type][ref][band][pt][ + tokens[next][1].token]; +#else rate1 += mb->token_costs[tx_size][type][ref][band][pt][ tokens[next][1].token]; +#endif } } @@ -326,8 +355,13 @@ static void optimize_b(VP9_COMMON *const cm, MACROBLOCK *mb, error1 = tokens[next][1].error; t0 = tokens[next][0].token; t1 = tokens[next][1].token; +#if CONFIG_BALANCED_COEFTREE + rate0 += mb->token_costs_noskip[tx_size][type][ref][band][pt][t0]; + rate1 += mb->token_costs_noskip[tx_size][type][ref][band][pt][t1]; +#else rate0 += mb->token_costs[tx_size][type][ref][band][pt][t0]; rate1 += mb->token_costs[tx_size][type][ref][band][pt][t1]; +#endif UPDATE_RD_COST(); best = rd_cost1 < rd_cost0; final_eob = i0 - 1; diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c index e2f24848f..93dafeead 100644 --- a/vp9/encoder/vp9_onyx_if.c +++ b/vp9/encoder/vp9_onyx_if.c @@ -284,7 +284,6 @@ static void setup_features(VP9_COMP *cpi) { set_default_lf_deltas(cpi); } - static void dealloc_compressor_data(VP9_COMP *cpi) { // Delete sementation map vpx_free(cpi->segmentation_map); @@ -2935,9 +2934,6 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi, #endif // transform / motion compensation build reconstruction frame - if (cm->frame_type == KEY_FRAME) { - vp9_default_coef_probs(cm); - } vp9_encode_frame(cpi); diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c index e649192f9..bf417b89f 100644 --- a/vp9/encoder/vp9_rdopt.c +++ b/vp9/encoder/vp9_rdopt.c @@ -108,11 +108,31 @@ const MODE_DEFINITION vp9_mode_order[MAX_MODES] = { {SPLITMV, GOLDEN_FRAME, ALTREF_FRAME}, }; +#if CONFIG_BALANCED_COEFTREE +static void fill_token_costs(vp9_coeff_count *c, + vp9_coeff_count *cnoskip, + vp9_coeff_probs_model *p, + TX_SIZE tx_size) { + int i, j, k, l; + for (i = 0; i < BLOCK_TYPES; i++) + for (j = 0; j < REF_TYPES; j++) + for (k = 0; k < COEF_BANDS; k++) + for (l = 0; l < PREV_COEF_CONTEXTS; l++) { + vp9_prob probs[ENTROPY_NODES]; + vp9_model_to_full_probs(p[i][j][k][l], probs); + vp9_cost_tokens((int *)cnoskip[i][j][k][l], probs, + vp9_coef_tree); + // Replace the eob node prob with a very small value so that the + // cost approximately equals the cost without the eob node + probs[1] = 1; + vp9_cost_tokens((int *)c[i][j][k][l], probs, vp9_coef_tree); + } +} +#else static void fill_token_costs(vp9_coeff_count *c, vp9_coeff_probs_model *p, TX_SIZE tx_size) { int i, j, k, l; - for (i = 0; i < BLOCK_TYPES; i++) for (j = 0; j < REF_TYPES; j++) for (k = 0; k < COEF_BANDS; k++) @@ -123,6 +143,7 @@ static void fill_token_costs(vp9_coeff_count *c, vp9_coef_tree); } } +#endif static int rd_iifactor[32] = { 4, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -213,6 +234,20 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) { } } +#if CONFIG_BALANCED_COEFTREE + fill_token_costs(cpi->mb.token_costs[TX_4X4], + cpi->mb.token_costs_noskip[TX_4X4], + cpi->common.fc.coef_probs_4x4, TX_4X4); + fill_token_costs(cpi->mb.token_costs[TX_8X8], + cpi->mb.token_costs_noskip[TX_8X8], + cpi->common.fc.coef_probs_8x8, TX_8X8); + fill_token_costs(cpi->mb.token_costs[TX_16X16], + cpi->mb.token_costs_noskip[TX_16X16], + cpi->common.fc.coef_probs_16x16, TX_16X16); + fill_token_costs(cpi->mb.token_costs[TX_32X32], + cpi->mb.token_costs_noskip[TX_32X32], + cpi->common.fc.coef_probs_32x32, TX_32X32); +#else fill_token_costs(cpi->mb.token_costs[TX_4X4], cpi->common.fc.coef_probs_4x4, TX_4X4); fill_token_costs(cpi->mb.token_costs[TX_8X8], @@ -221,6 +256,7 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) { cpi->common.fc.coef_probs_16x16, TX_16X16); fill_token_costs(cpi->mb.token_costs[TX_32X32], cpi->common.fc.coef_probs_32x32, TX_32X32); +#endif for (i = 0; i < NUM_PARTITION_CONTEXTS; i++) vp9_cost_tokens(cpi->mb.partition_cost[i], @@ -274,7 +310,13 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb, TX_TYPE tx_type = DCT_DCT; const int segment_id = xd->mode_info_context->mbmi.segment_id; +#if CONFIG_BALANCED_COEFTREE + unsigned int (*token_costs_noskip)[PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS] = + mb->token_costs_noskip[tx_size][type][ref]; +#else vp9_prob coef_probs[COEF_BANDS][PREV_COEF_CONTEXTS][ENTROPY_NODES]; +#endif + int seg_eob, default_eob; uint8_t token_cache[1024]; const uint8_t * band_translate; @@ -294,8 +336,10 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb, get_tx_type_4x4(xd, block) : DCT_DCT; above_ec = A[0] != 0; left_ec = L[0] != 0; +#if !CONFIG_BALANCED_COEFTREE vp9_model_to_full_probs_sb(cm->fc.coef_probs_4x4[type][ref], coef_probs); +#endif seg_eob = 16; scan = get_scan_4x4(tx_type); band_translate = vp9_coefband_trans_4x4; @@ -310,8 +354,10 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb, above_ec = (A[0] + A[1]) != 0; left_ec = (L[0] + L[1]) != 0; scan = get_scan_8x8(tx_type); +#if !CONFIG_BALANCED_COEFTREE vp9_model_to_full_probs_sb(cm->fc.coef_probs_8x8[type][ref], coef_probs); +#endif seg_eob = 64; band_translate = vp9_coefband_trans_8x8plus; break; @@ -323,8 +369,10 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb, TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ? get_tx_type_16x16(xd, y + (x >> 2)) : DCT_DCT; scan = get_scan_16x16(tx_type); +#if !CONFIG_BALANCED_COEFTREE vp9_model_to_full_probs_sb(cm->fc.coef_probs_16x16[type][ref], coef_probs); +#endif seg_eob = 256; above_ec = (A[0] + A[1] + A[2] + A[3]) != 0; left_ec = (L[0] + L[1] + L[2] + L[3]) != 0; @@ -333,8 +381,10 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb, } case TX_32X32: scan = vp9_default_scan_32x32; +#if !CONFIG_BALANCED_COEFTREE vp9_model_to_full_probs_sb(cm->fc.coef_probs_32x32[type][ref], coef_probs); +#endif seg_eob = 1024; above_ec = (A[0] + A[1] + A[2] + A[3] + A[4] + A[5] + A[6] + A[7]) != 0; left_ec = (L[0] + L[1] + L[2] + L[3] + L[4] + L[5] + L[6] + L[7]) != 0; @@ -365,18 +415,30 @@ static INLINE int cost_coeffs(VP9_COMMON *const cm, MACROBLOCK *mb, if (c) pt = vp9_get_coef_context(scan, nb, pad, token_cache, c, default_eob); +#if CONFIG_BALANCED_COEFTREE + if (!c || token_cache[scan[c - 1]]) // do not skip eob + cost += token_costs_noskip[band][pt][t] + vp9_dct_value_cost_ptr[v]; + else + cost += token_costs[band][pt][t] + vp9_dct_value_cost_ptr[v]; +#else cost += token_costs[band][pt][t] + vp9_dct_value_cost_ptr[v]; - if (!c || token_cache[scan[c - 1]]) cost += vp9_cost_bit(coef_probs[band][pt][0], 1); +#endif token_cache[scan[c]] = vp9_pt_energy_class[t]; } if (c < seg_eob) { if (c) pt = vp9_get_coef_context(scan, nb, pad, token_cache, c, default_eob); +#if CONFIG_BALANCED_COEFTREE + cost += mb->token_costs_noskip[tx_size][type][ref] + [get_coef_band(band_translate, c)] + [pt][DCT_EOB_TOKEN]; +#else cost += mb->token_costs[tx_size][type][ref] [get_coef_band(band_translate, c)] [pt][DCT_EOB_TOKEN]; +#endif } } diff --git a/vp9/encoder/vp9_tokenize.c b/vp9/encoder/vp9_tokenize.c index eb79de1d9..79f72bb4b 100644 --- a/vp9/encoder/vp9_tokenize.c +++ b/vp9/encoder/vp9_tokenize.c @@ -224,11 +224,21 @@ static void tokenize_b(int plane, int block, BLOCK_SIZE_TYPE bsize, t->token = token; t->context_tree = coef_probs[type][ref][band][pt]; t->skip_eob_node = (c > 0) && (token_cache[scan[c - 1]] == 0); + +#if CONFIG_BALANCED_COEFTREE + assert(token <= ZERO_TOKEN || + vp9_coef_encodings[t->token].len - t->skip_eob_node > 0); +#else assert(vp9_coef_encodings[t->token].len - t->skip_eob_node > 0); +#endif if (!dry_run) { ++counts[type][ref][band][pt][token]; +#if CONFIG_BALANCED_COEFTREE + if (!t->skip_eob_node && token > ZERO_TOKEN) +#else if (!t->skip_eob_node) +#endif ++cpi->common.fc.eob_branch_counts[tx_size][type][ref][band][pt]; } token_cache[scan[c]] = vp9_pt_energy_class[token];