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

Balancing coef-tree to reduce bool decodes

Browse Source 
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
This commit is contained in:
Deb Mukherjee 2013-05-08 10:04:14 -07:00
parent 38cb616fbf
commit b8b3f1a46d
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

17
vp9/common/vp9_entropy.c
View File

@ -201,8 +201,13 @@ DECLARE_ALIGNED(16, const int, vp9_default_scan_32x32[1024]) = {
const vp9_tree_index vp9_coef_tree[ 22] = /* corresponding _CONTEXT_NODEs */
{
#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 */
@ -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;
@ -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)

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