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];