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