2 * Copyright © 2016 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 * Zhao Yakui <yakui.zhao@intel.com>
28 * This file defines some vp9 probability tables, and
29 * they are ported from libvpx (https://github.com/webmproject/libvpx/).
30 * The original copyright and licence statement as below.
34 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
36 * Use of this source code is governed by a BSD-style license
37 * that can be found in the LICENSE file in the root of the source
38 * tree. An additional intellectual property rights grant can be found
39 * in the file PATENTS. All contributing project authors may
40 * be found in the AUTHORS file in the root of the source tree.
45 #include "vp9_probs.h"
46 #include "i965_drv_video.h"
49 struct tx_probs default_tx_probs = {
60 vp9_prob default_skip_probs[SKIP_CONTEXTS] = {
64 vp9_prob default_inter_mode_probs[INTER_MODE_CONTEXTS]
66 {2, 173, 34}, // 0 = both zero mv
67 {7, 145, 85}, // 1 = one zero mv + one a predicted mv
68 {7, 166, 63}, // 2 = two predicted mvs
69 {7, 94, 66}, // 3 = one predicted/zero and one new mv
70 {8, 64, 46}, // 4 = two new mvs
71 {17, 81, 31}, // 5 = one intra neighbour + x
72 {25, 29, 30}, // 6 = two intra neighbours
75 vp9_prob default_switchable_interp_prob[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS - 1] = {
82 vp9_prob default_intra_inter_p[INTRA_INTER_CONTEXTS] = {
86 vp9_prob default_comp_inter_p[COMP_INTER_CONTEXTS] = {
90 vp9_prob default_single_ref_p[REF_CONTEXTS][2] = {
98 vp9_prob default_comp_ref_p[REF_CONTEXTS] = {
99 50, 126, 123, 221, 226
102 vp9_prob vp9_kf_uv_mode_prob[INTRA_MODES][INTRA_MODES - 1] = {
103 { 144, 11, 54, 157, 195, 130, 46, 58, 108 }, // y = dc
104 { 118, 15, 123, 148, 131, 101, 44, 93, 131 }, // y = v
105 { 113, 12, 23, 188, 226, 142, 26, 32, 125 }, // y = h
106 { 120, 11, 50, 123, 163, 135, 64, 77, 103 }, // y = d45
107 { 113, 9, 36, 155, 111, 157, 32, 44, 161 }, // y = d135
108 { 116, 9, 55, 176, 76, 96, 37, 61, 149 }, // y = d117
109 { 115, 9, 28, 141, 161, 167, 21, 25, 193 }, // y = d153
110 { 120, 12, 32, 145, 195, 142, 32, 38, 86 }, // y = d207
111 { 116, 12, 64, 120, 140, 125, 49, 115, 121 }, // y = d63
112 { 102, 19, 66, 162, 182, 122, 35, 59, 128 } // y = tm
115 vp9_prob default_if_y_probs[BLOCK_SIZE_GROUPS][INTRA_MODES - 1] = {
116 { 65, 32, 18, 144, 162, 194, 41, 51, 98 }, // block_size < 8x8
117 { 132, 68, 18, 165, 217, 196, 45, 40, 78 }, // block_size < 16x16
118 { 173, 80, 19, 176, 240, 193, 64, 35, 46 }, // block_size < 32x32
119 { 221, 135, 38, 194, 248, 121, 96, 85, 29 } // block_size >= 32x32
122 vp9_prob default_if_uv_probs[INTRA_MODES][INTRA_MODES - 1] = {
123 { 120, 7, 76, 176, 208, 126, 28, 54, 103 }, // y = dc
124 { 48, 12, 154, 155, 139, 90, 34, 117, 119 }, // y = v
125 { 67, 6, 25, 204, 243, 158, 13, 21, 96 }, // y = h
126 { 97, 5, 44, 131, 176, 139, 48, 68, 97 }, // y = d45
127 { 83, 5, 42, 156, 111, 152, 26, 49, 152 }, // y = d135
128 { 80, 5, 58, 178, 74, 83, 33, 62, 145 }, // y = d117
129 { 86, 5, 32, 154, 192, 168, 14, 22, 163 }, // y = d153
130 { 85, 5, 32, 156, 216, 148, 19, 29, 73 }, // y = d207
131 { 77, 7, 64, 116, 132, 122, 37, 126, 120 }, // y = d63
132 { 101, 21, 107, 181, 192, 103, 19, 67, 125 } // y = tm
135 vp9_prob default_seg_tree_probs[SEG_TREE_PROBS] = {
136 255, 255, 255, 255, 255, 255, 255
139 vp9_prob default_seg_pred_probs[PREDICTION_PROBS] = {
143 vp9_prob vp9_kf_partition_probs[PARTITION_CONTEXTS]
144 [PARTITION_TYPES - 1] = {
146 { 158, 97, 94 }, // a/l both not split
147 { 93, 24, 99 }, // a split, l not split
148 { 85, 119, 44 }, // l split, a not split
149 { 62, 59, 67 }, // a/l both split
151 { 149, 53, 53 }, // a/l both not split
152 { 94, 20, 48 }, // a split, l not split
153 { 83, 53, 24 }, // l split, a not split
154 { 52, 18, 18 }, // a/l both split
156 { 150, 40, 39 }, // a/l both not split
157 { 78, 12, 26 }, // a split, l not split
158 { 67, 33, 11 }, // l split, a not split
159 { 24, 7, 5 }, // a/l both split
161 { 174, 35, 49 }, // a/l both not split
162 { 68, 11, 27 }, // a split, l not split
163 { 57, 15, 9 }, // l split, a not split
164 { 12, 3, 3 }, // a/l both split
167 vp9_prob default_partition_probs[PARTITION_CONTEXTS]
168 [PARTITION_TYPES - 1] = {
170 { 199, 122, 141 }, // a/l both not split
171 { 147, 63, 159 }, // a split, l not split
172 { 148, 133, 118 }, // l split, a not split
173 { 121, 104, 114 }, // a/l both split
175 { 174, 73, 87 }, // a/l both not split
176 { 92, 41, 83 }, // a split, l not split
177 { 82, 99, 50 }, // l split, a not split
178 { 53, 39, 39 }, // a/l both split
180 { 177, 58, 59 }, // a/l both not split
181 { 68, 26, 63 }, // a split, l not split
182 { 52, 79, 25 }, // l split, a not split
183 { 17, 14, 12 }, // a/l both split
185 { 222, 34, 30 }, // a/l both not split
186 { 72, 16, 44 }, // a split, l not split
187 { 58, 32, 12 }, // l split, a not split
188 { 10, 7, 6 }, // a/l both split
191 //Rearranged the values for better usage
192 nmv_context default_nmv_context = {
195 { // Vertical component
197 {224, 144, 192, 168, 192, 176, 192, 198, 198, 245}, // class
199 {136, 140, 148, 160, 176, 192, 224, 234, 234, 240}, // bits
201 { // Horizontal component
203 {216, 128, 176, 160, 176, 176, 192, 198, 198, 208}, // class
205 {136, 140, 148, 160, 176, 192, 224, 234, 234, 240}, // bits
208 {{128, 128, 64}, {96, 112, 64}}, // class0_fp0
210 {{128, 128, 64}, {96, 112, 64}}, // class0_fp1
212 {160, 128}, // class0_hp bit
217 //Rearranged the coeff probs for better usage
218 vp9_prob default_coef_probs_4x4[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
221 { 195, 29, 183 }, { 84, 49, 136 }, { 8, 42, 71 },
223 { 31, 107, 169 }, { 35, 99, 159 }, { 17, 82, 140 },
224 { 8, 66, 114 }, { 2, 44, 76 }, { 1, 19, 32 },
226 { 40, 132, 201 }, { 29, 114, 187 }, { 13, 91, 157 },
227 { 7, 75, 127 }, { 3, 58, 95 }, { 1, 28, 47 },
229 { 69, 142, 221 }, { 42, 122, 201 }, { 15, 91, 159 },
230 { 6, 67, 121 }, { 1, 42, 77 }, { 1, 17, 31 },
232 { 102, 148, 228 }, { 67, 117, 204 }, { 17, 82, 154 },
233 { 6, 59, 114 }, { 2, 39, 75 }, { 1, 15, 29 },
235 { 156, 57, 233 }, { 119, 57, 212 }, { 58, 48, 163 },
236 { 29, 40, 124 }, { 12, 30, 81 }, { 3, 12, 31 },
240 { 191, 107, 226 }, { 124, 117, 204 }, { 25, 99, 155 },
242 { 29, 148, 210 }, { 37, 126, 194 }, { 8, 93, 157 },
243 { 2, 68, 118 }, { 1, 39, 69 }, { 1, 17, 33 },
245 { 41, 151, 213 }, { 27, 123, 193 }, { 3, 82, 144 },
246 { 1, 58, 105 }, { 1, 32, 60 }, { 1, 13, 26 },
248 { 59, 159, 220 }, { 23, 126, 198 }, { 4, 88, 151 },
249 { 1, 66, 114 }, { 1, 38, 71 }, { 1, 18, 34 },
251 { 114, 136, 232 }, { 51, 114, 207 }, { 11, 83, 155 },
252 { 3, 56, 105 }, { 1, 33, 65 }, { 1, 17, 34 },
254 { 149, 65, 234 }, { 121, 57, 215 }, { 61, 49, 166 },
255 { 28, 36, 114 }, { 12, 25, 76 }, { 3, 16, 42 },
259 { 214, 49, 220 }, { 132, 63, 188 }, { 42, 65, 137 },
261 { 85, 137, 221 }, { 104, 131, 216 }, { 49, 111, 192 },
262 { 21, 87, 155 }, { 2, 49, 87 }, { 1, 16, 28 },
264 { 89, 163, 230 }, { 90, 137, 220 }, { 29, 100, 183 },
265 { 10, 70, 135 }, { 2, 42, 81 }, { 1, 17, 33 },
267 { 108, 167, 237 }, { 55, 133, 222 }, { 15, 97, 179 },
268 { 4, 72, 135 }, { 1, 45, 85 }, { 1, 19, 38 },
270 { 124, 146, 240 }, { 66, 124, 224 }, { 17, 88, 175 },
271 { 4, 58, 122 }, { 1, 36, 75 }, { 1, 18, 37 },
273 { 141, 79, 241 }, { 126, 70, 227 }, { 66, 58, 182 },
274 { 30, 44, 136 }, { 12, 34, 96 }, { 2, 20, 47 },
278 { 229, 99, 249 }, { 143, 111, 235 }, { 46, 109, 192 },
280 { 82, 158, 236 }, { 94, 146, 224 }, { 25, 117, 191 },
281 { 9, 87, 149 }, { 3, 56, 99 }, { 1, 33, 57 },
283 { 83, 167, 237 }, { 68, 145, 222 }, { 10, 103, 177 },
284 { 2, 72, 131 }, { 1, 41, 79 }, { 1, 20, 39 },
286 { 99, 167, 239 }, { 47, 141, 224 }, { 10, 104, 178 },
287 { 2, 73, 133 }, { 1, 44, 85 }, { 1, 22, 47 },
289 { 127, 145, 243 }, { 71, 129, 228 }, { 17, 93, 177 },
290 { 3, 61, 124 }, { 1, 41, 84 }, { 1, 21, 52 },
292 { 157, 78, 244 }, { 140, 72, 231 }, { 69, 58, 184 },
293 { 31, 44, 137 }, { 14, 38, 105 }, { 8, 23, 61 }
296 vp9_prob default_coef_probs_8x8[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
299 { 125, 34, 187 }, { 52, 41, 133 }, { 6, 31, 56 },
301 { 37, 109, 153 }, { 51, 102, 147 }, { 23, 87, 128 },
302 { 8, 67, 101 }, { 1, 41, 63 }, { 1, 19, 29 },
304 { 31, 154, 185 }, { 17, 127, 175 }, { 6, 96, 145 },
305 { 2, 73, 114 }, { 1, 51, 82 }, { 1, 28, 45 },
307 { 23, 163, 200 }, { 10, 131, 185 }, { 2, 93, 148 },
308 { 1, 67, 111 }, { 1, 41, 69 }, { 1, 14, 24 },
310 { 29, 176, 217 }, { 12, 145, 201 }, { 3, 101, 156 },
311 { 1, 69, 111 }, { 1, 39, 63 }, { 1, 14, 23 },
313 { 57, 192, 233 }, { 25, 154, 215 }, { 6, 109, 167 },
314 { 3, 78, 118 }, { 1, 48, 69 }, { 1, 21, 29 },
318 { 202, 105, 245 }, { 108, 106, 216 }, { 18, 90, 144 },
320 { 33, 172, 219 }, { 64, 149, 206 }, { 14, 117, 177 },
321 { 5, 90, 141 }, { 2, 61, 95 }, { 1, 37, 57 },
323 { 33, 179, 220 }, { 11, 140, 198 }, { 1, 89, 148 },
324 { 1, 60, 104 }, { 1, 33, 57 }, { 1, 12, 21 },
326 { 30, 181, 221 }, { 8, 141, 198 }, { 1, 87, 145 },
327 { 1, 58, 100 }, { 1, 31, 55 }, { 1, 12, 20 },
329 { 32, 186, 224 }, { 7, 142, 198 }, { 1, 86, 143 },
330 { 1, 58, 100 }, { 1, 31, 55 }, { 1, 12, 22 },
332 { 57, 192, 227 }, { 20, 143, 204 }, { 3, 96, 154 },
333 { 1, 68, 112 }, { 1, 42, 69 }, { 1, 19, 32 },
337 { 212, 35, 215 }, { 113, 47, 169 }, { 29, 48, 105 },
339 { 74, 129, 203 }, { 106, 120, 203 }, { 49, 107, 178 },
340 { 19, 84, 144 }, { 4, 50, 84 }, { 1, 15, 25 },
342 { 71, 172, 217 }, { 44, 141, 209 }, { 15, 102, 173 },
343 { 6, 76, 133 }, { 2, 51, 89 }, { 1, 24, 42 },
345 { 64, 185, 231 }, { 31, 148, 216 }, { 8, 103, 175 },
346 { 3, 74, 131 }, { 1, 46, 81 }, { 1, 18, 30 },
348 { 65, 196, 235 }, { 25, 157, 221 }, { 5, 105, 174 },
349 { 1, 67, 120 }, { 1, 38, 69 }, { 1, 15, 30 },
351 { 65, 204, 238 }, { 30, 156, 224 }, { 7, 107, 177 },
352 { 2, 70, 124 }, { 1, 42, 73 }, { 1, 18, 34 },
356 { 225, 86, 251 }, { 144, 104, 235 }, { 42, 99, 181 },
358 { 85, 175, 239 }, { 112, 165, 229 }, { 29, 136, 200 },
359 { 12, 103, 162 }, { 6, 77, 123 }, { 2, 53, 84 },
361 { 75, 183, 239 }, { 30, 155, 221 }, { 3, 106, 171 },
362 { 1, 74, 128 }, { 1, 44, 76 }, { 1, 17, 28 },
364 { 73, 185, 240 }, { 27, 159, 222 }, { 2, 107, 172 },
365 { 1, 75, 127 }, { 1, 42, 73 }, { 1, 17, 29 },
367 { 62, 190, 238 }, { 21, 159, 222 }, { 2, 107, 172 },
368 { 1, 72, 122 }, { 1, 40, 71 }, { 1, 18, 32 },
370 { 61, 199, 240 }, { 27, 161, 226 }, { 4, 113, 180 },
371 { 1, 76, 129 }, { 1, 46, 80 }, { 1, 23, 41 }
374 vp9_prob default_coef_probs_16x16[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
377 { 7, 27, 153 }, { 5, 30, 95 }, { 1, 16, 30 },
379 { 50, 75, 127 }, { 57, 75, 124 }, { 27, 67, 108 },
380 { 10, 54, 86 }, { 1, 33, 52 }, { 1, 12, 18 },
382 { 43, 125, 151 }, { 26, 108, 148 }, { 7, 83, 122 },
383 { 2, 59, 89 }, { 1, 38, 60 }, { 1, 17, 27 },
385 { 23, 144, 163 }, { 13, 112, 154 }, { 2, 75, 117 },
386 { 1, 50, 81 }, { 1, 31, 51 }, { 1, 14, 23 },
388 { 18, 162, 185 }, { 6, 123, 171 }, { 1, 78, 125 },
389 { 1, 51, 86 }, { 1, 31, 54 }, { 1, 14, 23 },
391 { 15, 199, 227 }, { 3, 150, 204 }, { 1, 91, 146 },
392 { 1, 55, 95 }, { 1, 30, 53 }, { 1, 11, 20 },
396 { 19, 55, 240 }, { 19, 59, 196 }, { 3, 52, 105 },
398 { 41, 166, 207 }, { 104, 153, 199 }, { 31, 123, 181 },
399 { 14, 101, 152 }, { 5, 72, 106 }, { 1, 36, 52 },
401 { 35, 176, 211 }, { 12, 131, 190 }, { 2, 88, 144 },
402 { 1, 60, 101 }, { 1, 36, 60 }, { 1, 16, 28 },
404 { 28, 183, 213 }, { 8, 134, 191 }, { 1, 86, 142 },
405 { 1, 56, 96 }, { 1, 30, 53 }, { 1, 12, 20 },
407 { 20, 190, 215 }, { 4, 135, 192 }, { 1, 84, 139 },
408 { 1, 53, 91 }, { 1, 28, 49 }, { 1, 11, 20 },
410 { 13, 196, 216 }, { 2, 137, 192 }, { 1, 86, 143 },
411 { 1, 57, 99 }, { 1, 32, 56 }, { 1, 13, 24 },
415 { 211, 29, 217 }, { 96, 47, 156 }, { 22, 43, 87 },
417 { 78, 120, 193 }, { 111, 116, 186 }, { 46, 102, 164 },
418 { 15, 80, 128 }, { 2, 49, 76 }, { 1, 18, 28 },
420 { 71, 161, 203 }, { 42, 132, 192 }, { 10, 98, 150 },
421 { 3, 69, 109 }, { 1, 44, 70 }, { 1, 18, 29 },
423 { 57, 186, 211 }, { 30, 140, 196 }, { 4, 93, 146 },
424 { 1, 62, 102 }, { 1, 38, 65 }, { 1, 16, 27 },
426 { 47, 199, 217 }, { 14, 145, 196 }, { 1, 88, 142 },
427 { 1, 57, 98 }, { 1, 36, 62 }, { 1, 15, 26 },
429 { 26, 219, 229 }, { 5, 155, 207 }, { 1, 94, 151 },
430 { 1, 60, 104 }, { 1, 36, 62 }, { 1, 16, 28 },
434 { 233, 29, 248 }, { 146, 47, 220 }, { 43, 52, 140 },
436 { 100, 163, 232 }, { 179, 161, 222 }, { 63, 142, 204 },
437 { 37, 113, 174 }, { 26, 89, 137 }, { 18, 68, 97 },
439 { 85, 181, 230 }, { 32, 146, 209 }, { 7, 100, 164 },
440 { 3, 71, 121 }, { 1, 45, 77 }, { 1, 18, 30 },
442 { 65, 187, 230 }, { 20, 148, 207 }, { 2, 97, 159 },
443 { 1, 68, 116 }, { 1, 40, 70 }, { 1, 14, 29 },
445 { 40, 194, 227 }, { 8, 147, 204 }, { 1, 94, 155 },
446 { 1, 65, 112 }, { 1, 39, 66 }, { 1, 14, 26 },
448 { 16, 208, 228 }, { 3, 151, 207 }, { 1, 98, 160 },
449 { 1, 67, 117 }, { 1, 41, 74 }, { 1, 17, 31 }
452 vp9_prob default_coef_probs_32x32[COEFF_PROB_SIZE][COEFF_PROB_NUM] = {
455 { 17, 38, 140 }, { 7, 34, 80 }, { 1, 17, 29 },
457 { 37, 75, 128 }, { 41, 76, 128 }, { 26, 66, 116 },
458 { 12, 52, 94 }, { 2, 32, 55 }, { 1, 10, 16 },
460 { 50, 127, 154 }, { 37, 109, 152 }, { 16, 82, 121 },
461 { 5, 59, 85 }, { 1, 35, 54 }, { 1, 13, 20 },
463 { 40, 142, 167 }, { 17, 110, 157 }, { 2, 71, 112 },
464 { 1, 44, 72 }, { 1, 27, 45 }, { 1, 11, 17 },
466 { 30, 175, 188 }, { 9, 124, 169 }, { 1, 74, 116 },
467 { 1, 48, 78 }, { 1, 30, 49 }, { 1, 11, 18 },
469 { 10, 222, 223 }, { 2, 150, 194 }, { 1, 83, 128 },
470 { 1, 48, 79 }, { 1, 27, 45 }, { 1, 11, 17 },
474 { 36, 41, 235 }, { 29, 36, 193 }, { 10, 27, 111 },
476 { 85, 165, 222 }, { 177, 162, 215 }, { 110, 135, 195 },
477 { 57, 113, 168 }, { 23, 83, 120 }, { 10, 49, 61 },
479 { 85, 190, 223 }, { 36, 139, 200 }, { 5, 90, 146 },
480 { 1, 60, 103 }, { 1, 38, 65 }, { 1, 18, 30 },
482 { 72, 202, 223 }, { 23, 141, 199 }, { 2, 86, 140 },
483 { 1, 56, 97 }, { 1, 36, 61 }, { 1, 16, 27 },
485 { 55, 218, 225 }, { 13, 145, 200 }, { 1, 86, 141 },
486 { 1, 57, 99 }, { 1, 35, 61 }, { 1, 13, 22 },
488 { 15, 235, 212 }, { 1, 132, 184 }, { 1, 84, 139 },
489 { 1, 57, 97 }, { 1, 34, 56 }, { 1, 14, 23 },
493 { 181, 21, 201 }, { 61, 37, 123 }, { 10, 38, 71 },
495 { 47, 106, 172 }, { 95, 104, 173 }, { 42, 93, 159 },
496 { 18, 77, 131 }, { 4, 50, 81 }, { 1, 17, 23 },
498 { 62, 147, 199 }, { 44, 130, 189 }, { 28, 102, 154 },
499 { 18, 75, 115 }, { 2, 44, 65 }, { 1, 12, 19 },
501 { 55, 153, 210 }, { 24, 130, 194 }, { 3, 93, 146 },
502 { 1, 61, 97 }, { 1, 31, 50 }, { 1, 10, 16 },
504 { 49, 186, 223 }, { 17, 148, 204 }, { 1, 96, 142 },
505 { 1, 53, 83 }, { 1, 26, 44 }, { 1, 11, 17 },
507 { 13, 217, 212 }, { 2, 136, 180 }, { 1, 78, 124 },
508 { 1, 50, 83 }, { 1, 29, 49 }, { 1, 14, 23 },
512 { 197, 13, 247 }, { 82, 17, 222 }, { 25, 17, 162 },
514 { 126, 186, 247 }, { 234, 191, 243 }, { 176, 177, 234 },
515 { 104, 158, 220 }, { 66, 128, 186 }, { 55, 90, 137 },
517 { 111, 197, 242 }, { 46, 158, 219 }, { 9, 104, 171 },
518 { 2, 65, 125 }, { 1, 44, 80 }, { 1, 17, 91 },
520 { 104, 208, 245 }, { 39, 168, 224 }, { 3, 109, 162 },
521 { 1, 79, 124 }, { 1, 50, 102 }, { 1, 43, 102 },
523 { 84, 220, 246 }, { 31, 177, 231 }, { 2, 115, 180 },
524 { 1, 79, 134 }, { 1, 55, 77 }, { 1, 60, 79 },
526 { 43, 243, 240 }, { 8, 180, 217 }, { 1, 115, 166 },
527 { 1, 84, 121 }, { 1, 51, 67 }, { 1, 16, 6 }
531 #define FC_INTRA_OFFSET 0
532 #define FC_INTRA_SIZE 1664
534 #define FC_INTER_OFFSET 1664
535 #define FC_INTER_SIZE 384
537 #define FC_SKIP_OFFSET 1664
538 #define FC_SKIP_SIZE 3
540 void intel_init_default_vp9_probs(FRAME_CONTEXT *frame_context)
545 frame_context->tx_probs = default_tx_probs;
547 memcpy(frame_context->coeff_probs4x4, default_coef_probs_4x4,
548 sizeof(default_coef_probs_4x4));
549 memcpy(frame_context->coeff_probs8x8, default_coef_probs_8x8,
550 sizeof(default_coef_probs_8x8));
551 memcpy(frame_context->coeff_probs16x16, default_coef_probs_16x16,
552 sizeof(default_coef_probs_16x16));
553 memcpy(frame_context->coeff_probs32x32, default_coef_probs_32x32,
554 sizeof(default_coef_probs_16x16));
556 memcpy(frame_context->skip_probs, default_skip_probs,
557 sizeof(default_skip_probs));
558 memcpy(frame_context->inter_mode_probs, default_inter_mode_probs,
559 sizeof(default_inter_mode_probs));
560 memcpy(frame_context->switchable_interp_prob,
561 default_switchable_interp_prob,
562 sizeof(default_switchable_interp_prob));
563 memcpy(frame_context->intra_inter_prob, default_intra_inter_p,
564 sizeof(default_intra_inter_p));
565 memcpy(frame_context->comp_inter_prob, default_comp_inter_p,
566 sizeof(default_comp_inter_p));
567 memcpy(frame_context->single_ref_prob, default_single_ref_p,
568 sizeof(default_single_ref_p));
569 memcpy(frame_context->comp_ref_prob, default_comp_ref_p,
570 sizeof(default_comp_ref_p));
571 memcpy(frame_context->y_mode_prob, default_if_y_probs,
572 sizeof(default_if_y_probs));
573 memcpy(frame_context->partition_prob, default_partition_probs,
574 sizeof(default_partition_probs));
575 frame_context->nmvc = default_nmv_context;
577 memcpy(frame_context->uv_mode_prob, default_if_uv_probs,
578 sizeof(default_if_uv_probs));
579 memcpy(frame_context->seg_tree_probs, default_seg_tree_probs,
580 sizeof(default_seg_tree_probs));
581 memcpy(frame_context->seg_pred_probs, default_seg_pred_probs,
582 sizeof(default_seg_pred_probs));
587 void intel_vp9_copy_frame_context(FRAME_CONTEXT *dst,
591 unsigned char *fc_dst, *fc_src;
596 fc_dst = (unsigned char *)dst;
597 fc_src = (unsigned char *)src;
598 /* update the prob related with tx_mode/tx_coeff */
599 memcpy(fc_dst + FC_INTRA_OFFSET, fc_src + FC_INTRA_OFFSET, FC_INTRA_SIZE);
602 /* update the prob related with inter-frame */
603 memcpy(fc_dst + FC_INTER_OFFSET, fc_src + FC_INTER_OFFSET, FC_INTER_SIZE);
605 memcpy(fc_dst + FC_SKIP_OFFSET, fc_src + FC_SKIP_OFFSET, FC_SKIP_SIZE);
609 void intel_update_intra_frame_context(FRAME_CONTEXT *frame_context)
614 memcpy(frame_context->partition_prob, vp9_kf_partition_probs,
615 sizeof(vp9_kf_partition_probs));
617 memcpy(frame_context->uv_mode_prob, vp9_kf_uv_mode_prob,
618 sizeof(vp9_kf_uv_mode_prob));
622 struct vp9_write_bit_buffer {
628 void vp9_wb_write_bit(struct vp9_write_bit_buffer *wb, int bit)
630 const int off = wb->bit_offset;
631 const int p = off / 8;
632 const int q = 7 - off % 8;
634 wb->bit_buffer[p] = bit << q;
636 wb->bit_buffer[p] &= ~(1 << q);
637 wb->bit_buffer[p] |= bit << q;
639 wb->bit_offset = off + 1;
643 void vp9_wb_write_literal(struct vp9_write_bit_buffer *wb, int data, int bits)
646 for (bit = bits - 1; bit >= 0; bit--)
647 vp9_wb_write_bit(wb, (data >> bit) & 1);
651 void write_bitdepth_colorspace_sampling(int codec_profile,
652 struct vp9_write_bit_buffer *wb)
654 int profile = VAProfileVP9Profile0;
655 profile = profile + 0;
657 if (codec_profile >= (VAProfileVP9Profile0 + 2)) {
658 /* the bit-depth will be added for VP9Profile2/3 */
659 /* this will be added later */
662 /* Add the default color-space */
663 vp9_wb_write_literal(wb, 0, 3);
664 vp9_wb_write_bit(wb, 0); // 0: [16, 235] (i.e. xvYCC), 1: [0, 255]
666 /* the sampling_x/y will be added for VP9Profile1/2/3 later */
669 #define MAX_TILE_WIDTH_B64 64
670 #define MIN_TILE_WIDTH_B64 4
672 static int get_min_log2_tile_cols(const int sb_cols) {
675 while ((MAX_TILE_WIDTH_B64 << min_log2) < sb_cols)
681 static int get_max_log2_tile_cols(const int sb_cols) {
684 while ((sb_cols >> max_log2) >= MIN_TILE_WIDTH_B64)
691 bool intel_write_uncompressed_header(struct encode_state *encode_state,
695 vp9_header_bitoffset *header_bitoffset)
697 #define VP9_SYNC_CODE_0 0x49
698 #define VP9_SYNC_CODE_1 0x83
699 #define VP9_SYNC_CODE_2 0x42
701 #define VP9_FRAME_MARKER 0x2
703 #define REFS_PER_FRAME 3
705 #define REF_FRAMES_LOG2 3
706 #define REF_FRAMES (1 << REF_FRAMES_LOG2)
708 #define VP9_KEY_FRAME 0
710 VAEncPictureParameterBufferVP9 *pic_param;
711 VAEncMiscParameterTypeVP9PerSegmantParam *seg_param = NULL;
712 struct vp9_write_bit_buffer *wb, vp9_wb;
714 if (!encode_state->pic_param_ext || !encode_state->pic_param_ext->buffer)
717 if (!header_data || !header_bitoffset || !header_length)
720 memset(header_bitoffset, 0, sizeof(vp9_header_bitoffset));
722 pic_param = (VAEncPictureParameterBufferVP9 *)encode_state->pic_param_ext->buffer;
724 if (encode_state->q_matrix)
725 seg_param = (VAEncMiscParameterTypeVP9PerSegmantParam *) encode_state->q_matrix->buffer;
727 vp9_wb.bit_buffer = (uint8_t *)header_data;
728 vp9_wb.bit_offset = 0;
730 vp9_wb_write_literal(wb, VP9_FRAME_MARKER, 2);
732 if (codec_profile == VAProfileVP9Profile0) {
733 vp9_wb_write_literal(wb, 0, 2);
735 /* Other VP9Profile1/2/3 will be added later */
738 vp9_wb_write_bit(wb, 0); // show_existing_frame
739 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.frame_type);
740 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.show_frame);
741 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.error_resilient_mode);
743 if (pic_param->pic_flags.bits.frame_type == VP9_KEY_FRAME) {
744 vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
745 vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
746 vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);
748 write_bitdepth_colorspace_sampling(codec_profile, wb);
750 /* write the encoded frame size */
751 vp9_wb_write_literal(wb, pic_param->frame_width_dst - 1, 16);
752 vp9_wb_write_literal(wb, pic_param->frame_height_dst - 1, 16);
753 /* write display size */
754 if ((pic_param->frame_width_dst != pic_param->frame_width_src) ||
755 (pic_param->frame_height_dst != pic_param->frame_height_src)) {
756 vp9_wb_write_bit(wb, 1);
757 vp9_wb_write_literal(wb, pic_param->frame_width_src - 1, 16);
758 vp9_wb_write_literal(wb, pic_param->frame_height_src - 1, 16);
760 vp9_wb_write_bit(wb, 0);
762 /* for the non-Key frame */
763 if (!pic_param->pic_flags.bits.show_frame)
764 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.intra_only);
766 if (!pic_param->pic_flags.bits.error_resilient_mode)
767 vp9_wb_write_literal(wb, pic_param->pic_flags.bits.reset_frame_context, 2);
769 if (pic_param->pic_flags.bits.intra_only) {
770 vp9_wb_write_literal(wb, VP9_SYNC_CODE_0, 8);
771 vp9_wb_write_literal(wb, VP9_SYNC_CODE_1, 8);
772 vp9_wb_write_literal(wb, VP9_SYNC_CODE_2, 8);
774 /* Add the bit_depth for VP9Profile1/2/3 */
775 /* write the refreshed_frame_flags */
776 vp9_wb_write_literal(wb, pic_param->refresh_frame_flags, REF_FRAMES);
777 /* write the encoded frame size */
778 vp9_wb_write_literal(wb, pic_param->frame_width_dst - 1, 16);
779 vp9_wb_write_literal(wb, pic_param->frame_height_dst - 1, 16);
780 /* write display size */
781 if ((pic_param->frame_width_dst != pic_param->frame_width_src) ||
782 (pic_param->frame_height_dst != pic_param->frame_height_src)) {
783 vp9_wb_write_bit(wb, 1);
784 vp9_wb_write_literal(wb, pic_param->frame_width_src - 1, 16);
785 vp9_wb_write_literal(wb, pic_param->frame_height_src - 1, 16);
787 vp9_wb_write_bit(wb, 0);
790 /* The refresh_frame_map is for the next frame so that it can select Last/Godlen/Alt ref_index */
792 if ((pic_param->ref_flags.bits.ref_frame_ctrl_l0) & (1 << 0))
793 refresh_flags = 1 << pic_param->ref_flags.bits.ref_last_idx;
794 if ((pic_param->ref_flags.bits.ref_frame_ctrl_l0) & (1 << 0))
795 refresh_flags = 1 << pic_param->ref_flags.bits.ref_last_idx;
796 if ((pic_param->ref_flags.bits.ref_frame_ctrl_l0) & (1 << 0))
797 refresh_flags = 1 << pic_param->ref_flags.bits.ref_last_idx;
799 vp9_wb_write_literal(wb, pic_param->refresh_frame_flags, REF_FRAMES);
801 vp9_wb_write_literal(wb, pic_param->ref_flags.bits.ref_last_idx, REF_FRAMES_LOG2);
802 vp9_wb_write_bit(wb, pic_param->ref_flags.bits.ref_last_sign_bias);
803 vp9_wb_write_literal(wb, pic_param->ref_flags.bits.ref_gf_idx, REF_FRAMES_LOG2);
804 vp9_wb_write_bit(wb, pic_param->ref_flags.bits.ref_gf_sign_bias);
805 vp9_wb_write_literal(wb, pic_param->ref_flags.bits.ref_arf_idx, REF_FRAMES_LOG2);
806 vp9_wb_write_bit(wb, pic_param->ref_flags.bits.ref_arf_sign_bias);
808 /* write three bits with zero so that it can parse width/height directly */
809 vp9_wb_write_literal(wb, 0, 3);
810 vp9_wb_write_literal(wb, pic_param->frame_width_dst - 1, 16);
811 vp9_wb_write_literal(wb, pic_param->frame_height_dst - 1, 16);
813 /* write display size */
814 if ((pic_param->frame_width_dst != pic_param->frame_width_src) ||
815 (pic_param->frame_height_dst != pic_param->frame_height_src)) {
817 vp9_wb_write_bit(wb, 1);
818 vp9_wb_write_literal(wb, pic_param->frame_width_src - 1, 16);
819 vp9_wb_write_literal(wb, pic_param->frame_height_src - 1, 16);
821 vp9_wb_write_bit(wb, 0);
823 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.allow_high_precision_mv);
825 #define SWITCHABLE_FILTER 4
826 #define FILTER_MASK 3
828 if (pic_param->pic_flags.bits.mcomp_filter_type == SWITCHABLE_FILTER)
829 vp9_wb_write_bit(wb, 1);
831 const int filter_to_literal[4] = { 1, 0, 2, 3 };
832 uint8_t filter_flag = pic_param->pic_flags.bits.mcomp_filter_type;
833 filter_flag = filter_flag & FILTER_MASK;
834 vp9_wb_write_bit(wb, 0);
835 vp9_wb_write_literal(wb, filter_to_literal[filter_flag], 2);
840 /* write refresh_frame_context/paralle frame_decoding */
841 if (!pic_param->pic_flags.bits.error_resilient_mode) {
842 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.refresh_frame_context);
843 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.frame_parallel_decoding_mode);
846 vp9_wb_write_literal(wb, pic_param->pic_flags.bits.frame_context_idx, 2);
848 /* write loop filter */
849 header_bitoffset->bit_offset_lf_level = wb->bit_offset;
850 vp9_wb_write_literal(wb, pic_param->filter_level, 6);
851 vp9_wb_write_literal(wb, pic_param->sharpness_level, 3);
856 vp9_wb_write_bit(wb, 1);
857 vp9_wb_write_bit(wb, 1);
858 header_bitoffset->bit_offset_ref_lf_delta = wb->bit_offset;
859 for (i = 0; i < 4; i++) {
861 * This check is skipped to prepare the bit_offset_lf_ref
862 if (pic_param->ref_lf_delta[i] == 0) {
863 vp9_wb_write_bit(wb, 0);
868 vp9_wb_write_bit(wb, 1);
869 mode_flag = pic_param->ref_lf_delta[i];
871 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
872 vp9_wb_write_bit(wb, 0);
874 mode_flag = -mode_flag;
875 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
876 vp9_wb_write_bit(wb, 1);
880 header_bitoffset->bit_offset_mode_lf_delta = wb->bit_offset;
881 for (i = 0; i < 2; i++) {
883 * This check is skipped to prepare the bit_offset_lf_ref
884 if (pic_param->mode_lf_delta[i] == 0) {
885 vp9_wb_write_bit(wb, 0);
889 vp9_wb_write_bit(wb, 1);
890 mode_flag = pic_param->mode_lf_delta[i];
892 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
893 vp9_wb_write_bit(wb, 0);
895 mode_flag = -mode_flag;
896 vp9_wb_write_literal(wb, mode_flag & (0x3F), 6);
897 vp9_wb_write_bit(wb, 1);
902 /* write basic quantizer */
903 header_bitoffset->bit_offset_qindex = wb->bit_offset;
904 vp9_wb_write_literal(wb, pic_param->luma_ac_qindex, 8);
905 if (pic_param->luma_dc_qindex_delta) {
906 int delta_q = pic_param->luma_dc_qindex_delta;
907 vp9_wb_write_bit(wb, 1);
908 vp9_wb_write_literal(wb, abs(delta_q), 4);
909 vp9_wb_write_bit(wb, delta_q < 0);
911 vp9_wb_write_bit(wb, 0);
913 if (pic_param->chroma_dc_qindex_delta) {
914 int delta_q = pic_param->chroma_dc_qindex_delta;
915 vp9_wb_write_bit(wb, 1);
916 vp9_wb_write_literal(wb, abs(delta_q), 4);
917 vp9_wb_write_bit(wb, delta_q < 0);
919 vp9_wb_write_bit(wb, 0);
921 if (pic_param->chroma_ac_qindex_delta) {
922 int delta_q = pic_param->chroma_ac_qindex_delta;
923 vp9_wb_write_bit(wb, 1);
924 vp9_wb_write_literal(wb, abs(delta_q), 4);
925 vp9_wb_write_bit(wb, delta_q < 0);
927 vp9_wb_write_bit(wb, 0);
929 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.segmentation_enabled);
930 if (pic_param->pic_flags.bits.segmentation_enabled) {
933 #define VP9_MAX_PROB 255
934 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.segmentation_update_map);
935 if (pic_param->pic_flags.bits.segmentation_update_map) {
937 header_bitoffset->bit_offset_segmentation = wb->bit_offset;
938 /* write the seg_tree_probs */
939 /* segment_tree_probs/segment_pred_probs are not passed.
940 * So the hard-coded prob is writen
942 for (i = 0; i < 7; i++) {
943 vp9_wb_write_bit(wb, 1);
944 vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
947 vp9_wb_write_bit(wb, pic_param->pic_flags.bits.segmentation_temporal_update);
948 if (pic_param->pic_flags.bits.segmentation_temporal_update) {
949 for (i = 0; i < 3; i++) {
950 vp9_wb_write_bit(wb, 1);
951 vp9_wb_write_literal(wb, VP9_MAX_PROB, 8);
956 /* write the segment_data info */
957 if (seg_param == NULL) {
958 vp9_wb_write_bit(wb, 0);
960 VAEncSegParamVP9 *seg_data;
964 vp9_wb_write_bit(wb, 1);
965 /* abs_delta should be zero */
966 vp9_wb_write_bit(wb, 0);
967 for (i = 0; i < 8; i++) {
968 seg_data = &seg_param->seg_data[i];
970 /* The segment qindex delta */
971 /* This check is skipped */
972 /* if (seg_data->segment_qindex_delta != 0) */
974 vp9_wb_write_bit(wb, 1);
975 seg_delta = seg_data->segment_qindex_delta;
976 vp9_wb_write_literal(wb, abs(seg_delta), 8);
977 vp9_wb_write_bit(wb, seg_delta < 0);
979 vp9_wb_write_bit(wb, 0);
981 /* The segment lf delta */
982 /* if (seg_data->segment_lf_level_delta != 0) */
984 vp9_wb_write_bit(wb, 1);
985 seg_delta = seg_data->segment_lf_level_delta;
986 vp9_wb_write_literal(wb, abs(seg_delta), 6);
987 vp9_wb_write_bit(wb, seg_delta < 0);
989 vp9_wb_write_bit(wb, 0);
991 /* segment reference flag */
992 vp9_wb_write_bit(wb, seg_data->seg_flags.bits.segment_reference_enabled);
993 if (seg_data->seg_flags.bits.segment_reference_enabled)
995 vp9_wb_write_literal(wb, seg_data->seg_flags.bits.segment_reference, 2);
998 /* segment skip flag */
999 vp9_wb_write_bit(wb, seg_data->seg_flags.bits.segment_reference_skipped);
1004 /* write tile info */
1006 int sb_cols = (pic_param->frame_width_dst + 63) / 64;
1007 int min_log2_tile_cols, max_log2_tile_cols;
1010 /* write tile column info */
1011 min_log2_tile_cols = get_min_log2_tile_cols(sb_cols);
1012 max_log2_tile_cols = get_max_log2_tile_cols(sb_cols);
1014 col_data = pic_param->log2_tile_columns - min_log2_tile_cols;
1016 vp9_wb_write_bit(wb, 1);
1018 if (pic_param->log2_tile_columns < max_log2_tile_cols)
1019 vp9_wb_write_bit(wb, 0);
1021 /* write tile row info */
1022 vp9_wb_write_bit(wb, pic_param->log2_tile_rows);
1023 if (pic_param->log2_tile_rows)
1024 vp9_wb_write_bit(wb, (pic_param->log2_tile_rows != 1));
1027 /* get the bit_offset of the first partition size */
1028 header_bitoffset->bit_offset_first_partition_size = wb->bit_offset;
1030 /* reserve the space for writing the first partitions ize */
1031 vp9_wb_write_literal(wb, 0, 16);
1033 *header_length = (wb->bit_offset + 7) / 8;
1038 const unsigned short vp9_quant_dc[256] = {
1039 4, 8, 8, 9, 10, 11, 12, 12,
1040 13, 14, 15, 16, 17, 18, 19, 19,
1041 20, 21, 22, 23, 24, 25, 26, 26,
1042 27, 28, 29, 30, 31, 32, 32, 33,
1043 34, 35, 36, 37, 38, 38, 39, 40,
1044 41, 42, 43, 43, 44, 45, 46, 47,
1045 48, 48, 49, 50, 51, 52, 53, 53,
1046 54, 55, 56, 57, 57, 58, 59, 60,
1047 61, 62, 62, 63, 64, 65, 66, 66,
1048 67, 68, 69, 70, 70, 71, 72, 73,
1049 74, 74, 75, 76, 77, 78, 78, 79,
1050 80, 81, 81, 82, 83, 84, 85, 85,
1051 87, 88, 90, 92, 93, 95, 96, 98,
1052 99, 101, 102, 104, 105, 107, 108, 110,
1053 111, 113, 114, 116, 117, 118, 120, 121,
1054 123, 125, 127, 129, 131, 134, 136, 138,
1055 140, 142, 144, 146, 148, 150, 152, 154,
1056 156, 158, 161, 164, 166, 169, 172, 174,
1057 177, 180, 182, 185, 187, 190, 192, 195,
1058 199, 202, 205, 208, 211, 214, 217, 220,
1059 223, 226, 230, 233, 237, 240, 243, 247,
1060 250, 253, 257, 261, 265, 269, 272, 276,
1061 280, 284, 288, 292, 296, 300, 304, 309,
1062 313, 317, 322, 326, 330, 335, 340, 344,
1063 349, 354, 359, 364, 369, 374, 379, 384,
1064 389, 395, 400, 406, 411, 417, 423, 429,
1065 435, 441, 447, 454, 461, 467, 475, 482,
1066 489, 497, 505, 513, 522, 530, 539, 549,
1067 559, 569, 579, 590, 602, 614, 626, 640,
1068 654, 668, 684, 700, 717, 736, 755, 775,
1069 796, 819, 843, 869, 896, 925, 955, 988,
1070 1022, 1058, 1098, 1139, 1184, 1232, 1282, 1336,
1073 const unsigned short vp9_quant_ac[256] = {
1074 4, 8, 9, 10, 11, 12, 13, 14,
1075 15, 16, 17, 18, 19, 20, 21, 22,
1076 23, 24, 25, 26, 27, 28, 29, 30,
1077 31, 32, 33, 34, 35, 36, 37, 38,
1078 39, 40, 41, 42, 43, 44, 45, 46,
1079 47, 48, 49, 50, 51, 52, 53, 54,
1080 55, 56, 57, 58, 59, 60, 61, 62,
1081 63, 64, 65, 66, 67, 68, 69, 70,
1082 71, 72, 73, 74, 75, 76, 77, 78,
1083 79, 80, 81, 82, 83, 84, 85, 86,
1084 87, 88, 89, 90, 91, 92, 93, 94,
1085 95, 96, 97, 98, 99, 100, 101, 102,
1086 104, 106, 108, 110, 112, 114, 116, 118,
1087 120, 122, 124, 126, 128, 130, 132, 134,
1088 136, 138, 140, 142, 144, 146, 148, 150,
1089 152, 155, 158, 161, 164, 167, 170, 173,
1090 176, 179, 182, 185, 188, 191, 194, 197,
1091 200, 203, 207, 211, 215, 219, 223, 227,
1092 231, 235, 239, 243, 247, 251, 255, 260,
1093 265, 270, 275, 280, 285, 290, 295, 300,
1094 305, 311, 317, 323, 329, 335, 341, 347,
1095 353, 359, 366, 373, 380, 387, 394, 401,
1096 408, 416, 424, 432, 440, 448, 456, 465,
1097 474, 483, 492, 501, 510, 520, 530, 540,
1098 550, 560, 571, 582, 593, 604, 615, 627,
1099 639, 651, 663, 676, 689, 702, 715, 729,
1100 743, 757, 771, 786, 801, 816, 832, 848,
1101 864, 881, 898, 915, 933, 951, 969, 988,
1102 1007, 1026, 1046, 1066, 1087, 1108, 1129, 1151,
1103 1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343,
1104 1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567,
1105 1597, 1628, 1660, 1692, 1725, 1759, 1793, 1828,