generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge "Balancing coef-tree to reduce bool decodes" into experimental

Browse Source
This commit is contained in:
Deb Mukherjee 2013-05-30 08:10:47 -07:00 committed by Gerrit Code Review
commit c98bfcfbbb
13 changed files with 873 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
configure vendored
View File

@ -244,6 +244,7 @@ EXPERIMENT_LIST="
multiple_arf
non420
alpha
balanced_coeftree
"
CONFIG_LIST="
external_build

687
vp9/common/vp9_default_coef_probs.h
View File

@ -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

27
vp9/common/vp9_entropy.c
View File

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

4
vp9/common/vp9_entropy.h
View File

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

3
vp9/decoder/vp9_decodframe.c
View File

@ -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);

24
vp9/decoder/vp9_detokenize.c
View File

@ -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);

29
vp9/encoder/vp9_bitstream.c
View File

@ -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;
@ -862,8 +868,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]);
}
}
}
@ -1066,11 +1075,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)

4
vp9/encoder/vp9_block.h
View File

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

1
vp9/encoder/vp9_boolhuff.c
View File

@ -10,6 +10,7 @@
#include <assert.h>
#include "vp9/encoder/vp9_boolhuff.h"
#include "vp9/common/vp9_entropy.h"
#if defined(SECTIONBITS_OUTPUT)
unsigned __int64 Sectionbits[500];

38
vp9/encoder/vp9_encodemb.c
View File

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

4
vp9/encoder/vp9_onyx_if.c
View File

@ -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);

66
vp9/encoder/vp9_rdopt.c
View File

@ -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
}
}

10
vp9/encoder/vp9_tokenize.c
View File

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