2 use nihav_core::codecs::*;
3 use nihav_core::io::byteio::*;
4 use nihav_core::io::bitreader::*;
5 use nihav_core::io::codebook::*;
6 use nihav_core::io::intcode::*;
8 macro_rules! idct_mul {
9 (a; $val: expr) => ($val + ($val >> 2));
10 (b; $val: expr) => ($val >> 1);
11 (c; $val: expr) => ($val - ($val >> 2) - ($val >> 4));
12 (d; $val: expr) => ($val + ($val >> 2) - ($val >> 4));
13 (e; $val: expr) => ($val >> 2);
17 ($src: expr, $sstep: expr, $off: expr, $dst: expr, $dstep: expr, $doff: expr, $bias: expr, $shift: expr) => {
18 let tmp00 = $src[$off + 3 * $sstep] + $src[$off + 5 * $sstep];
19 let tmp01 = $src[$off + 3 * $sstep] - $src[$off + 5 * $sstep];
20 let tmp02 = idct_mul!(a; $src[$off + 2 * $sstep]) + idct_mul!(b; $src[$off + 6 * $sstep]);
21 let tmp03 = idct_mul!(b; $src[$off + 2 * $sstep]) - idct_mul!(a; $src[$off + 6 * $sstep]);
22 let tmp0 = ($src[$off + 0 * $sstep] + $src[$off + 4 * $sstep]) + tmp02;
23 let tmp1 = ($src[$off + 0 * $sstep] + $src[$off + 4 * $sstep]) - tmp02;
24 let tmp2 = $src[$off + 0 * $sstep] - $src[$off + 4 * $sstep];
25 let tmp3 = $src[$off + 1 * $sstep] + tmp00;
26 let tmp4 = $src[$off + 1 * $sstep] - tmp00;
27 let tmp5 = tmp01 + $src[$off + 7 * $sstep];
28 let tmp6 = tmp01 - $src[$off + 7 * $sstep];
29 let tmp7 = tmp4 + idct_mul!(c; tmp6);
30 let tmp8 = idct_mul!(c; tmp4) - tmp6;
31 let tmp9 = idct_mul!(d; tmp3) + idct_mul!(e; tmp5);
32 let tmp10 = idct_mul!(e; tmp3) - idct_mul!(d; tmp5);
33 let tmp11 = tmp2 + tmp03;
34 let tmp12 = tmp2 - tmp03;
36 $dst[$doff + 0 * $dstep] = (tmp0 + tmp9 + $bias) >> $shift;
37 $dst[$doff + 1 * $dstep] = (tmp11 + tmp7 + $bias) >> $shift;
38 $dst[$doff + 2 * $dstep] = (tmp12 + tmp8 + $bias) >> $shift;
39 $dst[$doff + 3 * $dstep] = (tmp1 + tmp10 + $bias) >> $shift;
40 $dst[$doff + 4 * $dstep] = (tmp1 - tmp10 + $bias) >> $shift;
41 $dst[$doff + 5 * $dstep] = (tmp12 - tmp8 + $bias) >> $shift;
42 $dst[$doff + 6 * $dstep] = (tmp11 - tmp7 + $bias) >> $shift;
43 $dst[$doff + 7 * $dstep] = (tmp0 - tmp9 + $bias) >> $shift;
45 (float; $src: expr, $sstep: expr, $off: expr, $dst: expr, $dstep: expr, $doff: expr, $bias: expr, $shift: expr) => {
46 let t00 = $src[$off + $sstep * 2] + $src[$off + $sstep * 6];
47 let t01 = ($src[$off + $sstep * 2] - $src[$off + $sstep * 6]) * 1.4142135 - t00;
48 let t02 = $src[$off + $sstep * 0] + $src[$off + $sstep * 4];
49 let t03 = $src[$off + $sstep * 0] - $src[$off + $sstep * 4];
50 let t04 = $src[$off + $sstep * 3] + $src[$off + $sstep * 5];
51 let t05 = $src[$off + $sstep * 3] - $src[$off + $sstep * 5];
52 let t06 = $src[$off + $sstep * 1] + $src[$off + $sstep * 7];
53 let t07 = $src[$off + $sstep * 1] - $src[$off + $sstep * 7];
59 let t13 = (t06 - t04) * 1.4142135;
60 let t14 = (t07 - t05) * 1.847759;
61 let t15 = t05 * 2.613126 + t14 - t12;
63 let t17 = t07 * 1.0823922 - t14 + t16;
65 $dst[$doff + 0 * $dstep] = t08 + t12;
66 $dst[$doff + 1 * $dstep] = t10 + t15;
67 $dst[$doff + 2 * $dstep] = t11 + t16;
68 $dst[$doff + 3 * $dstep] = t09 - t17;
69 $dst[$doff + 4 * $dstep] = t09 + t17;
70 $dst[$doff + 5 * $dstep] = t11 - t16;
71 $dst[$doff + 6 * $dstep] = t10 - t15;
72 $dst[$doff + 7 * $dstep] = t08 - t12;
76 fn bink2_idct(coeffs: &mut [i32; 64]) {
77 let mut tmp: [i32; 64] = [0; 64];
79 idct!(coeffs, 1, 8 * i, tmp, 8, i, 0, 0);
82 idct!(tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
86 fn bink2_idct_old(coeffs: &mut [f32; 64]) {
87 let mut tmp: [f32; 64] = [0.0; 64];
89 idct!(float; coeffs, 8, i, tmp, 8, i, 0, 0);
92 idct!(float; tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
98 fn clip8(val: i32) -> u8 {
99 val.min(255).max(0) as u8
103 ($src: expr, $off: expr) => (
108 macro_rules! luma_filter {
109 ($src: expr, $off: expr, $step: expr) => ({
110 let t0 = el!($src, $off - 0 * $step) + el!($src, $off + 1 * $step);
111 let t1 = el!($src, $off - 1 * $step) + el!($src, $off + 2 * $step);
112 let t2 = el!($src, $off - 2 * $step) + el!($src, $off + 3 * $step);
113 clip8((((t0 * 19) >> 1) - t1 * 2 + (t2 >> 1) + 8) >> 4)
117 macro_rules! chroma_interp {
118 ($dst: expr, $dstride: expr, $h: expr, $ty: tt, $src: expr, $sstride: expr, $step: expr, $mode: expr, $shift: expr) => {
120 for out in $dst.chunks_mut($dstride).take($h) {
122 let e0 = el!($src, soff + i);
123 let e1 = el!($src, soff + i + $step);
124 out[i] = match $mode {
126 1 => (e0 * 3 + e1 + $shift) >> $shift,
127 2 => (e0 * 2 + e1 * 2 + $shift) >> $shift,
128 _ => (e0 + e1 * 3 + $shift) >> $shift,
137 fn calc_dc(src: &[u8], stride: usize) -> i32 {
139 for row in src.chunks(stride).take(8) {
140 for i in 0..8 { sum += row[i] as i32; }
144 fn put_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
145 bink2_idct(&mut blk[0]);
146 bink2_idct(&mut blk[1]);
147 bink2_idct(&mut blk[2]);
148 bink2_idct(&mut blk[3]);
150 let dout = &mut dst[off..];
151 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
152 for i in 0..8 { row[i + 0] = clip8(b0[i]); }
153 for i in 0..8 { row[i + 8] = clip8(b1[i]); }
158 let dout = &mut dst[off..];
159 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
160 for i in 0..8 { row[i + 0] = clip8(b2[i]); }
161 for i in 0..8 { row[i + 8] = clip8(b3[i]); }
165 fn add_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
166 bink2_idct(&mut blk[0]);
167 bink2_idct(&mut blk[1]);
168 bink2_idct(&mut blk[2]);
169 bink2_idct(&mut blk[3]);
171 let dout = &mut dst[off..];
172 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
173 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b0[i]); }
174 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b1[i]); }
179 let dout = &mut dst[off..];
180 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
181 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b2[i]); }
182 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b3[i]); }
186 fn put_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
187 bink2_idct_old(&mut blk[0]);
188 bink2_idct_old(&mut blk[1]);
189 bink2_idct_old(&mut blk[2]);
190 bink2_idct_old(&mut blk[3]);
192 let dout = &mut dst[off..];
193 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
194 for i in 0..8 { row[i + 0] = clip8(b0[i] as i32); }
195 for i in 0..8 { row[i + 8] = clip8(b1[i] as i32); }
200 let dout = &mut dst[off..];
201 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
202 for i in 0..8 { row[i + 0] = clip8(b2[i] as i32); }
203 for i in 0..8 { row[i + 8] = clip8(b3[i] as i32); }
207 fn add_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
208 bink2_idct_old(&mut blk[0]);
209 bink2_idct_old(&mut blk[1]);
210 bink2_idct_old(&mut blk[2]);
211 bink2_idct_old(&mut blk[3]);
213 let dout = &mut dst[off..];
214 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
215 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b0[i] as i32)); }
216 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b1[i] as i32)); }
221 let dout = &mut dst[off..];
222 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
223 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b2[i] as i32)); }
224 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b3[i] as i32)); }
228 fn mc_luma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
229 let sx = (xoff as isize) + ((mv.x >> 1) as isize);
230 let sy = (yoff as isize) + ((mv.y >> 1) as isize);
231 let mode = (mv.x & 1) + (mv.y & 1) * 2;
232 let (d_x, add_x) = if (mv.x & 1) != 0 { (2, 5) } else { (0, 0) };
233 let (d_y, add_y) = if (mv.y & 1) != 0 { (2, 5) } else { (0, 0) };
235 let (w, h) = ref_pic.get_dimensions(plane);
236 validate!((sx - d_x >= 0) && (sx - d_x + add_x + 16 <= (w as isize)));
237 validate!((sy - d_y >= 0) && (sy - d_y + add_y + 16 <= (h as isize)));
238 let pstride = ref_pic.get_stride(plane);
239 let mut poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
240 let pdata = ref_pic.get_data();
241 let ppix = pdata.as_slice();
243 let dst = &mut dst[xoff + (yoff & 31) * stride..];
247 let src = &ppix[poff..];
248 for (out, row) in dst.chunks_mut(stride).take(16).zip(src.chunks(pstride)) {
249 for i in 0..16 { out[i] = row[i]; }
253 for out in dst.chunks_mut(stride).take(16) {
255 out[i] = luma_filter!(ppix, poff + i, 1);
261 for out in dst.chunks_mut(stride).take(16) {
263 out[i] = luma_filter!(ppix, poff + i, pstride);
269 let mut tmp = [0u8; 21 * 16];
270 for out in tmp.chunks_mut(16) {
272 out[i] = luma_filter!(ppix, poff - 2 * pstride + i, 1);
276 for (row, out) in dst.chunks_mut(stride).take(16).enumerate() {
278 out[i] = luma_filter!(tmp, (row + 2) * 16 + i, 16);
286 fn mc_chroma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
287 let sx = (xoff as isize) + ((mv.x >> 2) as isize);
288 let sy = (yoff as isize) + ((mv.y >> 2) as isize);
291 let add_x = if mx != 0 { 1 } else { 0 };
292 let add_y = if my != 0 { 1 } else { 0 };
294 let (w, h) = ref_pic.get_dimensions(plane);
295 validate!((sx >= 0) && (sx + add_x + 8 <= (w as isize)));
296 validate!((sy >= 0) && (sy + add_y + 8 <= (h as isize)));
297 let pstride = ref_pic.get_stride(plane);
298 let poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
299 let pdata = ref_pic.get_data();
300 let ppix = pdata.as_slice();
302 let dst = &mut dst[xoff + (yoff & 15) * stride..];
303 if (mx == 0) && (my == 0) {
304 let inpix = &ppix[poff..];
305 for (out, src) in dst.chunks_mut(stride).take(8).zip(inpix.chunks(pstride)) {
306 for i in 0..8 { out[i] = src[i]; }
309 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, 1, mx, 2);
311 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, pstride, my, 2);
313 let mut tmp = [0u16; 9 * 8];
314 chroma_interp!(tmp, 8, 9, u16, &ppix[poff..], pstride, 1, mx, 0);
315 chroma_interp!(dst, stride, 8, u8, &tmp, 8, 8, my, 4);
321 fn mid_pred<T:PartialOrd>(a: T, b: T, c: T) -> T {
326 if a < c { c } else { a }
330 if a < c { a } else { c }
346 fn resize(&mut self, bw: usize) {
347 self.qstride = bw * 2;
348 self.quants.resize(self.qstride * 2, 0);
350 self.pqpos = self.qstride;
352 fn update_line(&mut self) {
353 mem::swap(&mut self.qpos, &mut self.pqpos);
355 fn pred_quant(&self, pos: usize, is_top: bool) -> u8 {
356 let is_left = pos < 2;
358 if is_left { 16 } else { self.quants[self.qpos + pos - 2] }
361 self.quants[self.pqpos + pos]
363 mid_pred(self.quants[self.pqpos + pos - 2],
364 self.quants[self.pqpos + pos],
365 self.quants[self.qpos + pos - 2])
369 fn set_quant(&mut self, pos: usize, q: u8) {
370 self.quants[self.qpos + pos] = q;
385 fn resize(&mut self, bw: usize) {
386 self.stride = bw * 4 + 4;
388 self.prev_dcs.resize(self.stride, 0);
389 self.new_dcs.resize(self.stride, 0);
391 fn update_line(&mut self) {
392 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
394 fn set_dcs(&mut self, bx: usize, dc5: i32, dc7: i32, dc13: i32, dc10: i32, dc11: i32, dc14: i32, dc15: i32) {
399 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
418 fn resize(&mut self, bw: usize) {
419 self.stride = bw * 2 + 2;
421 self.prev_dcs.resize(self.stride, 0);
422 self.new_dcs.resize(self.stride, 0);
424 fn update_line(&mut self) {
425 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
427 fn set_dcs(&mut self, bx: usize, dc1: i32, dc2: i32, dc3: i32) {
431 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
438 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool>;
439 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32);
440 fn predict_inter(&mut self, min_dc: i32, max_dc: i32);
443 fn dc_pred2(a: i32, b: i32) -> i32 {
444 (a.max(b)).min(a.min(b).max(a * 2 - b))
446 fn dc_pred(a: i32, b: i32, c: i32) -> i32 {
447 (a.max(b).max(c)).min((a.min(b).min(c)).max(b - a + c))
450 impl DCInfo for YDCInfo {
451 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
452 decode_dcs(br, &mut self.dc_buf, q)
454 #[allow(non_snake_case)]
455 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
456 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
457 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
458 let prev_dc = &self.prev_dcs[bx * 4..];
459 let dst = &mut self.dcs;
460 let dcs = &self.dc_buf;
462 if is_top { //zigzag in 2x2 blocks
463 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
464 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
465 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
466 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
467 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
469 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
470 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
471 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
472 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
474 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
475 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
476 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
477 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
479 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
480 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
481 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
482 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
484 a0 = (dcs[ 0] + dc_pred2(prev_dc[4], prev_dc[5])).max(min_dc).min(max_dc);
485 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
486 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
487 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
489 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
490 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
491 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
492 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
494 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
495 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
496 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
497 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
499 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
500 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
501 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
502 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
506 a0 = (dcs[ 0] + dc_pred2(dst[5], dst[7])).max(min_dc).min(max_dc);
507 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
508 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
509 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
511 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
512 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
513 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
514 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
516 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
517 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
518 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
519 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
521 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
522 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
523 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
524 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
526 a0 = (dcs[ 0] + dc_pred(prev_dc[3], prev_dc[4], dst[5])).max(min_dc).min(max_dc);
527 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
528 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
529 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
531 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
532 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
533 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
534 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
536 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
537 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
538 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
539 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
541 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
542 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
543 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
544 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
563 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
569 #[allow(non_snake_case)]
570 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
571 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
572 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
573 let dst = &mut self.dcs;
574 let dcs = &self.dc_buf;
575 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
576 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
577 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
578 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
580 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
581 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
582 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
583 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
585 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
586 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
587 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
588 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
590 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
591 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
592 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
593 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
614 impl DCInfo for CDCInfo {
615 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
616 decode_dcs(br, &mut self.dc_buf, q)
618 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
619 let prev_dc = &self.prev_dcs[bx * 2..];
620 let dst = &mut self.dcs;
621 let dcs = &self.dc_buf;
623 let a0; let a1; let a2; let a3;
626 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
627 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
628 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
630 a0 = (dcs[ 0] + dc_pred2(prev_dc[2], prev_dc[3])).max(min_dc).min(max_dc);
631 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
633 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
634 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
637 a0 = (dcs[ 0] + dc_pred2(dst[1], dst[3])).max(min_dc).min(max_dc);
638 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
640 a0 = (dcs[ 0] + dc_pred(prev_dc[1], prev_dc[2], dst[1])).max(min_dc).min(max_dc);
641 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
643 a2 = (dcs[ 2] + dc_pred(dst[1], dst[3], a0)).max(min_dc).min(max_dc);
644 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
650 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
654 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
655 let dst = &mut self.dcs;
656 let dcs = &self.dc_buf;
658 let a0; let a1; let a2; let a3;
660 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
661 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
662 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
663 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
672 fn decode_dcs(br: &mut BitReader, dcs: &mut [i32], q: u8) -> DecoderResult<bool> {
673 if !br.read_bool()? {
674 for dc in dcs.iter_mut() {
679 let quant = BINK2_QUANT_DC[q.max(8) as usize];
680 for dc in dcs.iter_mut() {
681 *dc = br.read_bink2_code_zero()?;
683 *dc = (*dc * quant + 0x1FF) >> 10;
701 fn resize(&mut self, bw: usize) {
702 self.stride = bw * 4;
704 self.prev_off = self.stride;
705 self.mvs.resize(self.stride * 2, ZERO_MV);
707 fn update_line(&mut self) {
708 mem::swap(&mut self.mv_off, &mut self.prev_off);
710 fn decode_mv_new(&mut self, br: &mut BitReader, mv_cb: &Codebook<i8>, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
711 let num_mv = if br.read_bool()? { 1 } else { 4 };
712 let mv = &mut self.mvs;
713 let mv_pos = self.mv_off + bx * 4;
714 let ref_pos = self.prev_off + bx * 4;
719 let raw_val = br.read_cb(mv_cb)?;
720 if raw_val != BINK2_MV_ESC {
721 val = raw_val as i16;
723 let len = br.read_code(UintCodeType::LimitedUnary(12, 1))? as u8;
725 let uval = (br.read(nlen)? as i32) + (1 << nlen) - 1;
727 val = (-(uval >> 1) - 1) as i16;
729 val = (uval >> 1) as i16;
733 mv[mv_pos + i].x = val;
735 mv[mv_pos + i].y = val;
743 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
744 mv[mv_pos + 0] = mv0;
745 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
746 mv[mv_pos + 2] = mv2;
747 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
748 mv[mv_pos + 1] = mv1;
749 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
750 mv[mv_pos + 3] = mv3;
752 let mv1 = mv[mv_pos + 1] + mv[mv_pos + 0];
753 mv[mv_pos + 1] = mv1;
754 let mv2 = mv[mv_pos + 2] + mv[mv_pos + 0];
755 mv[mv_pos + 2] = mv2;
756 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
757 mv[mv_pos + 3] = mv3;
761 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
762 mv[mv_pos + 0] = mv0;
763 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
764 mv[mv_pos + 1] = mv1;
765 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
766 mv[mv_pos + 2] = mv2;
767 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
768 mv[mv_pos + 3] = mv3;
770 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 2], mv[ref_pos - 1], mv[mv_pos - 3]);
771 mv[mv_pos + 0] = mv0;
772 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
773 mv[mv_pos + 1] = mv1;
774 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
775 mv[mv_pos + 2] = mv2;
776 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
777 mv[mv_pos + 3] = mv3;
781 let mut mv_pred = mv[mv_pos + 0];
784 mv_pred += MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
788 mv_pred += MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
790 mv_pred += MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
793 mv[mv_pos + 0] = mv_pred;
794 mv[mv_pos + 1] = mv_pred;
795 mv[mv_pos + 2] = mv_pred;
796 mv[mv_pos + 3] = mv_pred;
800 fn decode_mv_old(&mut self, br: &mut BitReader, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
801 let mv = &mut self.mvs;
802 let mv_pos = self.mv_off + bx * 4;
803 let ref_pos = self.prev_off + bx * 4;
808 let mut bits = br.read(3)? as u8;
810 bits += br.read(2)? as u8;
812 let mut mv_c: [i16; 4] = [0; 4];
815 mv_c[i] = br.read(bits)? as i16;
818 if (mv_c[i] != 0) && br.read_bool()? {
823 if is_top && is_left {
824 let mut val = br.read(5)? as i16;
825 if (val != 0) && br.read_bool()? {
836 mv[mv_pos + i].x = mv_c[i];
840 mv[mv_pos + i].y = mv_c[i];
846 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
847 mv[mv_pos + 0] = mv0;
848 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
849 mv[mv_pos + 1] = mv1;
850 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
851 mv[mv_pos + 2] = mv2;
852 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
853 mv[mv_pos + 3] = mv3;
855 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
856 mv[mv_pos + 0] = mv0;
857 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
858 mv[mv_pos + 1] = mv1;
859 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
860 mv[mv_pos + 2] = mv2;
861 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
862 mv[mv_pos + 3] = mv3;
866 let base_mv = MV { x: basex * 16, y: basey * 16 };
867 mv[mv_pos + 0] += base_mv;
868 mv[mv_pos + 1] += base_mv;
869 mv[mv_pos + 2] += base_mv;
870 mv[mv_pos + 3] += base_mv;
872 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
873 mv[mv_pos + 0] = mv0;
874 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
875 mv[mv_pos + 2] = mv2;
876 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
877 mv[mv_pos + 1] = mv1;
878 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
879 mv[mv_pos + 3] = mv3;
885 fn predict_mvs(&mut self, bx: usize, is_top: bool, is_left: bool, is_new: bool) {
886 let mv = &mut self.mvs;
887 let mv_pos = self.mv_off + bx * 4;
888 let ref_pos = self.prev_off + bx * 4;
893 mv[mv_pos + i] = ZERO_MV;
896 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
897 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
898 mv[mv_pos + 1] = MV::pred(mv[mv_pos - 1], mv[mv_pos + 0], mv[mv_pos + 2]);
899 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
903 mv[mv_pos + 0] = MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
904 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
905 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
906 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
908 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 3], mv[ref_pos - 1], mv[ref_pos + 2]);
909 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
911 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
913 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
915 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
920 fn get_mv(&self, bx: usize, blk: usize) -> MV { self.mvs[self.mv_off + bx * 4 + blk] }
921 fn zero(&mut self, bx: usize) {
922 let pos = self.mv_off + bx * 4;
923 self.mvs[pos + 0] = ZERO_MV;
924 self.mvs[pos + 1] = ZERO_MV;
925 self.mvs[pos + 2] = ZERO_MV;
926 self.mvs[pos + 3] = ZERO_MV;
931 ac_cb1: Codebook<u8>,
932 ac_cb2: Codebook<u8>,
934 val_cb1: Codebook<u8>,
935 val_cb2: Codebook<u8>,
936 skip_cb1: Codebook<u8>,
937 skip_cb2: Codebook<u8>,
938 quant_cb: Codebook<u8>,
941 fn map_ac(idx: usize) -> u8 { idx as u8 }
942 fn map_mv(idx: usize) -> i8 { BINK2_MV_SYMS[idx] }
944 impl Default for Bink2Codes {
945 fn default() -> Self {
946 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES1, BINK2_AC_BITS1, map_ac);
947 let ac_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
948 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES2, BINK2_AC_BITS2, map_ac);
949 let ac_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
950 let mut cbr = TableCodebookDescReader::new(BINK2_MV_CODES, BINK2_MV_BITS, map_mv);
951 let mv_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
952 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES1, BINK2_AC_VAL_BITS1, map_ac);
953 let val_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
954 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES2, BINK2_AC_VAL_BITS2, map_ac);
955 let val_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
956 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES1, BINK2_AC_SKIP_BITS1, map_ac);
957 let skip_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
958 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES2, BINK2_AC_SKIP_BITS2, map_ac);
959 let skip_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
960 let mut cbr = TableCodebookDescReader::new(BINK2_QUANT_CODES, BINK2_QUANT_BITS, map_ac);
961 let quant_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
962 Self { ac_cb1, ac_cb2, mv_cb, val_cb1, val_cb2, skip_cb1, skip_cb2, quant_cb }
967 struct Bink2Decoder {
968 info: Rc<NACodecInfo>,
989 fn decode_frame_new(&mut self, br: &mut BitReader, buf: &mut NAVideoBuffer<u8>, is_intra: bool) -> DecoderResult<()> {
990 let (stride_y, stride_u, stride_v) = (buf.get_stride(0), buf.get_stride(1), buf.get_stride(2));
991 let (mut off_y, mut off_u, mut off_v) = (buf.get_offset(0), buf.get_offset(1), buf.get_offset(2));
992 let (ooff_y, ooff_u, ooff_v) = (off_y, off_u, off_v);
993 let (width, height) = buf.get_dimensions(0);
994 let mut data = buf.get_data_mut();
995 let dst = data.as_mut_slice();
996 let bw = (width + 31) >> 5;
997 let bh = (height + 31) >> 6;
998 self.cur_w = (width + 7) & !7;
999 self.cur_h = ((height + 7) & !7) >> 1;
1001 let frame_flags = br.read(32)?;
1002 let offset2 = br.read(32)?;
1003 if (frame_flags & 0x80000) != 0 {
1004 println!("fill {:X}", frame_flags);
1007 for slice_no in 0..2 {
1009 br.seek(offset2 * 8)?;
1010 off_y = ooff_y + stride_y * bh * 32;
1011 off_u = ooff_u + stride_u * bh * 16;
1012 off_v = ooff_v + stride_v * bh * 16;
1014 let mut row_flags: Vec<u8> = Vec::with_capacity(height >> 3);
1015 let mut col_flags: Vec<u8> = Vec::with_capacity(width >> 3);
1016 if (frame_flags & 0x1000) != 0 {
1017 if (frame_flags & 0x8000) != 0 {
1018 decode_flags(br, &mut row_flags, 1, (height >> 3) - 1)?;
1020 if (frame_flags & 0x4000) != 0 {
1021 decode_flags(br, &mut col_flags, 1, (width >> 3) - 1)?;
1024 row_flags.resize(height >> 3, 0);
1025 col_flags.resize(width >> 3, 0);
1026 //store frame_flags * 8 & 0x7F8
1028 let mut row_state = frame_flags & 0x2E000;
1030 row_state |= 0x10000;
1032 self.qinfo.resize(bw);
1033 self.y_dcs.resize(bw);
1034 self.u_dcs.resize(bw);
1035 self.v_dcs.resize(bw);
1036 self.mvs.resize(bw);
1041 let mut cbp_y_p = 0;
1042 let mut cbp_u_p = 0;
1043 let mut cbp_v_p = 0;
1050 let rflags = (row_flags[by >> 1] >> (if (by & 1) != 0 { 4 } else { 0 })) as u32;
1051 row_state = (row_state & 0x3FFFFFF) | ((row_state >> 4) & 0xC000000) | (rflags << 28);
1055 // row_state |= 0x8;
1061 let mut btype_lru: [u8; 4] = [ 2, 3, 1, 0 ];
1062 let mut edge_state = 0;
1063 let is_top = by == 0;
1065 let mut blk_state = row_state | (edge_state & 0x3FC0000);
1075 let clflags = (col_flags[bx >> 1] >> (if (bx & 1) != 0 { 4 } else { 0 })) as u32;
1076 let edge_state_c = ((blk_state >> 4) & 0x3C0000) | (blk_state & 0xFC03FFFF) | ((clflags & 0xF) << 22);
1077 let edge_state_y = (frame_flags & 0x40000) | (blk_state & 0x3FFFF);
1078 edge_state = edge_state_c;
1080 //let is_top = (edge_state & 0x88) != 0;
1081 let is_left = bx == 0; //(edge_state & 0x20) != 0;
1087 if (blk_state & 0x2000) != 0 {
1088 let val = br.read_code(UintCodeType::LimitedUnary(3, 1))?;
1091 btype = btype_lru[0];
1094 btype = btype_lru[1];
1095 btype_lru[1] = btype_lru[0];
1096 btype_lru[0] = btype;
1099 btype = btype_lru[3];
1100 btype_lru[3] = btype_lru[2];
1101 btype_lru[2] = btype;
1104 btype = btype_lru[2];
1105 btype_lru[2] = btype_lru[1];
1106 btype_lru[1] = btype;
1108 _ => unreachable!(),
1111 btype = br.read(2)? as u8;
1115 let q = self.qinfo.pred_quant(bx * 2, is_top);
1116 self.qinfo.set_quant(bx * 2, q);
1117 let q = self.qinfo.pred_quant(bx * 2 + 1, is_top);
1118 self.qinfo.set_quant(bx * 2 + 1, q);
1122 if (frame_flags & 0x2000) != 0 {
1123 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1124 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1125 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1126 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2, is_top))?;
1127 self.qinfo.set_quant(bx * 2, q);
1128 cbp_y = decode_luma_intra(br, &self.codes, cbp_y, q, &mut yblk, edge_state_y, &mut self.y_dcs, bx)?;
1129 cbp_v = decode_chroma_intra(br, &self.codes, cbp_v, q, &mut vblk, edge_state_c, &mut self.v_dcs, bx)?;
1130 cbp_u = decode_chroma_intra(br, &self.codes, cbp_u, q, &mut ublk, edge_state_c, &mut self.u_dcs, bx)?;
1131 //if smth decode one more y
1132 //if smth else decode one more y
1133 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1134 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1135 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1136 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1137 Bink2DSP::put_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1138 Bink2DSP::put_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1140 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1141 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1142 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1143 cbp_y = decode_luma_intra_old(br, &self.codes, cbp_y, &mut yblk, edge_state_y, &mut self.y_dcs, bx, &mut q_y)?;
1144 cbp_v = decode_chroma_intra_old(br, &self.codes, cbp_v, &mut vblk, edge_state_c, &mut self.v_dcs, bx, &mut q_v)?;
1145 cbp_u = decode_chroma_intra_old(br, &self.codes, cbp_u, &mut ublk, edge_state_c, &mut self.u_dcs, bx, &mut q_u)?;
1146 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1147 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1148 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1149 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1150 Bink2DSP::put_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1151 Bink2DSP::put_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1154 self.mvs.predict_mvs(bx, is_top, is_left, (frame_flags & 0x2000) != 0);
1158 if let Some(ref ref_pic) = self.ips.get_ref() {
1159 for blk_no in 0..4 {
1160 let xoff = bx * 32 + (blk_no & 1) * 16;
1161 let yoff = slice_no * bh * 32 + by * 32 + (blk_no & 2) * 8;
1162 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, ZERO_MV, 0)?;
1163 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 1)?;
1164 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 2)?;
1167 return Err(DecoderError::MissingReference);
1172 if (frame_flags & 0x2000) != 0 {
1173 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1175 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1177 if let Some(ref ref_pic) = self.ips.get_ref() {
1178 for blk_no in 0..4 {
1179 let xoff = bx * 32 + (blk_no & 1) * 16;
1180 let yoff = slice_no * bh * 32 + by * 32 + (blk_no & 2) * 8;
1181 let mv = self.mvs.get_mv(bx, blk_no);
1182 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1183 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1184 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1187 return Err(DecoderError::MissingReference);
1191 if (frame_flags & 0x2000) != 0 {
1192 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1194 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1196 if let Some(ref ref_pic) = self.ips.get_ref() {
1197 for blk_no in 0..4 {
1198 let xoff = bx * 32 + (blk_no & 1) * 16;
1199 let yoff = slice_no * bh * 32 + by * 32 + (blk_no & 2) * 8;
1200 let mv = self.mvs.get_mv(bx, blk_no);
1201 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1202 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1203 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1206 return Err(DecoderError::MissingReference);
1208 if (frame_flags & 0x2000) != 0 {
1209 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1210 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1211 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1212 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2 + 1, is_top))?;
1213 self.qinfo.set_quant(bx * 2 + 1, q);
1214 cbp_y_p = decode_luma_inter(br, &self.codes, cbp_y_p, q, &mut yblk, edge_state_y, &mut self.y_dcs)?;
1215 if br.read_bool()? {
1216 cbp_v_p = decode_chroma_inter(br, &self.codes, cbp_v_p, q, &mut vblk, edge_state_y, &mut self.v_dcs)?;
1217 cbp_u_p = decode_chroma_inter(br, &self.codes, cbp_u_p, q, &mut ublk, edge_state_y, &mut self.u_dcs)?;
1222 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1223 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1224 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1225 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1226 Bink2DSP::add_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1227 Bink2DSP::add_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1229 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1230 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1231 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1232 cbp_y_p = decode_luma_inter_old(br, &self.codes, cbp_y_p, &mut yblk, edge_state_y, &mut self.y_dcs, &mut q_y_p)?;
1233 cbp_v_p = decode_chroma_inter_old(br, &self.codes, cbp_v_p, &mut vblk, edge_state_y, &mut self.v_dcs, &mut q_v_p)?;
1234 cbp_u_p = decode_chroma_inter_old(br, &self.codes, cbp_u_p, &mut ublk, edge_state_y, &mut self.u_dcs, &mut q_u_p)?;
1235 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1236 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1237 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1238 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1239 Bink2DSP::add_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1240 Bink2DSP::add_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1243 _ => unreachable!(),
1246 let src = &dst[off_y + bx * 32..];
1247 let dc5 = Bink2DSP::calc_dc(&src[24..], stride_y);
1248 let dc7 = Bink2DSP::calc_dc(&src[24 + stride_y * 8..], stride_y);
1249 let dc13 = Bink2DSP::calc_dc(&src[24 + stride_y * 16..], stride_y);
1250 let dc10 = Bink2DSP::calc_dc(&src[ 0 + stride_y * 24..], stride_y);
1251 let dc11 = Bink2DSP::calc_dc(&src[ 8 + stride_y * 24..], stride_y);
1252 let dc14 = Bink2DSP::calc_dc(&src[16 + stride_y * 24..], stride_y);
1253 let dc15 = Bink2DSP::calc_dc(&src[24 + stride_y * 24..], stride_y);
1254 self.y_dcs.set_dcs(bx, dc5, dc7, dc13, dc10, dc11, dc14, dc15);
1255 let src = &dst[off_u + bx * 16..];
1256 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_u);
1257 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_u * 8..], stride_u);
1258 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_u * 8..], stride_u);
1259 self.u_dcs.set_dcs(bx, dc1, dc2, dc3);
1260 let src = &dst[off_v + bx * 16..];
1261 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_v);
1262 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_v * 8..], stride_v);
1263 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_v * 8..], stride_v);
1264 self.v_dcs.set_dcs(bx, dc1, dc2, dc3);
1267 self.qinfo.update_line();
1268 self.y_dcs.update_line();
1269 self.u_dcs.update_line();
1270 self.v_dcs.update_line();
1271 self.mvs.update_line();
1272 off_y += stride_y * 32;
1273 off_u += stride_u * 16;
1274 off_v += stride_v * 16;
1275 row_state = (row_state & !0x190) | ((row_state & 4) << 2);
1282 fn decode_flags(_br: &mut BitReader, _dst: &mut Vec<u8>, _start: usize, _nbits: usize) -> DecoderResult<u32> {
1284 /* if !br.read_bool()? { // read bits into byte array?
1285 if nbits == 0 { return Ok(()); }
1292 pfx |= br.read(8)? << shift;
1293 dst.push((pfx & 0xFF) as u8);
1298 let val = br.read(cur_nbits)?;
1299 dst.push(pfx | (val << shift))
1301 let mut cur_bits = nbits;
1303 let mut lastbit = 0;
1304 while cur_bits > 0 {
1305 if !br.read_bool()? {
1306 lastbit = if mode == 3 { lastbit ^ 1 } else { br.read(1)? };
1307 let val1 = lastval | (lastbit << shift);
1308 let val2 = br.read(if cur_bits > 4 { 4 } else { cur_bits });
1309 let val = lastval | (lastbit << shift) | (val2 << (shift + 1));
1312 dst.push((val & 0xFF) as u8);
1321 } else if cur_bits < 16 {
1326 lastbit = if mode == 3 { lastbit ^ 1 } else { br.read(1)? };
1327 run = (if mode == 3 { bread + 1 } else { bread + 2 }).min(cur_bits);
1328 if run == cur_bits {
1329 output lastbit x run
1331 let add_run = br.read(bread)? as usize;
1333 output lastbit x run
1334 mode = if add_run == (1 << bread) - 1 { 3 } else { 1 };
1342 fn get_new_quant(br: &mut BitReader, prev_q: u8) -> DecoderResult<u8> {
1343 let mut code = br.read_code(UintCodeType::LimitedUnary(4, 1))? as u8;
1348 code += br.read(1)? as u8;
1349 } else if code == 4 {
1350 code = (br.read(5)? as u8) + 5;
1353 if !br.read_bool()? {
1354 ret = prev_q.checked_add(code);
1356 ret = prev_q.checked_sub(code);
1358 validate!(ret.is_some());
1359 let val = ret.unwrap();
1360 validate!(val < (BINK2_QUANT_DC.len() as u8));
1365 fn decode_luma_intra(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, q: u8, dst: &mut [[[i32; 64]; 4]; 4], edge_state: u32, dcinfo: &mut YDCInfo, bx: usize) -> DecoderResult<u32> {
1366 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1367 let _coded = dcinfo.decode_dcs(br, q)?;
1368 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1369 let dcs = &dcinfo.dcs;
1371 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTRA_LUMA, q, cbp >> (i * 4))?;
1372 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j] * 8 + 32; }
1377 fn decode_chroma_intra(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, q: u8, dst: &mut [[i32; 64]; 4], edge_state: u32, dcinfo: &mut CDCInfo, bx: usize) -> DecoderResult<u32> {
1378 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1379 let _coded = dcinfo.decode_dcs(br, q)?;
1380 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1381 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTRA_CHROMA, q, cbp)?;
1382 let dcs = &dcinfo.dcs;
1383 for i in 0..4 { dst[i][0] = dcs[i] * 8 + 32; }
1387 fn decode_luma_inter(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, q: u8, dst: &mut [[[i32; 64]; 4]; 4], edge_state: u32, dcinfo: &mut YDCInfo) -> DecoderResult<u32> {
1388 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1389 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1390 let _coded = dcinfo.decode_dcs(br, q)?;
1391 dcinfo.predict_inter(min_dc, max_dc);
1392 let dcs = &dcinfo.dcs;
1394 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTER, q, cbp >> (i * 4))?;
1395 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j]; }
1400 fn decode_chroma_inter(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, q: u8, dst: &mut [[i32; 64]; 4], edge_state: u32, dcinfo: &mut CDCInfo) -> DecoderResult<u32> {
1401 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1402 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1403 let _coded = dcinfo.decode_dcs(br, q)?;
1404 dcinfo.predict_inter(min_dc, max_dc);
1405 let dcs = &dcinfo.dcs;
1406 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTER, q, cbp)?;
1407 for i in 0..4 { dst[i][0] = dcs[i]; }
1411 fn decode_cbp_luma(br: &mut BitReader, prev_cbp: u32, edge_state: u32) -> DecoderResult<u32> {
1412 let cnt = (prev_cbp as u16).count_ones() as usize;
1413 let (min_count, mask) = if cnt < 8 { (cnt, 0x0000) } else { (16 - cnt, 0xFFFF) };
1416 if br.read_bool()? {
1418 } else if min_count >= 4 {
1423 if !br.read_bool()? {
1424 let cbp4 = br.read(4)?;
1425 cbp |= cbp4 << (i * 4);
1430 if ((edge_state & 0x40000) == 0) || (cbp != 0) {
1431 if br.read_bool()? {
1437 fn decode_cbp_chroma(br: &mut BitReader, last_cbp: u32) -> DecoderResult<u32> {
1438 if br.read_bool()? {
1439 Ok((last_cbp & 0xF0000) | BINK2_CHROMA_CBPS[(last_cbp & 0xF) as usize])
1441 let ncbp = br.read(4)?;
1442 if br.read_bool()? {
1443 Ok(ncbp | (ncbp << 16))
1450 trait ReadBink2Code {
1451 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32>;
1452 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32>;
1455 impl<'a> ReadBink2Code for BitReader<'a> {
1456 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32> {
1457 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? as i32;
1461 let add_bits = self.read((pfx as u8) - 3)? as i32;
1462 val = (1 << (pfx - 3)) + add_bits + 2;
1471 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32> {
1472 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? + 1;
1475 let add_bits = self.read((pfx as u8) - 3)? as i32;
1476 val = (1 << (pfx - 3)) + add_bits + 2;
1480 if self.read_bool()? {
1488 fn decode_acs_4blocks(br: &mut BitReader, codes: &Bink2Codes, dst: &mut [[i32; 64]; 4], quant_mat: &[[i32; 64]; 4], q: u8, cbp: u32) -> DecoderResult<()> {
1489 let cb = if (cbp >> 16) != 0 { &codes.ac_cb1 } else { &codes.ac_cb2 };
1490 let qmat = &quant_mat[(q & 3) as usize];
1492 for blk_no in 0..4 {
1493 if ((cbp >> blk_no) & 1) == 0 { continue; }
1494 let mut esc_len = 0;
1500 let sym = br.read_cb(cb)?;
1503 skip = br.read(6)? as usize;
1505 skip = BINK2_AC_RUNS[sym as usize];
1508 if idx > 63 { break; }
1509 esc_len = if sym == 13 { 6 } else { 0 };
1511 let level = br.read_bink2_code_nz()?;
1512 let pos = BINK2_ZIGZAG[idx];
1513 dst[blk_no][pos] = (((level * qmat[pos]) << shift) + 0x40) >> 7;
1516 // set blk info to (dc & 0x1FFF) | (intra ? 0x8000 : 0) | (((ncoded == 0) + (ncoded < 4) + (ncoded < 8)) << 13)
1521 fn decode_luma_intra_old(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, dst: &mut [[[f32; 64]; 4]; 4], edge_state: u32, dcinfo: &mut YDCInfo, bx: usize, old_q: &mut u8) -> DecoderResult<u32> {
1522 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1523 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1525 let is_top = (edge_state & 0x88) != 0;
1526 let is_left = (edge_state & 0x20) != 0;
1527 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1528 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1529 let dcs = &dcinfo.dcs;
1531 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTRA_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1532 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1537 fn decode_chroma_intra_old(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, dst: &mut [[f32; 64]; 4], edge_state: u32, dcinfo: &mut CDCInfo, bx: usize, old_q: &mut u8) -> DecoderResult<u32> {
1538 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1539 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1541 let is_top = (edge_state & 0x88) != 0;
1542 let is_left = (edge_state & 0x20) != 0;
1543 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1544 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1545 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1546 let dcs = &dcinfo.dcs;
1547 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1552 fn decode_luma_inter_old(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, dst: &mut [[[f32; 64]; 4]; 4], _edge_state: u32, dcinfo: &mut YDCInfo, old_q: &mut u8) -> DecoderResult<u32> {
1553 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1554 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1556 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1557 dcinfo.predict_inter(-1023, 1023);
1558 let dcs = &dcinfo.dcs;
1560 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTER_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1561 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1566 fn decode_chroma_inter_old(br: &mut BitReader, codes: &Bink2Codes, prev_cbp: u32, dst: &mut [[f32; 64]; 4], _edge_state: u32, dcinfo: &mut CDCInfo, old_q: &mut u8) -> DecoderResult<u32> {
1567 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1568 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1570 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1571 dcinfo.predict_inter(-1023, 1023);
1572 let dcs = &dcinfo.dcs;
1573 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1574 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1578 fn decode_quant_old(br: &mut BitReader, quant_cb: &Codebook<u8>, prev_quant: u8) -> DecoderResult<u8> {
1579 let diff = br.read_cb(quant_cb)?;
1584 if br.read_bool()? {
1585 res = prev_quant.checked_sub(diff);
1587 res = prev_quant.checked_add(diff);
1589 validate!(res.is_some());
1590 let q = res.unwrap();
1596 fn decode_cbp_luma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1598 if br.read_bool()? {
1599 if br.read_bool()? {
1600 return Ok(prev_cbp);
1602 low = prev_cbp & 0xFFFF;
1604 let mut nib1 = (prev_cbp >> 4) & 0xF;
1605 if !br.read_bool()? {
1608 let mut new_cbp = nib1;
1609 if !br.read_bool()? {
1612 new_cbp = new_cbp | (nib1 << 4);
1613 if !br.read_bool()? {
1616 new_cbp = new_cbp | (nib1 << 8);
1617 if !br.read_bool()? {
1620 low = new_cbp | (nib1 << 12);
1622 let mut nib_hi = (prev_cbp >> 20) & 0xF;
1625 let nib = (low >> (4 * i)) & 0xF;
1626 if nib.count_ones() == 0 {
1628 } else if (nib.count_ones() == 1) || !br.read_bool()? {
1631 if (((nib >> bit) & 1) != 0) && br.read_bool()? {
1637 high = (high >> 4) | (nib_hi << 28);
1642 fn decode_cbp_chroma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1644 if !br.read_bool()? {
1647 if br.read_bool()? {
1648 return Ok(prev_cbp);
1650 low = prev_cbp & 0xF;
1653 if low.count_ones() == 0 {
1656 if low.count_ones() != 1 {
1657 high = (prev_cbp >> 16) & low;
1658 if br.read_bool()? {
1659 return Ok((high << 16) | low);
1664 if (((low >> bit) & 1) != 0) && br.read_bool()? {
1668 Ok((high << 16) | low)
1671 fn decode_dcs_old(br: &mut BitReader, dcs: &mut [i32], q: u8, read_bias: bool) -> DecoderResult<()> {
1672 let mut bits = br.read(3)? as u8;
1674 bits += br.read(2)? as u8;
1676 let scale = BINK2_OLD_DC_QUANTS[q as usize];
1678 for el in dcs.iter_mut() { *el = 0; }
1680 for dcb in dcs.chunks_mut(4) {
1681 for dc in dcb.iter_mut() {
1682 *dc = br.read(bits)? as i32;
1684 for dc in dcb.iter_mut() {
1685 if *dc == 0 { continue; }
1687 if br.read_bool()? {
1694 let add_bits = BINK2_DC_EXTRA_BITS[q as usize] + bits;
1696 let pfx = br.read(10 - add_bits)? as i32;
1699 if br.read_bool()? {
1700 base_dc = -(pfx << bits);
1702 base_dc = pfx << bits;
1707 dcs[0] += base_dc * scale;
1713 fn decode_acs_4blocks_old(br: &mut BitReader, codes: &Bink2Codes, dst: &mut [[f32; 64]; 4], quant_mat: &[f32; 64], q: u8, cbp: u32, scan: &[usize; 64]) -> DecoderResult<()> {
1714 let quant = BINK2_OLD_QUANTS[q as usize];
1715 for blk_no in 0..4 {
1716 if ((cbp >> blk_no) & 1) == 0 { continue; }
1717 let val_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.val_cb2 } else { &codes.val_cb1 };
1718 let skip_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.skip_cb2 } else { &codes.skip_cb1 };
1719 let mut esc_len = 0;
1722 let val = br.read_cb(val_cb)?;
1726 let add_bits = br.read(val - 3)? as i32;
1727 level = (1 << (val - 3)) + add_bits + 2;
1731 if br.read_bool()? {
1734 let pos = scan[idx];
1735 dst[blk_no][pos] = (level as f32) * quant_mat[idx] * quant;
1738 if idx >= 64 { break; }
1742 let sym = br.read_cb(skip_cb)?;
1745 skip = br.read(6)? as usize;
1747 skip = BINK2_AC_RUNS[sym as usize];
1750 if idx > 63 { break; }
1751 esc_len = if sym == 13 { 6 } else { 0 };
1758 impl NADecoder for Bink2Decoder {
1759 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
1760 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1761 let w = vinfo.get_width();
1762 let h = vinfo.get_height();
1764 let edata = info.get_extradata().unwrap();
1765 validate!(edata.len() >= 8);
1767 let mut mr = MemoryReader::new_read(&edata);
1768 let mut br = ByteReader::new(&mut mr);
1769 let magic = br.read_u32be()?;
1770 let _flags = br.read_u32le()?;
1772 self.version = magic;
1775 fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
1776 Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
1777 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 1, 1)),
1778 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 2, 1)),
1781 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
1782 self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
1786 Err(DecoderError::InvalidData)
1789 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1790 let src = pkt.get_buffer();
1792 let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
1795 self.key_frame = pkt.is_keyframe();
1797 let bufret = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4);
1798 if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
1799 let bufinfo = bufret.unwrap();
1800 buf = bufinfo.get_vbuf().unwrap();
1802 self.decode_frame_new(&mut br, &mut buf, pkt.is_keyframe())?;
1803 let bufinfo = NABufferType::Video(buf);
1804 self.ips.add_frame(bufinfo.get_vbuf().unwrap());
1806 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
1807 frm.set_frame_type(if self.key_frame { FrameType::I } else { FrameType::P });
1808 Ok(Rc::new(RefCell::new(frm)))
1812 pub fn get_decoder() -> Box<NADecoder> {
1813 Box::new(Bink2Decoder::new())
1818 use nihav_core::codecs::RegisteredDecoders;
1819 use nihav_core::demuxers::RegisteredDemuxers;
1820 use nihav_core::test::dec_video::*;
1821 use crate::codecs::rad_register_all_codecs;
1822 use crate::demuxers::rad_register_all_demuxers;
1825 let mut dmx_reg = RegisteredDemuxers::new();
1826 rad_register_all_demuxers(&mut dmx_reg);
1827 let mut dec_reg = RegisteredDecoders::new();
1828 rad_register_all_codecs(&mut dec_reg);
1830 //let file = "assets/RAD/Open_Logos_partial.bik";
1831 //let file = "assets/RAD/sc13_01_partial.bk2";
1832 let file = "assets/RAD/ge_video_86l.bk2";
1833 //let file = "assets/RAD/eg_club_0.bk2";
1834 test_file_decoding("bink", file, Some(8), true, false, None/*Some("bink2")*/, &dmx_reg, &dec_reg);
1838 const BINK2_ZIGZAG: [usize; 64] = [
1839 0, 8, 1, 2, 9, 16, 24, 17,
1840 10, 3, 4, 11, 18, 25, 32, 40,
1841 33, 26, 19, 12, 5, 6, 13, 20,
1842 27, 34, 41, 48, 56, 49, 42, 35,
1843 28, 21, 14, 7, 15, 22, 29, 36,
1844 43, 50, 57, 58, 51, 44, 37, 30,
1845 23, 31, 38, 45, 52, 59, 60, 53,
1846 46, 39, 47, 54, 61, 62, 55, 63
1848 const BINK2_LUMA_SCAN_OLD: &[usize; 64] = &[
1849 0, 2, 1, 8, 9, 17, 10, 16,
1850 24, 3, 18, 25, 32, 11, 33, 26,
1851 4, 40, 19, 12, 27, 41, 34, 5,
1852 20, 48, 6, 28, 15, 42, 23, 35,
1853 21, 13, 14, 7, 31, 43, 49, 36,
1854 22, 56, 39, 50, 30, 44, 29, 51,
1855 57, 47, 58, 59, 63, 61, 55, 38,
1856 52, 62, 45, 37, 60, 46, 54, 53
1858 const BINK2_CHROMA_SCAN_OLD: &[usize; 64] = &[
1859 0, 1, 8, 2, 9, 16, 10, 17,
1860 3, 24, 11, 18, 25, 13, 14, 4,
1861 15, 5, 6, 7, 12, 19, 20, 21,
1862 22, 23, 26, 27, 28, 29, 30, 31,
1863 32, 33, 34, 35, 36, 37, 38, 39,
1864 40, 41, 42, 43, 44, 45, 46, 47,
1865 48, 49, 50, 51, 52, 53, 54, 55,
1866 56, 57, 58, 59, 60, 61, 62, 63
1869 const BINK2_CHROMA_CBPS: [u32; 16] = [
1876 const BINK2_QUANT_DC: [i32; 37] = [
1877 0x400, 0x4C2, 0x5A8, 0x6BA, 0x800, 0x983, 0xB50, 0xD74,
1878 0x1000, 0x1307, 0x16A1, 0x1AE9, 0x2000, 0x260E, 0x2D41, 0x35D1,
1879 0x4000, 0x4C1C, 0x5A82, 0x6BA3, 0x8000, 0x9838, 0xB505, 0xD745,
1880 0x10000, 0x13070, 0x16A0A, 0x1AE8A, 0x20000, 0x260E0, 0x2D414, 0x35D14,
1881 0x40000, 0x4C1C0, 0x5A828, 0x6BA28, 0x80000
1884 const BINK2_QUANT_INTRA_LUMA: &[[i32; 64]; 4] = &[
1886 0x400, 0x598, 0x5E2, 0x49D, 0x733, 0x7E9, 0x1497, 0x2190,
1887 0x521, 0x685, 0x65E, 0x688, 0xA41, 0xD72, 0x1F57, 0x31FA,
1888 0x434, 0x6DB, 0x710, 0x79E, 0xF8C, 0x130B, 0x226D, 0x2E85,
1889 0x546, 0x74C, 0x84F, 0x7E0, 0x1275, 0x1162, 0x1E20, 0x25A5,
1890 0x99A, 0xC1F, 0x10CF, 0x10CF, 0x1B33, 0x1AB3, 0x2B47, 0x3435,
1891 0xD2F, 0x1648, 0x13BC, 0x17A1, 0x23EE, 0x1C40, 0x29E5, 0x266A,
1892 0x156E, 0x1D61, 0x1E75, 0x1BB3, 0x2B47, 0x2720, 0x34F7, 0x3270,
1893 0x1C6F, 0x1DE1, 0x1B6C, 0x17D1, 0x23E5, 0x2357, 0x3175, 0x35C8
1895 0x4C2, 0x6A7, 0x6FF, 0x57D, 0x890, 0x968, 0x187C, 0x27EA,
1896 0x619, 0x7C1, 0x792, 0x7C4, 0xC32, 0xFFD, 0x2545, 0x3B6F,
1897 0x4FF, 0x827, 0x866, 0x90F, 0x127D, 0x16A6, 0x28F1, 0x3752,
1898 0x646, 0x8AE, 0x9E2, 0x95E, 0x15F3, 0x14AC, 0x23D3, 0x2CC4,
1899 0xB6B, 0xE6A, 0x13FD, 0x13FE, 0x2059, 0x1FC0, 0x3378, 0x3E16,
1900 0xFAE, 0x1A7F, 0x1778, 0x1C1A, 0x2ABA, 0x2198, 0x31D3, 0x2DAE,
1901 0x197C, 0x22F0, 0x2438, 0x20F1, 0x3378, 0x2E87, 0x3EFD, 0x3BFA,
1902 0x21D1, 0x2388, 0x209C, 0x1C52, 0x2AAF, 0x2A07, 0x3AD0, 0x3FF5
1904 0x5A8, 0x7E9, 0x852, 0x687, 0xA2F, 0xB30, 0x1D1E, 0x2F77,
1905 0x740, 0x938, 0x901, 0x93C, 0xE81, 0x1303, 0x2C52, 0x46AE,
1906 0x5F1, 0x9B2, 0x9FD, 0xAC6, 0x15FC, 0x1AEE, 0x30B0, 0x41C9,
1907 0x775, 0xA52, 0xBC0, 0xB24, 0x1A1B, 0x1895, 0x2A9A, 0x353D,
1908 0xD94, 0x1124, 0x17C5, 0x17C6, 0x2677, 0x25C2, 0x3D34, 0x49D5,
1909 0x12A5, 0x1F82, 0x1BE9, 0x216B, 0x32CF, 0x27F3, 0x3B40, 0x3653,
1910 0x1E4E, 0x298D, 0x2B12, 0x272C, 0x3D34, 0x3755, 0x4AE7, 0x4753,
1911 0x2836, 0x2A41, 0x26C7, 0x21AE, 0x32C3, 0x31FA, 0x45F1, 0x4C0E
1913 0x6BA, 0x968, 0x9E5, 0x7C3, 0xC1C, 0xD4E, 0x22A0, 0x3872,
1914 0x8A0, 0xAF7, 0xAB5, 0xAFB, 0x113F, 0x169C, 0x34B5, 0x540D,
1915 0x711, 0xB87, 0xBE1, 0xCD0, 0x1A25, 0x2007, 0x39E6, 0x4E3C,
1916 0x8DF, 0xC46, 0xDFA, 0xD3F, 0x1F0B, 0x1D3C, 0x32A9, 0x3F4F,
1917 0x1025, 0x1462, 0x1C44, 0x1C46, 0x2DBF, 0x2CE7, 0x48C9, 0x57CE,
1918 0x162D, 0x2578, 0x2131, 0x27BE, 0x3C6D, 0x2F82, 0x4676, 0x409A,
1919 0x240A, 0x3169, 0x3338, 0x2E96, 0x48C9, 0x41CD, 0x5914, 0x54D3,
1920 0x2FD2, 0x3240, 0x2E1E, 0x280E, 0x3C5E, 0x3B6F, 0x532D, 0x5A73
1924 const BINK2_QUANT_INTRA_CHROMA: &[[i32; 64]; 4] = &[
1926 0x400, 0x4A9, 0x59A, 0x89B, 0x1600, 0x1221, 0x171C, 0x19A3,
1927 0x4A9, 0x656, 0x713, 0xE16, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
1928 0x59A, 0x713, 0xDBB, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
1929 0x89B, 0xE16, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
1930 0x1600, 0x19A3, 0x171C, 0x1221, 0x1600, 0x1221, 0x171C, 0x19A3,
1931 0x1221, 0x1520, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
1932 0x171C, 0x1AEE, 0x1847, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
1933 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1
1935 0x4C2, 0x58B, 0x6AA, 0xA3C, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
1936 0x58B, 0x789, 0x869, 0x10C0, 0x1E7D, 0x1920, 0x2007, 0x2388,
1937 0x6AA, 0x869, 0x1054, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
1938 0xA3C, 0x10C0, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
1939 0x1A2A, 0x1E7D, 0x1B7B, 0x158F, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
1940 0x158F, 0x1920, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
1941 0x1B7B, 0x2007, 0x1CDE, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
1942 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388
1944 0x5A8, 0x698, 0x7EC, 0xC2C, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
1945 0x698, 0x8F6, 0xA01, 0x13EB, 0x2442, 0x1DE1, 0x2616, 0x2A41,
1946 0x7EC, 0xA01, 0x136B, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
1947 0xC2C, 0x13EB, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
1948 0x1F1D, 0x2442, 0x20AF, 0x19A3, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
1949 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
1950 0x20AF, 0x2616, 0x2255, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
1951 0x2442, 0x2A41, 0x2616, 0x1DE1, 0x2442, 0x1DE1, 0x2616, 0x2A41
1953 0x6BA, 0x7D7, 0x96C, 0xE7A, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
1954 0x7D7, 0xAA9, 0xBE5, 0x17B0, 0x2B1E, 0x2388, 0x2D4B, 0x3240,
1955 0x96C, 0xBE5, 0x1718, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
1956 0xE7A, 0x17B0, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
1957 0x2500, 0x2B1E, 0x26DE, 0x1E7D, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
1958 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
1959 0x26DE, 0x2D4B, 0x28D4, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
1960 0x2B1E, 0x3240, 0x2D4B, 0x2388, 0x2B1E, 0x2388, 0x2D4B, 0x3240
1964 const BINK2_QUANT_INTER: &[[i32; 64]; 4] = &[
1966 0x400, 0x4A9, 0x434, 0x34C, 0x41C, 0x392, 0x4C9, 0x5D4,
1967 0x4A9, 0x56F, 0x4E6, 0x3D7, 0x4CB, 0x429, 0x5B7, 0x718,
1968 0x434, 0x4E6, 0x489, 0x3A8, 0x4AB, 0x40A, 0x5A4, 0x6CD,
1969 0x34C, 0x3D7, 0x3A8, 0x32B, 0x41F, 0x39F, 0x519, 0x630,
1970 0x41C, 0x4CB, 0x4AB, 0x41F, 0x5AB, 0x538, 0x778, 0x932,
1971 0x392, 0x429, 0x40A, 0x39F, 0x538, 0x521, 0x799, 0x9B6,
1972 0x4C9, 0x5B7, 0x5A4, 0x519, 0x778, 0x799, 0xBE4, 0xFC7,
1973 0x5D4, 0x718, 0x6CD, 0x630, 0x932, 0x9B6, 0xFC7, 0x162F
1975 0x4C2, 0x58B, 0x4FF, 0x3EB, 0x4E4, 0x43F, 0x5B1, 0x6EE,
1976 0x58B, 0x676, 0x5D3, 0x491, 0x5B3, 0x4F3, 0x6CB, 0x86F,
1977 0x4FF, 0x5D3, 0x565, 0x459, 0x58D, 0x4CE, 0x6B5, 0x816,
1978 0x3EB, 0x491, 0x459, 0x3C5, 0x4E6, 0x44F, 0x610, 0x75C,
1979 0x4E4, 0x5B3, 0x58D, 0x4E6, 0x6BD, 0x635, 0x8E2, 0xAEF,
1980 0x43F, 0x4F3, 0x4CE, 0x44F, 0x635, 0x61A, 0x909, 0xB8C,
1981 0x5B1, 0x6CB, 0x6B5, 0x610, 0x8E2, 0x909, 0xE24, 0x12C3,
1982 0x6EE, 0x86F, 0x816, 0x75C, 0xAEF, 0xB8C, 0x12C3, 0x1A61
1984 0x5A8, 0x698, 0x5F1, 0x4A9, 0x5D0, 0x50D, 0x6C4, 0x83E,
1985 0x698, 0x7AF, 0x6ED, 0x56F, 0x6C7, 0x5E3, 0x814, 0xA08,
1986 0x5F1, 0x6ED, 0x66A, 0x52B, 0x69A, 0x5B6, 0x7FA, 0x99E,
1987 0x4A9, 0x56F, 0x52B, 0x47B, 0x5D4, 0x51F, 0x735, 0x8C1,
1988 0x5D0, 0x6C7, 0x69A, 0x5D4, 0x804, 0x761, 0xA90, 0xD00,
1989 0x50D, 0x5E3, 0x5B6, 0x51F, 0x761, 0x741, 0xABF, 0xDBB,
1990 0x6C4, 0x814, 0x7FA, 0x735, 0xA90, 0xABF, 0x10D2, 0x1650,
1991 0x83E, 0xA08, 0x99E, 0x8C1, 0xD00, 0xDBB, 0x1650, 0x1F5F
1993 0x6BA, 0x7D7, 0x711, 0x58B, 0x6EA, 0x601, 0x80C, 0x9CD,
1994 0x7D7, 0x923, 0x83C, 0x676, 0x80F, 0x700, 0x99C, 0xBEE,
1995 0x711, 0x83C, 0x7A1, 0x626, 0x7DA, 0x6CB, 0x97C, 0xB70,
1996 0x58B, 0x676, 0x626, 0x554, 0x6EE, 0x617, 0x893, 0xA68,
1997 0x6EA, 0x80F, 0x7DA, 0x6EE, 0x988, 0x8C7, 0xC90, 0xF76,
1998 0x601, 0x700, 0x6CB, 0x617, 0x8C7, 0x8A1, 0xCC7, 0x1055,
1999 0x80C, 0x99C, 0x97C, 0x893, 0xC90, 0xCC7, 0x1400, 0x1A89,
2000 0x9CD, 0xBEE, 0xB70, 0xA68, 0xF76, 0x1055, 0x1A89, 0x254E
2004 const BINK2_AC_CODES1: &[u8] = &[
2005 0x01, 0x04, 0x00, 0x08, 0x02, 0x32, 0x0A, 0x12,
2006 0x3A, 0x7A, 0xFA, 0x72, 0x06, 0x1A
2008 const BINK2_AC_BITS1: &[u8] = &[ 1, 3, 4, 4, 5, 7, 5, 6, 7, 8, 8, 7, 3, 6 ];
2009 const BINK2_AC_CODES2: &[u16] = &[
2010 0x01, 0x00, 0x04, 0x2C, 0x6C, 0x0C, 0x4C, 0xAC,
2011 0xEC, 0x12C, 0x16C, 0x1AC, 0x02, 0x1C
2013 const BINK2_AC_BITS2: &[u8] = &[ 1, 3, 4, 9, 9, 7, 7, 9, 8, 9, 9, 9, 2, 5 ];
2015 const BINK2_AC_RUNS: [usize; 14] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 64, 0 ];
2017 const BINK2_MV_CODES: &[u8] = &[
2018 0x01, 0x06, 0x0C, 0x1C, 0x18, 0x38, 0x58, 0x78,
2019 0x68, 0x48, 0x28, 0x08, 0x14, 0x04, 0x02, 0x00
2021 const BINK2_MV_BITS: &[u8] = &[
2022 1, 3, 5, 5, 7, 7, 7, 7,
2023 7, 7, 7, 7, 5, 5, 3, 4
2025 const BINK2_MV_ESC: i8 = 42;
2026 const BINK2_MV_SYMS: &[i8] = &[
2027 0, 1, 2, 3, 4, 5, 6, 7,
2028 -7, -6, -5, -4, -3, -2, -1, BINK2_MV_ESC
2031 const BINK2_AC_VAL_CODES1: &[u16] = &[
2032 0x004, 0x01, 0x002, 0x00, 0x08, 0x18, 0xF8, 0x178,
2033 0x138, 0x38, 0x1B8, 0x78, 0xB8
2035 const BINK2_AC_VAL_BITS1: &[u8] = &[ 3, 1, 2, 4, 5, 6, 8, 9, 9, 9, 9, 9, 9 ];
2036 const BINK2_AC_VAL_CODES2: &[u16] = &[
2037 0x0A, 0x001, 0x004, 0x08, 0x06, 0x00, 0x02, 0x1A,
2038 0x2A, 0x16A, 0x1EA, 0x6A, 0xEA
2040 const BINK2_AC_VAL_BITS2: &[u8] = &[ 6, 1, 3, 4, 3, 4, 4, 5, 7, 9, 9, 9, 9 ];
2041 const BINK2_AC_SKIP_CODES1: &[u16] = &[
2042 0x00, 0x001, 0x0D, 0x15, 0x45, 0x85, 0xA5, 0x165,
2043 0x65, 0x1E5, 0xE5, 0x25, 0x03, 0x05
2045 const BINK2_AC_SKIP_BITS1: &[u8] = &[ 1, 3, 4, 5, 7, 8, 8, 9, 9, 9, 9, 8, 2, 8 ];
2046 const BINK2_AC_SKIP_CODES2: &[u16] = &[
2047 0x00, 0x01, 0x003, 0x07, 0x1F, 0x1B, 0x0F, 0x2F,
2048 0x5B, 0xDB, 0x1DB, 0x3B, 0x05, 0x0B
2050 const BINK2_AC_SKIP_BITS2: &[u8] = &[ 1, 3, 4, 4, 5, 7, 6, 6, 8, 9, 9, 6, 3, 5 ];
2051 const BINK2_QUANT_CODES: &[u8] = &[
2052 0x01, 0x02, 0x04, 0x08, 0x10, 0x30, 0x50, 0x70,
2053 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
2055 const BINK2_QUANT_BITS: &[u8] = &[ 1, 2, 3, 4, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8 ];
2057 const BINK2_OLD_QUANTS: [f32; 16] = [
2058 1.0, 2.0, 2.5, 3.0, 3.5, 4.0, 6.0, 7.0, 8.0, 12.0, 16.0, 24.0, 32.0, 48.0, 64.0, 128.0
2060 const BINK2_OLD_DC_QUANTS: [i32; 16] = [
2061 4, 4, 4, 4, 4, 6, 7, 8, 10, 12, 16, 24, 32, 48, 64, 128
2063 const BINK2_DC_EXTRA_BITS: [u8; 16] = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 6 ];
2064 const BINK2_QMAT_INTRA_LUMA_OLD: &[f32; 64] = &[
2065 0.125, 0.208056, 0.22864901, 0.205778, 0.22499999, 0.235708, 0.33148301, 0.248309,
2066 0.190718, 0.288582, 0.29449099, 0.34658501, 0.38143599, 0.47678301, 0.600528, 0.44008601,
2067 0.16332, 0.31714499, 0.34142101, 0.42249799, 0.604285, 0.70576, 0.68942899, 0.42807001,
2068 0.235175, 0.38735899, 0.46090701, 0.50122303, 0.82311302, 0.73910397, 0.69206202, 0.39741901,
2069 0.30000001, 0.45078799, 0.65328097, 0.74962097, 0.85000002, 0.79551601, 0.69678998, 0.38625899,
2070 0.392847, 0.79009801, 0.73142397, 1.004719, 1.070509, 0.80251199, 0.64313799, 0.27096599,
2071 0.34501299, 0.56299502, 0.60987997, 0.636379, 0.69678998, 0.60061598, 0.43934, 0.19224399,
2072 0.210373, 0.26309499, 0.252336, 0.25142801, 0.265553, 0.24928901, 0.188511, 0.094199002
2074 const BINK2_QMAT_CHROMA_OLD: &[f32; 64] = &[
2075 0.125, 0.17338, 0.217761, 0.383793, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2076 0.17338, 0.28056601, 0.32721299, 0.74753499, 0.95358998, 0.74923098, 0.51607901, 0.26309499,
2077 0.217761, 0.32721299, 0.66387498, 1.056244, 0.89826202, 0.70576, 0.48613599, 0.24783,
2078 0.383793, 0.74753499, 1.056244, 0.95059502, 0.80841398, 0.635167, 0.437511, 0.223041,
2079 0.6875, 0.95358998, 0.89826202, 0.80841398, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2080 0.54016501, 0.74923098, 0.70576, 0.635167, 0.54016501, 0.42440501, 0.292335, 0.149031,
2081 0.37207201, 0.51607901, 0.48613599, 0.437511, 0.37207201, 0.292335, 0.201364, 0.102655,
2082 0.18968099, 0.26309499, 0.24783, 0.223041, 0.18968099, 0.149031, 0.102655, 0.052333001
2084 const BINK2_QMAT_INTER_LUMA_OLD: &[f32; 64] = &[
2085 0.125, 0.17338, 0.16332, 0.146984, 0.128475, 0.106393, 0.077045999, 0.043109,
2086 0.17338, 0.240485, 0.226532, 0.20387299, 0.17820001, 0.147571, 0.109474, 0.062454,
2087 0.16332, 0.226532, 0.219321, 0.202722, 0.181465, 0.149711, 0.112943, 0.062583998,
2088 0.146984, 0.20387299, 0.202722, 0.201647, 0.183731, 0.15397599, 0.11711, 0.065334998,
2089 0.128475, 0.17820001, 0.181465, 0.183731, 0.17708801, 0.155499, 0.120267, 0.068016,
2090 0.106393, 0.147571, 0.149711, 0.15397599, 0.155499, 0.14575601, 0.116636, 0.068494998,
2091 0.077045999, 0.109474, 0.112943, 0.11711, 0.120267, 0.116636, 0.098646, 0.060141001,
2092 0.043109, 0.062454, 0.062583998, 0.065334998, 0.068016, 0.068494998, 0.060141001, 0.038853001