| 1 | use nihav_core::io::byteio::*; |
| 2 | use nihav_core::codecs::{EncoderResult, EncoderError}; |
| 3 | use nihav_codec_support::codecs::MV; |
| 4 | use super::super::vpcommon::*; |
| 5 | use super::super::vp6data::*; |
| 6 | use super::models::*; |
| 7 | |
| 8 | struct EncSeq { |
| 9 | bit: bool, |
| 10 | idx: u8, |
| 11 | } |
| 12 | |
| 13 | pub struct TokenSeq<T: PartialEq> { |
| 14 | val: T, |
| 15 | seq: &'static [EncSeq], |
| 16 | } |
| 17 | |
| 18 | macro_rules! bit_entry { |
| 19 | (T; $idx:expr) => {EncSeq {bit: true, idx: $idx }}; |
| 20 | (F; $idx:expr) => {EncSeq {bit: false, idx: $idx }}; |
| 21 | } |
| 22 | |
| 23 | macro_rules! bit_seq { |
| 24 | ($val: expr; $( $bit:tt),* ; $( $idx:expr),* ) => { |
| 25 | TokenSeq { |
| 26 | val: $val, |
| 27 | seq: |
| 28 | &[ |
| 29 | $( |
| 30 | bit_entry!($bit; $idx), |
| 31 | )* |
| 32 | ] |
| 33 | } |
| 34 | }; |
| 35 | } |
| 36 | |
| 37 | pub const MODE_TREE: &[TokenSeq<VPMBType>] = &[ |
| 38 | bit_seq!(VPMBType::Intra; T, F, F; 0, 2, 5), |
| 39 | bit_seq!(VPMBType::InterFourMV; T, F, T; 0, 2, 5), |
| 40 | bit_seq!(VPMBType::InterNoMV; F, F, F; 0, 1, 3), |
| 41 | bit_seq!(VPMBType::InterMV; F, F, T; 0, 1, 3), |
| 42 | bit_seq!(VPMBType::InterNearest; F, T, F; 0, 1, 4), |
| 43 | bit_seq!(VPMBType::InterNear; F, T, T; 0, 1, 4), |
| 44 | bit_seq!(VPMBType::GoldenNoMV; T, T, F, F; 0, 2, 6, 7), |
| 45 | bit_seq!(VPMBType::GoldenMV; T, T, F, T; 0, 2, 6, 7), |
| 46 | bit_seq!(VPMBType::GoldenNearest; T, T, T, F; 0, 2, 6, 8), |
| 47 | bit_seq!(VPMBType::GoldenNear; T, T, T, T; 0, 2, 6, 8), |
| 48 | ]; |
| 49 | |
| 50 | const MODE_TREE_DIFF: &[TokenSeq<u8>] = &[ |
| 51 | bit_seq!(1; F, T; 0, 1), |
| 52 | bit_seq!(2; F, F; 0, 1), |
| 53 | bit_seq!(3; T, F, T; 0, 2, 3), |
| 54 | bit_seq!(4; T, F, F, T; 0, 2, 3, 4), |
| 55 | bit_seq!(5; T, F, F, F, T; 0, 2, 3, 4, 5), |
| 56 | bit_seq!(6; T, F, F, F, F; 0, 2, 3, 4, 5), |
| 57 | bit_seq!(7; T, T; 0, 2), |
| 58 | ]; |
| 59 | |
| 60 | const MODE_TREE_DIFF_PROBS: &[u8; 6] = &[171, 83, 199, 140, 125, 104]; |
| 61 | |
| 62 | const SHORT_MV_TREE: &[TokenSeq<u8>] = &[ |
| 63 | bit_seq!(0; F, F, F; 0, 1, 2), |
| 64 | bit_seq!(1; F, F, T; 0, 1, 2), |
| 65 | bit_seq!(2; F, T, F; 0, 1, 3), |
| 66 | bit_seq!(3; F, T, T; 0, 1, 3), |
| 67 | bit_seq!(4; T, F, F; 0, 4, 5), |
| 68 | bit_seq!(5; T, F, T; 0, 4, 5), |
| 69 | bit_seq!(6; T, T, F; 0, 4, 6), |
| 70 | bit_seq!(7; T, T, T; 0, 4, 6), |
| 71 | ]; |
| 72 | |
| 73 | const EOB: i8 = 42; |
| 74 | |
| 75 | const DC_TREE: &[TokenSeq<i8>] = &[ |
| 76 | bit_seq!( 0; F; 0), |
| 77 | bit_seq!( 1; T, F; 0, 2), |
| 78 | bit_seq!( 2; T, T, F, F; 0, 2, 3, 4), |
| 79 | bit_seq!( 3; T, T, F, T, F; 0, 2, 3, 4, 5), |
| 80 | bit_seq!( 4; T, T, F, T, T; 0, 2, 3, 4, 5), |
| 81 | bit_seq!( -1; T, T, T, F, F; 0, 2, 3, 6, 7), |
| 82 | bit_seq!( -2; T, T, T, F, T; 0, 2, 3, 6, 7), |
| 83 | bit_seq!( -3; T, T, T, T, F, F; 0, 2, 3, 6, 8, 9), |
| 84 | bit_seq!( -4; T, T, T, T, F, T; 0, 2, 3, 6, 8, 9), |
| 85 | bit_seq!( -5; T, T, T, T, T, F; 0, 2, 3, 6, 8, 10), |
| 86 | bit_seq!( -6; T, T, T, T, T, T; 0, 2, 3, 6, 8, 10), |
| 87 | ]; |
| 88 | |
| 89 | const NZ_COEF_TREE: &[TokenSeq<i8>] = &[ |
| 90 | bit_seq!( 1; F; 2), |
| 91 | bit_seq!( 2; T, F, F; 2, 3, 4), |
| 92 | bit_seq!( 3; T, F, T, F; 2, 3, 4, 5), |
| 93 | bit_seq!( 4; T, F, T, T; 2, 3, 4, 5), |
| 94 | bit_seq!( -1; T, T, F, F; 2, 3, 6, 7), |
| 95 | bit_seq!( -2; T, T, F, T; 2, 3, 6, 7), |
| 96 | bit_seq!( -3; T, T, T, F, F; 2, 3, 6, 8, 9), |
| 97 | bit_seq!( -4; T, T, T, F, T; 2, 3, 6, 8, 9), |
| 98 | bit_seq!( -5; T, T, T, T, F; 2, 3, 6, 8, 10), |
| 99 | bit_seq!( -6; T, T, T, T, T; 2, 3, 6, 8, 10), |
| 100 | ]; |
| 101 | |
| 102 | const COEF_TREE: &[TokenSeq<i8>] = &[ |
| 103 | bit_seq!( 0; F, T; 0, 1), |
| 104 | bit_seq!(EOB; F, F; 0, 1), |
| 105 | bit_seq!( 1; T, F; 0, 2), |
| 106 | bit_seq!( 2; T, T, F, F; 0, 2, 3, 4), |
| 107 | bit_seq!( 3; T, T, F, T, F; 0, 2, 3, 4, 5), |
| 108 | bit_seq!( 4; T, T, F, T, T; 0, 2, 3, 4, 5), |
| 109 | bit_seq!( -1; T, T, T, F, F; 0, 2, 3, 6, 7), |
| 110 | bit_seq!( -2; T, T, T, F, T; 0, 2, 3, 6, 7), |
| 111 | bit_seq!( -3; T, T, T, T, F, F; 0, 2, 3, 6, 8, 9), |
| 112 | bit_seq!( -4; T, T, T, T, F, T; 0, 2, 3, 6, 8, 9), |
| 113 | bit_seq!( -5; T, T, T, T, T, F; 0, 2, 3, 6, 8, 10), |
| 114 | bit_seq!( -6; T, T, T, T, T, T; 0, 2, 3, 6, 8, 10), |
| 115 | ]; |
| 116 | |
| 117 | fn coef_to_cat(coef: i16) -> i8 { |
| 118 | match coef.abs() { |
| 119 | 0 ..=4 => coef.abs() as i8, |
| 120 | 5 ..=6 => -1, |
| 121 | 7 ..=10 => -2, |
| 122 | 11..=18 => -3, |
| 123 | 19..=34 => -4, |
| 124 | 35..=66 => -5, |
| 125 | _ => -6, |
| 126 | } |
| 127 | } |
| 128 | |
| 129 | const ZERO_RUN_TREE: &[TokenSeq<u8>] = &[ |
| 130 | bit_seq!(1; F, F, F; 0, 1, 2), |
| 131 | bit_seq!(2; F, F, T; 0, 1, 2), |
| 132 | bit_seq!(3; F, T, F; 0, 1, 3), |
| 133 | bit_seq!(4; F, T, T; 0, 1, 3), |
| 134 | bit_seq!(5; T, F, F, F; 0, 4, 5, 6), |
| 135 | bit_seq!(6; T, F, F, T; 0, 4, 5, 6), |
| 136 | bit_seq!(7; T, F, T, F; 0, 4, 5, 7), |
| 137 | bit_seq!(8; T, F, T, T; 0, 4, 5, 7), |
| 138 | bit_seq!(9; T, T; 0, 4), |
| 139 | ]; |
| 140 | |
| 141 | pub struct BoolEncoder<'a, 'b> { |
| 142 | bw: &'a mut ByteWriter<'b>, |
| 143 | val: u32, |
| 144 | range: u32, |
| 145 | bits: u8, |
| 146 | saved: u8, |
| 147 | run: usize, |
| 148 | } |
| 149 | |
| 150 | impl<'a, 'b> BoolEncoder<'a, 'b> { |
| 151 | pub fn new(bw: &'a mut ByteWriter<'b>) -> Self { |
| 152 | Self { |
| 153 | bw, |
| 154 | val: 0, |
| 155 | range: 255, |
| 156 | bits: 0, |
| 157 | saved: 0, |
| 158 | run: 0, |
| 159 | } |
| 160 | } |
| 161 | pub fn put_bool(&mut self, bit: bool, prob: u8) -> EncoderResult<()> { |
| 162 | let split = 1 + (((self.range - 1) * u32::from(prob)) >> 8); |
| 163 | if bit { |
| 164 | self.range -= split; |
| 165 | self.val += split; |
| 166 | } else { |
| 167 | self.range = split; |
| 168 | } |
| 169 | |
| 170 | if self.range < 128 { |
| 171 | self.renorm()?; |
| 172 | } |
| 173 | Ok(()) |
| 174 | } |
| 175 | fn flush_run(&mut self, overflow: bool) -> EncoderResult<()> { |
| 176 | if self.run > 0 { |
| 177 | self.bw.write_byte(self.saved + (overflow as u8))?; |
| 178 | if !overflow { |
| 179 | for _ in 1..self.run { |
| 180 | self.bw.write_byte(0xFF)?; |
| 181 | } |
| 182 | } else { |
| 183 | for _ in 1..self.run { |
| 184 | self.bw.write_byte(0)?; |
| 185 | } |
| 186 | } |
| 187 | self.run = 0; |
| 188 | } |
| 189 | Ok(()) |
| 190 | } |
| 191 | fn renorm(&mut self) -> EncoderResult<()> { |
| 192 | let bits = (self.range.leading_zeros() & 7) as u8; |
| 193 | self.range <<= bits; |
| 194 | if self.bits + bits < 23 { |
| 195 | self.bits += bits; |
| 196 | self.val <<= bits; |
| 197 | } else { |
| 198 | for _ in 0..bits { |
| 199 | if (self.bits == 23) && ((self.val >> 31) != 0) { |
| 200 | self.flush_run(true)?; |
| 201 | } |
| 202 | self.val <<= 1; |
| 203 | self.bits += 1; |
| 204 | if self.bits == 24 { |
| 205 | let tbyte = (self.val >> 24) as u8; |
| 206 | let nbyte = (self.val >> 16) as u8; |
| 207 | if tbyte < 0xFF { |
| 208 | self.flush_run(false)?; |
| 209 | if nbyte < 0xFE { |
| 210 | self.bw.write_byte(tbyte)?; |
| 211 | } else { |
| 212 | self.saved = tbyte; |
| 213 | self.run = 1; |
| 214 | } |
| 215 | } else { |
| 216 | self.run += 1; |
| 217 | } |
| 218 | self.val &= 0xFFFFFF; |
| 219 | self.bits -= 8; |
| 220 | } |
| 221 | } |
| 222 | } |
| 223 | Ok(()) |
| 224 | } |
| 225 | pub fn flush(mut self) -> EncoderResult<()> { |
| 226 | self.flush_run(false)?; |
| 227 | self.val <<= 24 - self.bits; |
| 228 | self.bw.write_u32be(self.val)?; |
| 229 | Ok(()) |
| 230 | } |
| 231 | |
| 232 | pub fn put_bits(&mut self, val: u32, len: u8) -> EncoderResult<()> { |
| 233 | let mut mask = 1 << (len - 1); |
| 234 | while mask != 0 { |
| 235 | self.put_bool((val & mask) != 0, 128)?; |
| 236 | mask >>= 1; |
| 237 | } |
| 238 | Ok(()) |
| 239 | } |
| 240 | fn put_probability(&mut self, prob: u8) -> EncoderResult<()> { |
| 241 | self.put_bits(u32::from(prob >> 1), 7) |
| 242 | } |
| 243 | fn encode_probability(&mut self, new: u8, old: u8, prob: u8) -> EncoderResult<()> { |
| 244 | self.put_bool(new != old, prob)?; |
| 245 | if new != old { |
| 246 | self.put_probability(new)?; |
| 247 | } |
| 248 | Ok(()) |
| 249 | } |
| 250 | pub fn write_el<T: PartialEq>(&mut self, el: T, tree: &[TokenSeq<T>], probs: &[u8]) -> EncoderResult<()> { |
| 251 | for entry in tree.iter() { |
| 252 | if entry.val == el { |
| 253 | for seq in entry.seq.iter() { |
| 254 | self.put_bool(seq.bit, probs[seq.idx as usize])?; |
| 255 | } |
| 256 | return Ok(()); |
| 257 | } |
| 258 | } |
| 259 | Err(EncoderError::Bug) |
| 260 | } |
| 261 | fn write_cat(&mut self, cat: i8, tree: &[TokenSeq<i8>], tok_probs: &[u8], val_probs: &[u8; 11]) -> EncoderResult<()> { |
| 262 | for entry in tree.iter() { |
| 263 | if entry.val == cat { |
| 264 | for seq in entry.seq.iter() { |
| 265 | let prob = if seq.idx < 5 { |
| 266 | tok_probs[seq.idx as usize] |
| 267 | } else { |
| 268 | val_probs[seq.idx as usize] |
| 269 | }; |
| 270 | self.put_bool(seq.bit, prob)?; |
| 271 | } |
| 272 | return Ok(()); |
| 273 | } |
| 274 | } |
| 275 | Err(EncoderError::Bug) |
| 276 | } |
| 277 | fn write_large_coef(&mut self, val: i16, cat: usize) -> EncoderResult<()> { |
| 278 | let base = VP56_COEF_BASE[cat]; |
| 279 | let mut probs = VP56_COEF_ADD_PROBS[cat].iter(); |
| 280 | let add = val.abs() - base; |
| 281 | let mut mask = 1 << (VP6_COEF_ADD_BITS[cat] - 1); |
| 282 | while mask != 0 { |
| 283 | self.put_bool((add & mask) != 0, *probs.next().unwrap())?; |
| 284 | mask >>= 1; |
| 285 | } |
| 286 | self.put_bool(val < 0, 128)?; |
| 287 | |
| 288 | Ok(()) |
| 289 | } |
| 290 | fn write_dc(&mut self, val: i16, tok_probs: &[u8; 5], val_probs: &[u8; 11]) -> EncoderResult<()> { |
| 291 | let cat = coef_to_cat(val); |
| 292 | self.write_cat(cat, DC_TREE, tok_probs, val_probs)?; |
| 293 | if cat < 0 { |
| 294 | self.write_large_coef(val, (-cat - 1) as usize)?; |
| 295 | } else if val != 0 { |
| 296 | self.put_bool(val < 0, 128)?; |
| 297 | } |
| 298 | Ok(()) |
| 299 | } |
| 300 | fn write_ac(&mut self, val: i16, tree: &[TokenSeq<i8>], probs: &[u8; 11]) -> EncoderResult<()> { |
| 301 | let cat = coef_to_cat(val); |
| 302 | self.write_cat(cat, tree, probs, probs)?; |
| 303 | if cat < 0 { |
| 304 | self.write_large_coef(val, (-cat - 1) as usize)?; |
| 305 | } else if val != 0 { |
| 306 | self.put_bool(val < 0, 128)?; |
| 307 | } |
| 308 | Ok(()) |
| 309 | } |
| 310 | fn write_zero_run(&mut self, val: usize, probs: &[u8; 14]) -> EncoderResult<()> { |
| 311 | self.write_el(val.min(9) as u8, ZERO_RUN_TREE, probs)?; |
| 312 | if val >= 9 { |
| 313 | let add = val - 9; |
| 314 | for i in 0..6 { |
| 315 | self.put_bool(((add >> i) & 1) != 0, probs[i + 8])?; |
| 316 | } |
| 317 | } |
| 318 | Ok(()) |
| 319 | } |
| 320 | } |
| 321 | |
| 322 | fn rescale_mb_mode_prob(prob: u32, total: u32) -> u8 { |
| 323 | (255 * prob / (1 + total)) as u8 |
| 324 | } |
| 325 | |
| 326 | fn calc_mb_model_probs(prob_xmitted: &[u8; 20], mbtype_models: &mut [VP56MBTypeModel; 10]) { |
| 327 | for mode in 0..10 { |
| 328 | let mdl = &mut mbtype_models[mode]; |
| 329 | let mut cnt = [0u32; 10]; |
| 330 | let mut total = 0; |
| 331 | for i in 0..10 { |
| 332 | if i == mode { continue; } |
| 333 | cnt[i] = 100 * u32::from(prob_xmitted[i * 2]); |
| 334 | total += cnt[i]; |
| 335 | } |
| 336 | let sum = u32::from(prob_xmitted[mode * 2]) + u32::from(prob_xmitted[mode * 2 + 1]); |
| 337 | mdl.probs[9] = 255 - rescale_mb_mode_prob(u32::from(prob_xmitted[mode * 2 + 1]), sum); |
| 338 | |
| 339 | let inter_mv0_weight = (cnt[0] as u32) + (cnt[2] as u32); |
| 340 | let inter_mv1_weight = (cnt[3] as u32) + (cnt[4] as u32); |
| 341 | let gold_mv0_weight = (cnt[5] as u32) + (cnt[6] as u32); |
| 342 | let gold_mv1_weight = (cnt[8] as u32) + (cnt[9] as u32); |
| 343 | let mix_weight = (cnt[1] as u32) + (cnt[7] as u32); |
| 344 | mdl.probs[0] = 1 + rescale_mb_mode_prob(inter_mv0_weight + inter_mv1_weight, total); |
| 345 | mdl.probs[1] = 1 + rescale_mb_mode_prob(inter_mv0_weight, inter_mv0_weight + inter_mv1_weight); |
| 346 | mdl.probs[2] = 1 + rescale_mb_mode_prob(mix_weight, mix_weight + gold_mv0_weight + gold_mv1_weight); |
| 347 | mdl.probs[3] = 1 + rescale_mb_mode_prob(cnt[0] as u32, inter_mv0_weight); |
| 348 | mdl.probs[4] = 1 + rescale_mb_mode_prob(cnt[3] as u32, inter_mv1_weight); |
| 349 | mdl.probs[5] = 1 + rescale_mb_mode_prob(cnt[1], mix_weight); |
| 350 | mdl.probs[6] = 1 + rescale_mb_mode_prob(gold_mv0_weight, gold_mv0_weight + gold_mv1_weight); |
| 351 | mdl.probs[7] = 1 + rescale_mb_mode_prob(cnt[5], gold_mv0_weight); |
| 352 | mdl.probs[8] = 1 + rescale_mb_mode_prob(cnt[8], gold_mv1_weight); |
| 353 | } |
| 354 | } |
| 355 | |
| 356 | fn calc_mbtype_bits(prob_xmitted: &[u8; 20], stats: &[[usize; 10]; 10], mdl: &mut [VP56MBTypeModel; 10]) -> u32 { |
| 357 | const MB_TYPES: [VPMBType; 10] = [ |
| 358 | VPMBType::InterNoMV, |
| 359 | VPMBType::Intra, |
| 360 | VPMBType::InterMV, |
| 361 | VPMBType::InterNearest, |
| 362 | VPMBType::InterNear, |
| 363 | VPMBType::GoldenNoMV, |
| 364 | VPMBType::GoldenMV, |
| 365 | VPMBType::InterFourMV, |
| 366 | VPMBType::GoldenNearest, |
| 367 | VPMBType::GoldenNear |
| 368 | ]; |
| 369 | |
| 370 | calc_mb_model_probs(prob_xmitted, mdl); |
| 371 | let mut nits = 0; |
| 372 | for (last, (srow, mdl)) in stats.iter().zip(mdl.iter()).enumerate() { |
| 373 | for (cur, &ccount) in srow.iter().enumerate() { |
| 374 | let ccount = ccount as u32; |
| 375 | nits += Estimator::est_nits(cur == last, mdl.probs[9]) * ccount; |
| 376 | if cur != last { |
| 377 | for entry in MODE_TREE.iter() { |
| 378 | if entry.val == MB_TYPES[cur] { |
| 379 | for seq in entry.seq.iter() { |
| 380 | nits += Estimator::est_nits(seq.bit, mdl.probs[seq.idx as usize]) * ccount; |
| 381 | } |
| 382 | break; |
| 383 | } |
| 384 | } |
| 385 | } |
| 386 | } |
| 387 | } |
| 388 | |
| 389 | Estimator::nits_to_bits(nits) |
| 390 | } |
| 391 | |
| 392 | fn find_model_vq(prob_xmitted: &[u8; 20], vq: &[[u8; 20]; 16]) -> usize { |
| 393 | let mut best_idx = 0; |
| 394 | let mut best_dist = i16::MAX; |
| 395 | |
| 396 | for (idx, row) in vq.iter().enumerate() { |
| 397 | let mut dist = 0; |
| 398 | for i in 0..20 { |
| 399 | let a = prob_xmitted[i ^ 1]; |
| 400 | let b = row[i]; |
| 401 | dist += (i16::from(a) - i16::from(b)).abs(); |
| 402 | } |
| 403 | if dist == 0 { |
| 404 | return idx; |
| 405 | } |
| 406 | if dist < best_dist { |
| 407 | best_dist = dist; |
| 408 | best_idx = idx; |
| 409 | } |
| 410 | } |
| 411 | |
| 412 | best_idx |
| 413 | } |
| 414 | |
| 415 | // todo per-delta decision, incremental updates and such |
| 416 | fn deltas_bits(probs: &[u8; 20], base: &[u8; 20], stats: &[[usize; 10]; 10], tmp: &mut [VP56MBTypeModel; 10], deltas: &mut [i16; 20]) -> u32 { |
| 417 | const DELTA_PROBS: [u8; 8] = [ |
| 418 | PROB_BITS[205], |
| 419 | PROB_BITS[256 - 205] + PROB_BITS[171] + PROB_BITS[256 - 83] + PROB_BITS[128], |
| 420 | PROB_BITS[256 - 205] + PROB_BITS[171] + PROB_BITS[83] + PROB_BITS[128], |
| 421 | PROB_BITS[256 - 205] + PROB_BITS[256 - 171] + PROB_BITS[199] + PROB_BITS[256 - 140] + PROB_BITS[128], |
| 422 | PROB_BITS[256 - 205] + PROB_BITS[256 - 171] + PROB_BITS[199] + PROB_BITS[140] + PROB_BITS[256 - 125] + PROB_BITS[128], |
| 423 | PROB_BITS[256 - 205] + PROB_BITS[256 - 171] + PROB_BITS[199] + PROB_BITS[140] + PROB_BITS[125] + PROB_BITS[256 - 104] + PROB_BITS[128], |
| 424 | PROB_BITS[256 - 205] + PROB_BITS[256 - 171] + PROB_BITS[199] + PROB_BITS[140] + PROB_BITS[125] + PROB_BITS[104] + PROB_BITS[128], |
| 425 | PROB_BITS[256 - 205] + PROB_BITS[256 - 171] + PROB_BITS[256 - 199] + 8 * PROB_BITS[128], |
| 426 | ]; |
| 427 | |
| 428 | let mut nits = 0; |
| 429 | let mut tprobs = [0u8; 20]; |
| 430 | |
| 431 | for i in 0..20 { |
| 432 | let old = i16::from(base[i]); |
| 433 | let new = i16::from(probs[i]); |
| 434 | let mut diff = (new - old) & !3; |
| 435 | if old + diff > 255 { |
| 436 | diff -= 4; |
| 437 | } else if old + diff < 0 || (old + diff == 0 && new != 0) { |
| 438 | diff += 4; |
| 439 | } |
| 440 | tprobs[i] = (old + diff) as u8; |
| 441 | deltas[i] = diff; |
| 442 | nits += u32::from(DELTA_PROBS[(diff.abs() >> 2).min(7) as usize]); |
| 443 | } |
| 444 | |
| 445 | Estimator::nits_to_bits(nits) + calc_mbtype_bits(&tprobs, stats, tmp) + 5 |
| 446 | } |
| 447 | |
| 448 | pub fn encode_mode_prob_models(bc: &mut BoolEncoder, models: &mut VP56Models, pmodels: &VP56Models, stats: &[[[usize; 10]; 10]; 3]) -> EncoderResult<()> { |
| 449 | let mut tmp = [VP56MBTypeModel::default(); 10]; |
| 450 | let mut tprob = [0; 20]; |
| 451 | for ctx in 0..3 { |
| 452 | let mut models_changed = models.prob_xmitted[ctx] != pmodels.prob_xmitted[ctx]; |
| 453 | if models_changed { |
| 454 | let old_bits = calc_mbtype_bits(&pmodels.prob_xmitted[ctx], &stats[ctx], &mut tmp); |
| 455 | let new_bits = calc_mbtype_bits(&models.prob_xmitted[ctx], &stats[ctx], &mut tmp) + 4; |
| 456 | if new_bits < old_bits { |
| 457 | let idx = find_model_vq(&models.prob_xmitted[ctx], &VP56_MODE_VQ[ctx]); |
| 458 | for i in 0..20 { |
| 459 | tprob[i ^ 1] = VP56_MODE_VQ[ctx][idx][i]; |
| 460 | } |
| 461 | let vq_bits = calc_mbtype_bits(&tprob, &stats[ctx], &mut tmp) + 4; |
| 462 | if vq_bits < old_bits { |
| 463 | bc.put_bool(true, 174)?; |
| 464 | bc.put_bits(idx as u32, 4)?; |
| 465 | let mut diffs_present = tprob != models.prob_xmitted[ctx]; |
| 466 | let mut deltas = [0; 20]; |
| 467 | let delta_cost = deltas_bits(&models.prob_xmitted[ctx], &tprob, &stats[ctx], &mut tmp, &mut deltas); |
| 468 | if delta_cost + 1 >= new_bits { |
| 469 | diffs_present = false; |
| 470 | } |
| 471 | if diffs_present { |
| 472 | bc.put_bool(true, 254)?; |
| 473 | for i in 0..20 { |
| 474 | let diff = deltas[i ^ 1] >> 2; |
| 475 | bc.put_bool(diff != 0, 205)?; |
| 476 | if diff != 0 { |
| 477 | let d0 = diff.abs().min(7) as u8; |
| 478 | bc.put_bool(diff < 0, 128)?; |
| 479 | bc.write_el(d0, MODE_TREE_DIFF, MODE_TREE_DIFF_PROBS)?; |
| 480 | if d0 == 7 { |
| 481 | bc.put_bits(diff.abs() as u32, 7)?; |
| 482 | } |
| 483 | tprob[i ^ 1] = (i16::from(tprob[i ^ 1]) + deltas[i ^ 1]) as u8; |
| 484 | } |
| 485 | } |
| 486 | } |
| 487 | if !diffs_present { |
| 488 | bc.put_bool(false, 254)?; |
| 489 | } |
| 490 | } else { |
| 491 | models_changed = false; |
| 492 | } |
| 493 | } else { |
| 494 | models_changed = false; |
| 495 | } |
| 496 | } |
| 497 | if !models_changed { |
| 498 | bc.put_bool(false, 174)?; |
| 499 | bc.put_bool(false, 254)?; |
| 500 | models.prob_xmitted[ctx] = pmodels.prob_xmitted[ctx]; |
| 501 | } else { |
| 502 | models.prob_xmitted[ctx] = tprob; |
| 503 | } |
| 504 | } |
| 505 | for ctx in 0..3 { |
| 506 | let prob_xmitted = &models.prob_xmitted[ctx]; |
| 507 | calc_mb_model_probs(prob_xmitted, &mut models.mbtype_models[ctx]); |
| 508 | } |
| 509 | Ok(()) |
| 510 | } |
| 511 | |
| 512 | pub fn encode_mv_models(bc: &mut BoolEncoder, models: &[VP56MVModel; 2], pmodels: &[VP56MVModel; 2]) -> EncoderResult<()> { |
| 513 | for (i, (mdl, pmdl)) in models.iter().zip(pmodels.iter()).enumerate() { |
| 514 | bc.encode_probability(mdl.nz_prob, pmdl.nz_prob, HAS_NZ_PROB[i])?; |
| 515 | bc.encode_probability(mdl.sign_prob, pmdl.sign_prob, HAS_SIGN_PROB[i])?; |
| 516 | } |
| 517 | for (i, (mdl, pmdl)) in models.iter().zip(pmodels.iter()).enumerate() { |
| 518 | for (&coded_prob, (&prob, &pprob)) in HAS_TREE_PROB[i].iter().zip(mdl.tree_probs.iter().zip(pmdl.tree_probs.iter())) { |
| 519 | bc.encode_probability(prob, pprob, coded_prob)?; |
| 520 | } |
| 521 | } |
| 522 | for (i, (mdl, pmdl)) in models.iter().zip(pmodels.iter()).enumerate() { |
| 523 | for (&coded_prob, (&prob, &pprob)) in HAS_RAW_PROB[i].iter().zip(mdl.raw_probs.iter().zip(pmdl.raw_probs.iter())) { |
| 524 | bc.encode_probability(prob, pprob, coded_prob)?; |
| 525 | } |
| 526 | } |
| 527 | Ok(()) |
| 528 | } |
| 529 | |
| 530 | pub fn encode_coeff_models(bc: &mut BoolEncoder, models: &mut VP56Models, pmodels: &VP56Models, is_intra: bool, interlaced: bool) -> EncoderResult<()> { |
| 531 | let mut def_prob = [128u8; 11]; |
| 532 | for plane in 0..2 { |
| 533 | for i in 0..11 { |
| 534 | let pprob = pmodels.coeff_models[plane].dc_value_probs[i]; |
| 535 | let prob = models.coeff_models[plane].dc_value_probs[i]; |
| 536 | let changed = (is_intra && prob != def_prob[i]) || (!is_intra && prob != pprob); |
| 537 | bc.put_bool(changed, HAS_COEF_PROBS[plane][i])?; |
| 538 | if changed { |
| 539 | bc.put_probability(prob)?; |
| 540 | def_prob[i] = prob; |
| 541 | } |
| 542 | } |
| 543 | } |
| 544 | |
| 545 | bc.put_bool(false, 128)?; |
| 546 | reset_scan(&mut models.vp6models, interlaced); |
| 547 | /* for scan |
| 548 | for i in 1..64 { |
| 549 | if bc.read_prob(HAS_SCAN_UPD_PROBS[i]) { |
| 550 | models.vp6models.scan_order[i] = bc.read_bits(4) as usize; |
| 551 | } |
| 552 | } |
| 553 | update_scan(&mut models.vp6models); |
| 554 | */ |
| 555 | |
| 556 | for comp in 0..2 { |
| 557 | for i in 0..14 { |
| 558 | bc.encode_probability(models.vp6models.zero_run_probs[comp][i], pmodels.vp6models.zero_run_probs[comp][i], HAS_ZERO_RUN_PROBS[comp][i])?; |
| 559 | } |
| 560 | } |
| 561 | |
| 562 | for ctype in 0..3 { |
| 563 | for plane in 0..2 { |
| 564 | for group in 0..6 { |
| 565 | for i in 0..11 { |
| 566 | let pprob = pmodels.coeff_models[plane].ac_val_probs[ctype][group][i]; |
| 567 | let prob = models.coeff_models[plane].ac_val_probs[ctype][group][i]; |
| 568 | let changed = (is_intra && prob != def_prob[i]) || (!is_intra && prob != pprob); |
| 569 | bc.put_bool(changed, VP6_AC_PROBS[ctype][plane][group][i])?; |
| 570 | if changed { |
| 571 | bc.put_probability(prob)?; |
| 572 | def_prob[i] = prob; |
| 573 | } |
| 574 | } |
| 575 | } |
| 576 | } |
| 577 | } |
| 578 | |
| 579 | for plane in 0..2 { |
| 580 | let mdl = &mut models.coeff_models[plane]; |
| 581 | for i in 0..3 { |
| 582 | for k in 0..5 { |
| 583 | mdl.dc_token_probs[0][i][k] = rescale_prob(mdl.dc_value_probs[k], &VP6_DC_WEIGHTS[k][i], 255); |
| 584 | } |
| 585 | } |
| 586 | } |
| 587 | Ok(()) |
| 588 | } |
| 589 | |
| 590 | pub fn encode_block(bc: &mut BoolEncoder, blk: &[i16; 64], dc_mode: usize, model: &VP56CoeffModel, vp6model: &VP6Models) -> EncoderResult<()> { |
| 591 | let mut last = 64; |
| 592 | for i in (0..64).rev() { |
| 593 | if blk[vp6model.zigzag[i]] != 0 { |
| 594 | last = i; |
| 595 | break; |
| 596 | } |
| 597 | } |
| 598 | if last < 64 { |
| 599 | bc.write_dc(blk[0], &model.dc_token_probs[0][dc_mode], &model.dc_value_probs)?; |
| 600 | let mut idx = 1; |
| 601 | let mut last_idx = 0; |
| 602 | let mut last_val = blk[0]; |
| 603 | while idx <= last { |
| 604 | let val = blk[vp6model.zigzag[idx]]; |
| 605 | let has_nnz = (idx == 1) || (last_val != 0); |
| 606 | if (val != 0) || has_nnz { |
| 607 | if last_val == 0 && idx != 1 { |
| 608 | let zrun = idx - last_idx; |
| 609 | bc.write_zero_run(zrun, &vp6model.zero_run_probs[if last_idx + 1 >= 7 { 1 } else { 0 }])?; |
| 610 | } |
| 611 | let ac_band = VP6_IDX_TO_AC_BAND[idx]; |
| 612 | let ac_mode = last_val.abs().min(2) as usize; |
| 613 | let tree = if has_nnz { COEF_TREE } else { NZ_COEF_TREE }; |
| 614 | bc.write_ac(val, tree, &model.ac_val_probs[ac_mode][ac_band])?; |
| 615 | last_val = val; |
| 616 | last_idx = idx; |
| 617 | } |
| 618 | idx += 1; |
| 619 | } |
| 620 | if idx < 64 { |
| 621 | let ac_band = VP6_IDX_TO_AC_BAND[idx]; |
| 622 | let ac_mode = last_val.abs().min(2) as usize; |
| 623 | bc.write_el(EOB, COEF_TREE, &model.ac_val_probs[ac_mode][ac_band])?; |
| 624 | } |
| 625 | } else { |
| 626 | bc.write_cat(0, DC_TREE, &model.dc_token_probs[0][dc_mode], &model.dc_value_probs)?; |
| 627 | let ac_band = VP6_IDX_TO_AC_BAND[1]; |
| 628 | bc.write_el(EOB, COEF_TREE, &model.ac_val_probs[0][ac_band])?; |
| 629 | } |
| 630 | Ok(()) |
| 631 | } |
| 632 | |
| 633 | fn map_mb_type(mbtype: VPMBType) -> usize { |
| 634 | match mbtype { |
| 635 | VPMBType::InterNoMV => 0, |
| 636 | VPMBType::Intra => 1, |
| 637 | VPMBType::InterMV => 2, |
| 638 | VPMBType::InterNearest => 3, |
| 639 | VPMBType::InterNear => 4, |
| 640 | VPMBType::GoldenNoMV => 5, |
| 641 | VPMBType::GoldenMV => 6, |
| 642 | VPMBType::InterFourMV => 7, |
| 643 | VPMBType::GoldenNearest => 8, |
| 644 | VPMBType::GoldenNear => 9, |
| 645 | } |
| 646 | } |
| 647 | |
| 648 | pub fn encode_mb_type(bc: &mut BoolEncoder, mb_type: VPMBType, last_mb_type: VPMBType, ctx: usize, model: &VP56Models) -> EncoderResult<()> { |
| 649 | let probs = &model.mbtype_models[ctx][map_mb_type(last_mb_type)].probs; |
| 650 | bc.put_bool(mb_type == last_mb_type, probs[9])?; |
| 651 | if mb_type != last_mb_type { |
| 652 | bc.write_el(mb_type, MODE_TREE, probs)?; |
| 653 | } |
| 654 | Ok(()) |
| 655 | } |
| 656 | |
| 657 | fn encode_mv_component(bc: &mut BoolEncoder, mv: i16, model: &VP56MVModel) -> EncoderResult<()> { |
| 658 | let aval = mv.abs(); |
| 659 | bc.put_bool(aval >= 8, model.nz_prob)?; |
| 660 | if aval < 8 { |
| 661 | bc.write_el(aval as u8, SHORT_MV_TREE, &model.tree_probs)?; |
| 662 | } else { |
| 663 | for &ord in LONG_VECTOR_ORDER.iter() { |
| 664 | bc.put_bool(((aval >> ord) & 1) != 0, model.raw_probs[ord])?; |
| 665 | } |
| 666 | if (aval & 0xF0) != 0 { |
| 667 | bc.put_bool((aval & (1 << 3)) != 0, model.raw_probs[3])?; |
| 668 | } |
| 669 | } |
| 670 | if aval != 0 { |
| 671 | bc.put_bool(mv < 0, model.sign_prob)?; |
| 672 | } |
| 673 | Ok(()) |
| 674 | } |
| 675 | |
| 676 | pub fn encode_mv(bc: &mut BoolEncoder, mv: MV, model: &VP56Models) -> EncoderResult<()> { |
| 677 | encode_mv_component(bc, mv.x, &model.mv_models[0])?; |
| 678 | encode_mv_component(bc, mv.y, &model.mv_models[1])?; |
| 679 | Ok(()) |
| 680 | } |
| 681 | |
| 682 | struct Estimator {} |
| 683 | |
| 684 | impl Estimator { |
| 685 | fn new() -> Self { Self{} } |
| 686 | fn write_el<T: PartialEq>(&self, el: T, tree: &[TokenSeq<T>], probs: &mut [ProbCounter]) { |
| 687 | for entry in tree.iter() { |
| 688 | if entry.val == el { |
| 689 | for seq in entry.seq.iter() { |
| 690 | probs[seq.idx as usize].add(seq.bit); |
| 691 | } |
| 692 | return; |
| 693 | } |
| 694 | } |
| 695 | } |
| 696 | fn write_cat(&self, cat: i8, tree: &[TokenSeq<i8>], probs: &mut [ProbCounter; 11]) { |
| 697 | for entry in tree.iter() { |
| 698 | if entry.val == cat { |
| 699 | for seq in entry.seq.iter() { |
| 700 | probs[seq.idx as usize].add(seq.bit); |
| 701 | } |
| 702 | return; |
| 703 | } |
| 704 | } |
| 705 | } |
| 706 | fn write_dc(&self, val: i16, probs: &mut [ProbCounter; 11]) { |
| 707 | self.write_cat(coef_to_cat(val), DC_TREE, probs); |
| 708 | } |
| 709 | fn write_ac(&self, val: i16, tree: &[TokenSeq<i8>], probs: &mut [ProbCounter; 11]) { |
| 710 | self.write_cat(coef_to_cat(val), tree, probs); |
| 711 | } |
| 712 | fn write_zero_run(&self, val: usize, probs: &mut [ProbCounter; 14]) { |
| 713 | self.write_el(val.min(9) as u8, ZERO_RUN_TREE, probs); |
| 714 | if val >= 9 { |
| 715 | let add = val - 9; |
| 716 | for i in 0..6 { |
| 717 | probs[i + 8].add(((add >> i) & 1) != 0); |
| 718 | } |
| 719 | } |
| 720 | } |
| 721 | fn est_nits(bit: bool, prob: u8) -> u32 { |
| 722 | if !bit { |
| 723 | u32::from(PROB_BITS[prob as usize]) |
| 724 | } else { |
| 725 | u32::from(PROB_BITS[256 - (prob as usize)]) |
| 726 | } |
| 727 | } |
| 728 | fn nits_to_bits(nits: u32) -> u32 { (nits + 7) >> 3 } |
| 729 | } |
| 730 | |
| 731 | pub fn estimate_block(blk: &[i16; 64], _dc_mode: usize, model: &mut VP56CoeffModelStat, vp6model: &mut VP6ModelsStat, scan: &[usize; 64]) { |
| 732 | let bc = Estimator::new(); |
| 733 | |
| 734 | let mut last = 64; |
| 735 | for i in (0..64).rev() { |
| 736 | if blk[scan[i]] != 0 { |
| 737 | last = i; |
| 738 | break; |
| 739 | } |
| 740 | } |
| 741 | if last < 64 { |
| 742 | bc.write_dc(blk[0], &mut model.dc_value_probs); |
| 743 | let mut idx = 1; |
| 744 | let mut last_idx = 0; |
| 745 | let mut last_val = blk[0]; |
| 746 | while idx <= last { |
| 747 | let val = blk[scan[idx]]; |
| 748 | let has_nnz = (idx == 1) || (last_val != 0); |
| 749 | if (val != 0) || has_nnz { |
| 750 | if last_val == 0 && idx != 1 { |
| 751 | let zrun = idx - last_idx; |
| 752 | bc.write_zero_run(zrun, &mut vp6model.zero_run_probs[if last_idx + 1 >= 7 { 1 } else { 0 }]); |
| 753 | } |
| 754 | let ac_band = VP6_IDX_TO_AC_BAND[idx]; |
| 755 | let ac_mode = last_val.abs().min(2) as usize; |
| 756 | let tree = if has_nnz { COEF_TREE } else { NZ_COEF_TREE }; |
| 757 | bc.write_ac(val, tree, &mut model.ac_val_probs[ac_mode][ac_band]); |
| 758 | last_val = val; |
| 759 | last_idx = idx; |
| 760 | } |
| 761 | idx += 1; |
| 762 | } |
| 763 | if idx < 64 { |
| 764 | let ac_band = VP6_IDX_TO_AC_BAND[idx]; |
| 765 | let ac_mode = last_val.abs().min(2) as usize; |
| 766 | bc.write_el(EOB, COEF_TREE, &mut model.ac_val_probs[ac_mode][ac_band]); |
| 767 | } |
| 768 | } else { |
| 769 | bc.write_cat(0, DC_TREE, &mut model.dc_value_probs); |
| 770 | let ac_band = VP6_IDX_TO_AC_BAND[1]; |
| 771 | bc.write_el(EOB, COEF_TREE, &mut model.ac_val_probs[0][ac_band]); |
| 772 | } |
| 773 | } |
| 774 | |
| 775 | pub fn estimate_mb_type(mb_type: VPMBType, last_mb_type: VPMBType, ctx: usize, model: &mut VP56ModelsStat) { |
| 776 | model.mbtype_models[ctx][map_mb_type(last_mb_type)][map_mb_type(mb_type)] += 1; |
| 777 | } |
| 778 | |
| 779 | fn estimate_mv_component(mv: i16, model: &mut VP56MVModelStat) { |
| 780 | let bc = Estimator::new(); |
| 781 | let aval = mv.abs(); |
| 782 | model.nz_prob.add(aval >= 8); |
| 783 | if aval < 8 { |
| 784 | bc.write_el(aval as u8, SHORT_MV_TREE, &mut model.tree_probs); |
| 785 | } else { |
| 786 | for &ord in LONG_VECTOR_ORDER.iter() { |
| 787 | model.raw_probs[ord].add(((aval >> ord) & 1) != 0); |
| 788 | } |
| 789 | if (aval & 0xF0) != 0 { |
| 790 | model.raw_probs[3].add((aval & (1 << 3)) != 0); |
| 791 | } |
| 792 | } |
| 793 | if aval != 0 { |
| 794 | model.sign_prob.add(mv < 0); |
| 795 | } |
| 796 | } |
| 797 | |
| 798 | pub fn estimate_mv(mv: MV, model: &mut VP56ModelsStat) { |
| 799 | estimate_mv_component(mv.x, &mut model.mv_models[0]); |
| 800 | estimate_mv_component(mv.y, &mut model.mv_models[1]); |
| 801 | } |
| 802 | |
| 803 | const VP56_MODE_VQ: [[[u8; 20]; 16]; 3] = [ |
| 804 | [ |
| 805 | [ 9, 15, 32, 25, 7, 19, 9, 21, 1, 12, 14, 12, 3, 18, 14, 23, 3, 10, 0, 4 ], |
| 806 | [ 48, 39, 1, 2, 11, 27, 29, 44, 7, 27, 1, 4, 0, 3, 1, 6, 1, 2, 0, 0 ], |
| 807 | [ 21, 32, 1, 2, 4, 10, 32, 43, 6, 23, 2, 3, 1, 19, 1, 6, 12, 21, 0, 7 ], |
| 808 | [ 69, 83, 0, 0, 0, 2, 10, 29, 3, 12, 0, 1, 0, 3, 0, 3, 2, 2, 0, 0 ], |
| 809 | [ 11, 20, 1, 4, 18, 36, 43, 48, 13, 35, 0, 2, 0, 5, 3, 12, 1, 2, 0, 0 ], |
| 810 | [ 70, 44, 0, 1, 2, 10, 37, 46, 8, 26, 0, 2, 0, 2, 0, 2, 0, 1, 0, 0 ], |
| 811 | [ 8, 15, 0, 1, 8, 21, 74, 53, 22, 42, 0, 1, 0, 2, 0, 3, 1, 2, 0, 0 ], |
| 812 | [ 141, 42, 0, 0, 1, 4, 11, 24, 1, 11, 0, 1, 0, 1, 0, 2, 0, 0, 0, 0 ], |
| 813 | [ 8, 19, 4, 10, 24, 45, 21, 37, 9, 29, 0, 3, 1, 7, 11, 25, 0, 2, 0, 1 ], |
| 814 | [ 46, 42, 0, 1, 2, 10, 54, 51, 10, 30, 0, 2, 0, 2, 0, 1, 0, 1, 0, 0 ], |
| 815 | [ 28, 32, 0, 0, 3, 10, 75, 51, 14, 33, 0, 1, 0, 2, 0, 1, 1, 2, 0, 0 ], |
| 816 | [ 100, 46, 0, 1, 3, 9, 21, 37, 5, 20, 0, 1, 0, 2, 1, 2, 0, 1, 0, 0 ], |
| 817 | [ 27, 29, 0, 1, 9, 25, 53, 51, 12, 34, 0, 1, 0, 3, 1, 5, 0, 2, 0, 0 ], |
| 818 | [ 80, 38, 0, 0, 1, 4, 69, 33, 5, 16, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 ], |
| 819 | [ 16, 20, 0, 0, 2, 8, 104, 49, 15, 33, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0 ], |
| 820 | [ 194, 16, 0, 0, 1, 1, 1, 9, 1, 3, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0 ], |
| 821 | ], [ |
| 822 | [ 41, 22, 1, 0, 1, 31, 0, 0, 0, 0, 0, 1, 1, 7, 0, 1, 98, 25, 4, 10 ], |
| 823 | [ 123, 37, 6, 4, 1, 27, 0, 0, 0, 0, 5, 8, 1, 7, 0, 1, 12, 10, 0, 2 ], |
| 824 | [ 26, 14, 14, 12, 0, 24, 0, 0, 0, 0, 55, 17, 1, 9, 0, 36, 5, 7, 1, 3 ], |
| 825 | [ 209, 5, 0, 0, 0, 27, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0 ], |
| 826 | [ 2, 5, 4, 5, 0, 121, 0, 0, 0, 0, 0, 3, 2, 4, 1, 4, 2, 2, 0, 1 ], |
| 827 | [ 175, 5, 0, 1, 0, 48, 0, 0, 0, 0, 0, 2, 0, 1, 0, 2, 0, 1, 0, 0 ], |
| 828 | [ 83, 5, 2, 3, 0, 102, 0, 0, 0, 0, 1, 3, 0, 2, 0, 1, 0, 0, 0, 0 ], |
| 829 | [ 233, 6, 0, 0, 0, 8, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 ], |
| 830 | [ 34, 16, 112, 21, 1, 28, 0, 0, 0, 0, 6, 8, 1, 7, 0, 3, 2, 5, 0, 2 ], |
| 831 | [ 159, 35, 2, 2, 0, 25, 0, 0, 0, 0, 3, 6, 0, 5, 0, 1, 4, 4, 0, 1 ], |
| 832 | [ 75, 39, 5, 7, 2, 48, 0, 0, 0, 0, 3, 11, 2, 16, 1, 4, 7, 10, 0, 2 ], |
| 833 | [ 212, 21, 0, 1, 0, 9, 0, 0, 0, 0, 1, 2, 0, 2, 0, 0, 2, 2, 0, 0 ], |
| 834 | [ 4, 2, 0, 0, 0, 172, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 2, 0, 0, 0 ], |
| 835 | [ 187, 22, 1, 1, 0, 17, 0, 0, 0, 0, 3, 6, 0, 4, 0, 1, 4, 4, 0, 1 ], |
| 836 | [ 133, 6, 1, 2, 1, 70, 0, 0, 0, 0, 0, 2, 0, 4, 0, 3, 1, 1, 0, 0 ], |
| 837 | [ 251, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], |
| 838 | ], [ |
| 839 | [ 2, 3, 2, 3, 0, 2, 0, 2, 0, 0, 11, 4, 1, 4, 0, 2, 3, 2, 0, 4 ], |
| 840 | [ 49, 46, 3, 4, 7, 31, 42, 41, 0, 0, 2, 6, 1, 7, 1, 4, 2, 4, 0, 1 ], |
| 841 | [ 26, 25, 1, 1, 2, 10, 67, 39, 0, 0, 1, 1, 0, 14, 0, 2, 31, 26, 1, 6 ], |
| 842 | [ 103, 46, 1, 2, 2, 10, 33, 42, 0, 0, 1, 4, 0, 3, 0, 1, 1, 3, 0, 0 ], |
| 843 | [ 14, 31, 9, 13, 14, 54, 22, 29, 0, 0, 2, 6, 4, 18, 6, 13, 1, 5, 0, 1 ], |
| 844 | [ 85, 39, 0, 0, 1, 9, 69, 40, 0, 0, 0, 1, 0, 3, 0, 1, 2, 3, 0, 0 ], |
| 845 | [ 31, 28, 0, 0, 3, 14, 130, 34, 0, 0, 0, 1, 0, 3, 0, 1, 3, 3, 0, 1 ], |
| 846 | [ 171, 25, 0, 0, 1, 5, 25, 21, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0 ], |
| 847 | [ 17, 21, 68, 29, 6, 15, 13, 22, 0, 0, 6, 12, 3, 14, 4, 10, 1, 7, 0, 3 ], |
| 848 | [ 51, 39, 0, 1, 2, 12, 91, 44, 0, 0, 0, 2, 0, 3, 0, 1, 2, 3, 0, 1 ], |
| 849 | [ 81, 25, 0, 0, 2, 9, 106, 26, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0 ], |
| 850 | [ 140, 37, 0, 1, 1, 8, 24, 33, 0, 0, 1, 2, 0, 2, 0, 1, 1, 2, 0, 0 ], |
| 851 | [ 14, 23, 1, 3, 11, 53, 90, 31, 0, 0, 0, 3, 1, 5, 2, 6, 1, 2, 0, 0 ], |
| 852 | [ 123, 29, 0, 0, 1, 7, 57, 30, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0 ], |
| 853 | [ 13, 14, 0, 0, 4, 20, 175, 20, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0 ], |
| 854 | [ 202, 23, 0, 0, 1, 3, 2, 9, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0 ], |
| 855 | ] |
| 856 | ]; |