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::*;
9 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
10 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
13 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
17 macro_rules! idct_mul {
18 (a; $val: expr) => ($val + ($val >> 2));
19 (b; $val: expr) => ($val >> 1);
20 (c; $val: expr) => ($val - ($val >> 2) - ($val >> 4));
21 (d; $val: expr) => ($val + ($val >> 2) - ($val >> 4));
22 (e; $val: expr) => ($val >> 2);
26 ($src: expr, $sstep: expr, $off: expr, $dst: expr, $dstep: expr, $doff: expr, $bias: expr, $shift: expr) => {
27 let tmp00 = $src[$off + 3 * $sstep] + $src[$off + 5 * $sstep];
28 let tmp01 = $src[$off + 3 * $sstep] - $src[$off + 5 * $sstep];
29 let tmp02 = idct_mul!(a; $src[$off + 2 * $sstep]) + idct_mul!(b; $src[$off + 6 * $sstep]);
30 let tmp03 = idct_mul!(b; $src[$off + 2 * $sstep]) - idct_mul!(a; $src[$off + 6 * $sstep]);
31 let tmp0 = ($src[$off + 0 * $sstep] + $src[$off + 4 * $sstep]) + tmp02;
32 let tmp1 = ($src[$off + 0 * $sstep] + $src[$off + 4 * $sstep]) - tmp02;
33 let tmp2 = $src[$off + 0 * $sstep] - $src[$off + 4 * $sstep];
34 let tmp3 = $src[$off + 1 * $sstep] + tmp00;
35 let tmp4 = $src[$off + 1 * $sstep] - tmp00;
36 let tmp5 = tmp01 + $src[$off + 7 * $sstep];
37 let tmp6 = tmp01 - $src[$off + 7 * $sstep];
38 let tmp7 = tmp4 + idct_mul!(c; tmp6);
39 let tmp8 = idct_mul!(c; tmp4) - tmp6;
40 let tmp9 = idct_mul!(d; tmp3) + idct_mul!(e; tmp5);
41 let tmp10 = idct_mul!(e; tmp3) - idct_mul!(d; tmp5);
42 let tmp11 = tmp2 + tmp03;
43 let tmp12 = tmp2 - tmp03;
45 $dst[$doff + 0 * $dstep] = (tmp0 + tmp9 + $bias) >> $shift;
46 $dst[$doff + 1 * $dstep] = (tmp11 + tmp7 + $bias) >> $shift;
47 $dst[$doff + 2 * $dstep] = (tmp12 + tmp8 + $bias) >> $shift;
48 $dst[$doff + 3 * $dstep] = (tmp1 + tmp10 + $bias) >> $shift;
49 $dst[$doff + 4 * $dstep] = (tmp1 - tmp10 + $bias) >> $shift;
50 $dst[$doff + 5 * $dstep] = (tmp12 - tmp8 + $bias) >> $shift;
51 $dst[$doff + 6 * $dstep] = (tmp11 - tmp7 + $bias) >> $shift;
52 $dst[$doff + 7 * $dstep] = (tmp0 - tmp9 + $bias) >> $shift;
54 (float; $src: expr, $sstep: expr, $off: expr, $dst: expr, $dstep: expr, $doff: expr, $bias: expr, $shift: expr) => {
55 let t00 = $src[$off + $sstep * 2] + $src[$off + $sstep * 6];
56 let t01 = ($src[$off + $sstep * 2] - $src[$off + $sstep * 6]) * 1.4142135 - t00;
57 let t02 = $src[$off + $sstep * 0] + $src[$off + $sstep * 4];
58 let t03 = $src[$off + $sstep * 0] - $src[$off + $sstep * 4];
59 let t04 = $src[$off + $sstep * 3] + $src[$off + $sstep * 5];
60 let t05 = $src[$off + $sstep * 3] - $src[$off + $sstep * 5];
61 let t06 = $src[$off + $sstep * 1] + $src[$off + $sstep * 7];
62 let t07 = $src[$off + $sstep * 1] - $src[$off + $sstep * 7];
68 let t13 = (t06 - t04) * 1.4142135;
69 let t14 = (t07 - t05) * 1.847759;
70 let t15 = t05 * 2.613126 + t14 - t12;
72 let t17 = t07 * 1.0823922 - t14 + t16;
74 $dst[$doff + 0 * $dstep] = t08 + t12;
75 $dst[$doff + 1 * $dstep] = t10 + t15;
76 $dst[$doff + 2 * $dstep] = t11 + t16;
77 $dst[$doff + 3 * $dstep] = t09 - t17;
78 $dst[$doff + 4 * $dstep] = t09 + t17;
79 $dst[$doff + 5 * $dstep] = t11 - t16;
80 $dst[$doff + 6 * $dstep] = t10 - t15;
81 $dst[$doff + 7 * $dstep] = t08 - t12;
85 fn bink2_idct(coeffs: &mut [i32; 64]) {
86 let mut tmp: [i32; 64] = [0; 64];
88 idct!(coeffs, 1, 8 * i, tmp, 8, i, 0, 0);
91 idct!(tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
95 fn bink2_idct_old(coeffs: &mut [f32; 64]) {
96 let mut tmp: [f32; 64] = [0.0; 64];
99 idct!(float; coeffs, 8, i, tmp, 8, i, 0, 0);
102 idct!(float; tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
108 fn clip8(val: i32) -> u8 {
109 val.min(255).max(0) as u8
113 ($src: expr, $off: expr) => (
118 macro_rules! luma_filter {
119 ($src: expr, $off: expr, $step: expr) => ({
120 let t0 = el!($src, $off - 0 * $step) + el!($src, $off + 1 * $step);
121 let t1 = el!($src, $off - 1 * $step) + el!($src, $off + 2 * $step);
122 let t2 = el!($src, $off - 2 * $step) + el!($src, $off + 3 * $step);
123 (((t0 * 19) >> 1) - t1 * 2 + (t2 >> 1) + 8) >> 4
127 macro_rules! chroma_interp {
128 ($dst: expr, $dstride: expr, $h: expr, $ty: tt, $src: expr, $sstride: expr, $step: expr, $mode: expr, $shift: expr) => {
130 for out in $dst.chunks_mut($dstride).take($h) {
132 let e0 = el!($src, soff + i);
133 let e1 = el!($src, soff + i + $step);
134 out[i] = match $mode {
136 1 => (e0 * 3 + e1 + $shift) >> $shift,
137 2 => (e0 * 2 + e1 * 2 + $shift) >> $shift,
138 _ => (e0 + e1 * 3 + $shift) >> $shift,
146 macro_rules! avg_tree {
147 ($a: expr, $b: expr) => (($a + $b + 1) >> 1);
148 ($a: expr, $b: expr, $c: expr, $d: expr) => (avg_tree!(avg_tree!($a, $b), avg_tree!($c, $d)));
152 fn calc_dc(src: &[u8], stride: usize) -> i32 {
153 let mut sums = [0u16; 8];
155 let s0 = src[i + stride * 0] as u16;
156 let s1 = src[i + stride * 1] as u16;
157 let s2 = src[i + stride * 2] as u16;
158 let s3 = src[i + stride * 3] as u16;
159 let s4 = src[i + stride * 4] as u16;
160 let s5 = src[i + stride * 5] as u16;
161 let s6 = src[i + stride * 6] as u16;
162 let s7 = src[i + stride * 7] as u16;
163 sums[i] = avg_tree!(avg_tree!(s0, s1, s2, s3), avg_tree!(s4, s5, s6, s7));
166 for e in sums.iter() {
171 fn put_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
172 bink2_idct(&mut blk[0]);
173 bink2_idct(&mut blk[1]);
174 bink2_idct(&mut blk[2]);
175 bink2_idct(&mut blk[3]);
177 let dout = &mut dst[off..];
178 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
179 for i in 0..8 { row[i + 0] = clip8(b0[i]); }
180 for i in 0..8 { row[i + 8] = clip8(b1[i]); }
185 let dout = &mut dst[off..];
186 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
187 for i in 0..8 { row[i + 0] = clip8(b2[i]); }
188 for i in 0..8 { row[i + 8] = clip8(b3[i]); }
192 fn add_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
193 bink2_idct(&mut blk[0]);
194 bink2_idct(&mut blk[1]);
195 bink2_idct(&mut blk[2]);
196 bink2_idct(&mut blk[3]);
198 let dout = &mut dst[off..];
199 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
200 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b0[i]); }
201 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b1[i]); }
206 let dout = &mut dst[off..];
207 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
208 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b2[i]); }
209 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b3[i]); }
213 fn put_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
214 bink2_idct_old(&mut blk[0]);
215 bink2_idct_old(&mut blk[1]);
216 bink2_idct_old(&mut blk[2]);
217 bink2_idct_old(&mut blk[3]);
219 let dout = &mut dst[off..];
220 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
221 for i in 0..8 { row[i + 0] = clip8((b0[i] as i32) - 512); }
222 for i in 0..8 { row[i + 8] = clip8((b1[i] as i32) - 512); }
227 let dout = &mut dst[off..];
228 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
229 for i in 0..8 { row[i + 0] = clip8((b2[i] as i32) - 512); }
230 for i in 0..8 { row[i + 8] = clip8((b3[i] as i32) - 512); }
234 fn add_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
235 bink2_idct_old(&mut blk[0]);
236 bink2_idct_old(&mut blk[1]);
237 bink2_idct_old(&mut blk[2]);
238 bink2_idct_old(&mut blk[3]);
240 let dout = &mut dst[off..];
241 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
242 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b0[i] as i32) - 512); }
243 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b1[i] as i32) - 512); }
248 let dout = &mut dst[off..];
249 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
250 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b2[i] as i32) - 512); }
251 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b3[i] as i32) - 512); }
255 fn mc_luma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
256 let sx = (xoff as isize) + ((mv.x >> 1) as isize);
257 let sy = (yoff as isize) + ((mv.y >> 1) as isize);
258 let mode = (mv.x & 1) + (mv.y & 1) * 2;
259 let (d_x, add_x) = if (mv.x & 1) != 0 { (2, 5) } else { (0, 0) };
260 let (d_y, add_y) = if (mv.y & 1) != 0 { (2, 5) } else { (0, 0) };
262 let (w, h) = ref_pic.get_dimensions(plane);
263 let align_w = ((w + 31) & !31) as isize;
264 let align_h = ((h + 31) & !31) as isize;
265 validate!((sx - d_x >= 0) && (sx - d_x + add_x + 16 <= align_w));
266 validate!((sy - d_y >= 0) && (sy - d_y + add_y + 16 <= align_h));
267 let pstride = ref_pic.get_stride(plane);
268 let mut poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
269 let pdata = ref_pic.get_data();
270 let ppix = pdata.as_slice();
272 let dst = &mut dst[xoff + (yoff & 31) * stride..];
276 let src = &ppix[poff..];
277 for (out, row) in dst.chunks_mut(stride).take(16).zip(src.chunks(pstride)) {
278 for i in 0..16 { out[i] = row[i]; }
282 for out in dst.chunks_mut(stride).take(16) {
284 out[i] = clip8(luma_filter!(ppix, poff + i, 1));
290 for out in dst.chunks_mut(stride).take(16) {
292 out[i] = clip8(luma_filter!(ppix, poff + i, pstride));
298 let mut tmp = [0i16; 21 * 16];
299 for out in tmp.chunks_mut(16) {
301 out[i] = luma_filter!(ppix, poff - 2 * pstride + i, 1) as i16;
305 for (row, out) in dst.chunks_mut(stride).take(16).enumerate() {
307 out[i] = clip8(luma_filter!(tmp, (row + 2) * 16 + i, 16));
315 fn mc_chroma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
316 let sx = (xoff as isize) + ((mv.x >> 2) as isize);
317 let sy = (yoff as isize) + ((mv.y >> 2) as isize);
320 let add_x = if mx != 0 { 1 } else { 0 };
321 let add_y = if my != 0 { 1 } else { 0 };
323 let (w, h) = ref_pic.get_dimensions(plane);
324 let align_w = ((w + 15) & !15) as isize;
325 let align_h = ((h + 15) & !15) as isize;
326 validate!((sx >= 0) && (sx + add_x + 8 <= align_w));
327 validate!((sy >= 0) && (sy + add_y + 8 <= align_h));
328 let pstride = ref_pic.get_stride(plane);
329 let poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
330 let pdata = ref_pic.get_data();
331 let ppix = pdata.as_slice();
333 let dst = &mut dst[xoff + (yoff & 15) * stride..];
334 if (mx == 0) && (my == 0) {
335 let inpix = &ppix[poff..];
336 for (out, src) in dst.chunks_mut(stride).take(8).zip(inpix.chunks(pstride)) {
337 for i in 0..8 { out[i] = src[i]; }
340 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, 1, mx, 2);
342 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, pstride, my, 2);
344 let mut tmp = [0u16; 9 * 8];
345 chroma_interp!(tmp, 8, 9, u16, &ppix[poff..], pstride, 1, mx, 0);
346 chroma_interp!(dst, stride, 8, u8, &tmp, 8, 8, my, 4);
352 fn mid_pred<T:PartialOrd>(a: T, b: T, c: T) -> T {
357 if a < c { c } else { a }
361 if a < c { a } else { c }
377 fn resize(&mut self, bw: usize) {
378 self.qstride = bw * 2;
379 self.quants.resize(self.qstride * 2, 0);
381 self.pqpos = self.qstride;
383 fn update_line(&mut self) {
384 mem::swap(&mut self.qpos, &mut self.pqpos);
386 fn pred_quant(&self, pos: usize, is_top: bool) -> u8 {
387 let is_left = pos < 2;
389 if is_left { 16 } else { self.quants[self.qpos + pos - 2] }
392 self.quants[self.pqpos + pos]
394 mid_pred(self.quants[self.pqpos + pos - 2],
395 self.quants[self.pqpos + pos],
396 self.quants[self.qpos + pos - 2])
400 fn set_quant(&mut self, pos: usize, q: u8) {
401 self.quants[self.qpos + pos] = q;
416 fn resize(&mut self, bw: usize) {
417 self.stride = bw * 4 + 4;
419 self.prev_dcs.resize(self.stride, 0);
420 self.new_dcs.resize(self.stride, 0);
422 fn update_line(&mut self) {
423 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
425 fn set_dcs(&mut self, bx: usize, dc5: i32, dc7: i32, dc13: i32, dc10: i32, dc11: i32, dc14: i32, dc15: i32) {
430 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
449 fn resize(&mut self, bw: usize) {
450 self.stride = bw * 2 + 2;
452 self.prev_dcs.resize(self.stride, 0);
453 self.new_dcs.resize(self.stride, 0);
455 fn update_line(&mut self) {
456 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
458 fn set_dcs(&mut self, bx: usize, dc1: i32, dc2: i32, dc3: i32) {
462 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
469 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool>;
470 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32);
471 fn predict_inter(&mut self, min_dc: i32, max_dc: i32);
474 fn dc_pred2(a: i32, b: i32) -> i32 {
475 (a.max(b)).min(a.min(b).max(a * 2 - b))
477 fn dc_pred(a: i32, b: i32, c: i32) -> i32 {
478 (a.max(b).max(c)).min((a.min(b).min(c)).max(b - a + c))
481 impl DCInfo for YDCInfo {
482 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
483 decode_dcs(br, &mut self.dc_buf, q)
485 #[allow(non_snake_case)]
486 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
487 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
488 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
489 let prev_dc = &self.prev_dcs[bx * 4..];
490 let dst = &mut self.dcs;
491 let dcs = &self.dc_buf;
493 if is_top { //zigzag in 2x2 blocks
494 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
495 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
496 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
497 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
498 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
500 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
501 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
502 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
503 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
505 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
506 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
507 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
508 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
510 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
511 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
512 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
513 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
515 a0 = (dcs[ 0] + dc_pred2(prev_dc[4], prev_dc[5])).max(min_dc).min(max_dc);
516 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
517 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
518 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
520 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
521 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
522 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
523 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
525 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
526 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
527 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
528 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
530 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
531 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
532 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
533 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
537 a0 = (dcs[ 0] + dc_pred2(dst[5], dst[7])).max(min_dc).min(max_dc);
538 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
539 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
540 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
542 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
543 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
544 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
545 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
547 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
548 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
549 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
550 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
552 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
553 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
554 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
555 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
557 a0 = (dcs[ 0] + dc_pred(prev_dc[3], prev_dc[4], dst[5])).max(min_dc).min(max_dc);
558 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
559 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
560 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
562 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
563 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
564 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
565 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
567 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
568 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
569 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
570 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
572 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
573 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
574 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
575 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
594 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
600 #[allow(non_snake_case)]
601 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
602 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
603 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
604 let dst = &mut self.dcs;
605 let dcs = &self.dc_buf;
606 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
607 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
608 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
609 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
611 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
612 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
613 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
614 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
616 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
617 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
618 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
619 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
621 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
622 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
623 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
624 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
645 impl DCInfo for CDCInfo {
646 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
647 decode_dcs(br, &mut self.dc_buf, q)
649 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
650 let prev_dc = &self.prev_dcs[bx * 2..];
651 let dst = &mut self.dcs;
652 let dcs = &self.dc_buf;
654 let a0; let a1; let a2; let a3;
657 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
658 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
659 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
661 a0 = (dcs[ 0] + dc_pred2(prev_dc[2], prev_dc[3])).max(min_dc).min(max_dc);
662 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
664 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
665 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
668 a0 = (dcs[ 0] + dc_pred2(dst[1], dst[3])).max(min_dc).min(max_dc);
669 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
671 a0 = (dcs[ 0] + dc_pred(prev_dc[1], prev_dc[2], dst[1])).max(min_dc).min(max_dc);
672 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
674 a2 = (dcs[ 2] + dc_pred(dst[1], dst[3], a0)).max(min_dc).min(max_dc);
675 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
681 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
685 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
686 let dst = &mut self.dcs;
687 let dcs = &self.dc_buf;
689 let a0; let a1; let a2; let a3;
691 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
692 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
693 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
694 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
703 fn decode_dcs(br: &mut BitReader, dcs: &mut [i32], q: u8) -> DecoderResult<bool> {
704 if !br.read_bool()? {
705 for dc in dcs.iter_mut() {
710 let quant = BINK2_QUANT_DC[q.max(8) as usize];
711 for dc in dcs.iter_mut() {
712 *dc = br.read_bink2_code_zero()?;
714 *dc = (*dc * quant + 0x1FF) >> 10;
732 fn resize(&mut self, bw: usize) {
733 self.stride = bw * 4;
735 self.prev_off = self.stride;
736 self.mvs.resize(self.stride * 2, ZERO_MV);
738 fn update_line(&mut self) {
739 mem::swap(&mut self.mv_off, &mut self.prev_off);
741 fn decode_mv_new(&mut self, br: &mut BitReader, mv_cb: &Codebook<i8>, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
742 let num_mv = if br.read_bool()? { 1 } else { 4 };
743 let mv = &mut self.mvs;
744 let mv_pos = self.mv_off + bx * 4;
745 let ref_pos = self.prev_off + bx * 4;
750 let raw_val = br.read_cb(mv_cb)?;
751 if raw_val != BINK2_MV_ESC {
752 val = raw_val as i16;
754 let len = br.read_code(UintCodeType::LimitedUnary(12, 1))? as u8;
756 let uval = (br.read(nlen)? as i32) + (1 << nlen) - 1;
758 val = (-(uval >> 1) - 1) as i16;
760 val = (uval >> 1) as i16;
764 mv[mv_pos + i].x = val;
766 mv[mv_pos + i].y = val;
774 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
775 mv[mv_pos + 0] = mv0;
776 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
777 mv[mv_pos + 2] = mv2;
778 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
779 mv[mv_pos + 1] = mv1;
780 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
781 mv[mv_pos + 3] = mv3;
783 let mv1 = mv[mv_pos + 1] + mv[mv_pos + 0];
784 mv[mv_pos + 1] = mv1;
785 let mv2 = mv[mv_pos + 2] + mv[mv_pos + 0];
786 mv[mv_pos + 2] = mv2;
787 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
788 mv[mv_pos + 3] = mv3;
792 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
793 mv[mv_pos + 0] = mv0;
794 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
795 mv[mv_pos + 1] = mv1;
796 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
797 mv[mv_pos + 2] = mv2;
798 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
799 mv[mv_pos + 3] = mv3;
801 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 2], mv[ref_pos - 1], mv[mv_pos - 3]);
802 mv[mv_pos + 0] = mv0;
803 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
804 mv[mv_pos + 1] = mv1;
805 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
806 mv[mv_pos + 2] = mv2;
807 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
808 mv[mv_pos + 3] = mv3;
812 let mut mv_pred = mv[mv_pos + 0];
815 mv_pred += MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
819 mv_pred += MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
821 mv_pred += MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
824 mv[mv_pos + 0] = mv_pred;
825 mv[mv_pos + 1] = mv_pred;
826 mv[mv_pos + 2] = mv_pred;
827 mv[mv_pos + 3] = mv_pred;
831 fn decode_mv_old(&mut self, br: &mut BitReader, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
832 let mv = &mut self.mvs;
833 let mv_pos = self.mv_off + bx * 4;
834 let ref_pos = self.prev_off + bx * 4;
839 let mut bits = br.read(3)? as u8;
841 bits += br.read(2)? as u8;
843 let mut mv_c: [i16; 4] = [0; 4];
846 mv_c[i] = br.read(bits)? as i16;
849 if (mv_c[i] != 0) && br.read_bool()? {
854 if is_top && is_left {
855 let mut val = br.read(5)? as i16;
856 if (val != 0) && br.read_bool()? {
867 mv[mv_pos + i].x = mv_c[i];
871 mv[mv_pos + i].y = mv_c[i];
877 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
878 mv[mv_pos + 0] = mv0;
879 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
880 mv[mv_pos + 1] = mv1;
881 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
882 mv[mv_pos + 2] = mv2;
883 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
884 mv[mv_pos + 3] = mv3;
886 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
887 mv[mv_pos + 0] = mv0;
888 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
889 mv[mv_pos + 1] = mv1;
890 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
891 mv[mv_pos + 2] = mv2;
892 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
893 mv[mv_pos + 3] = mv3;
897 let base_mv = MV { x: basex * 16, y: basey * 16 };
898 mv[mv_pos + 0] += base_mv;
899 mv[mv_pos + 1] += base_mv;
900 mv[mv_pos + 2] += base_mv;
901 mv[mv_pos + 3] += base_mv;
903 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
904 mv[mv_pos + 0] = mv0;
905 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
906 mv[mv_pos + 2] = mv2;
907 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
908 mv[mv_pos + 1] = mv1;
909 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
910 mv[mv_pos + 3] = mv3;
916 fn predict_mvs(&mut self, bx: usize, is_top: bool, is_left: bool, is_new: bool) {
917 let mv = &mut self.mvs;
918 let mv_pos = self.mv_off + bx * 4;
919 let ref_pos = self.prev_off + bx * 4;
924 mv[mv_pos + i] = ZERO_MV;
927 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
928 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
929 mv[mv_pos + 1] = MV::pred(mv[mv_pos - 1], mv[mv_pos + 0], mv[mv_pos + 2]);
930 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
934 mv[mv_pos + 0] = MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
935 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
936 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
937 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
939 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 3], mv[ref_pos - 1], mv[ref_pos + 2]);
940 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
942 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
944 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
946 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
951 fn get_mv(&self, bx: usize, blk: usize) -> MV { self.mvs[self.mv_off + bx * 4 + blk] }
952 fn zero(&mut self, bx: usize) {
953 let pos = self.mv_off + bx * 4;
954 self.mvs[pos + 0] = ZERO_MV;
955 self.mvs[pos + 1] = ZERO_MV;
956 self.mvs[pos + 2] = ZERO_MV;
957 self.mvs[pos + 3] = ZERO_MV;
962 ac_cb1: Codebook<u8>,
963 ac_cb2: Codebook<u8>,
965 val_cb1: Codebook<u8>,
966 val_cb2: Codebook<u8>,
967 skip_cb1: Codebook<u8>,
968 skip_cb2: Codebook<u8>,
969 quant_cb: Codebook<u8>,
972 fn map_ac(idx: usize) -> u8 { idx as u8 }
973 fn map_mv(idx: usize) -> i8 { BINK2_MV_SYMS[idx] }
975 impl Default for Bink2Codes {
976 fn default() -> Self {
977 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES1, BINK2_AC_BITS1, map_ac);
978 let ac_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
979 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES2, BINK2_AC_BITS2, map_ac);
980 let ac_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
981 let mut cbr = TableCodebookDescReader::new(BINK2_MV_CODES, BINK2_MV_BITS, map_mv);
982 let mv_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
983 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES1, BINK2_AC_VAL_BITS1, map_ac);
984 let val_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
985 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES2, BINK2_AC_VAL_BITS2, map_ac);
986 let val_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
987 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES1, BINK2_AC_SKIP_BITS1, map_ac);
988 let skip_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
989 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES2, BINK2_AC_SKIP_BITS2, map_ac);
990 let skip_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
991 let mut cbr = TableCodebookDescReader::new(BINK2_QUANT_CODES, BINK2_QUANT_BITS, map_ac);
992 let quant_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
993 Self { ac_cb1, ac_cb2, mv_cb, val_cb1, val_cb2, skip_cb1, skip_cb2, quant_cb }
998 struct Bink2Decoder {
999 info: Rc<NACodecInfo>,
1004 slice_h: [usize; 8],
1025 fn decode_frame_new(&mut self, br: &mut BitReader, buf: &mut NAVideoBuffer<u8>, is_intra: bool) -> DecoderResult<()> {
1026 let (stride_y, stride_u, stride_v, stride_a) = (buf.get_stride(0), buf.get_stride(1), buf.get_stride(2), buf.get_stride(3));
1027 let (mut off_y, mut off_u, mut off_v, mut off_a) = (buf.get_offset(0), buf.get_offset(1), buf.get_offset(2), buf.get_offset(3));
1028 let (ooff_y, ooff_u, ooff_v, ooff_a) = (off_y, off_u, off_v, off_a);
1029 let (width, height) = buf.get_dimensions(0);
1030 let data = buf.get_data_mut().unwrap();
1031 let dst = data.as_mut_slice();
1032 let bw = (width + 31) >> 5;
1033 let bheight = (height + 31) >> 5;
1034 self.cur_w = (width + 7) & !7;
1035 self.cur_h = ((height + 7) & !7) >> 1;
1037 let frame_flags = br.read(32)?;
1038 let mut offsets: [u32; 7] = [0; 7];
1039 for i in 0..self.num_slices-1 {
1040 offsets[i] = br.read(32)?;
1042 let mut do_alpha = self.has_alpha;
1043 if (frame_flags & 0x80000) != 0 && self.has_alpha {
1045 let fillval = (frame_flags >> 24) as u8;
1046 let aplane = &mut dst[off_a..][..stride_a * bheight * 32];
1047 for el in aplane.iter_mut() {
1051 let mut row_flags: Vec<bool> = Vec::with_capacity(bheight * 4);
1052 let mut col_flags: Vec<bool> = Vec::with_capacity(bw * 4);
1053 if (frame_flags & 0x10000) != 0 {
1054 if (frame_flags & 0x8000) == 0 {
1055 let len = (height + 15) >> 4;
1056 decode_flags(br, &mut row_flags, 1, len * 2 - 1)?;
1058 if (frame_flags & 0x4000) == 0 {
1059 let len = (width + 15) >> 4;
1060 decode_flags(br, &mut col_flags, 1, len * 2 - 1)?;
1063 row_flags.resize(bheight * 4, false);
1064 col_flags.resize(bw * 4, false);
1065 //store frame_flags * 8 & 0x7F8
1067 let mut start_by = 0;
1068 for slice_no in 0..self.num_slices {
1069 let end_by = self.slice_h[slice_no];
1071 br.seek(offsets[slice_no - 1] * 8)?;
1073 off_y = ooff_y + stride_y * start_by * 32;
1074 off_u = ooff_u + stride_u * start_by * 16;
1075 off_v = ooff_v + stride_v * start_by * 16;
1076 off_a = ooff_a + stride_a * start_by * 32;
1078 let mut row_state = frame_flags & 0x2E000;
1080 row_state |= 0x10000;
1082 self.qinfo.resize(bw);
1083 self.y_dcs.resize(bw);
1084 self.u_dcs.resize(bw);
1085 self.v_dcs.resize(bw);
1086 self.a_dcs.resize(bw);
1087 self.mvs.resize(bw);
1088 for by in start_by..end_by {
1093 let mut cbp_y_p = 0;
1094 let mut cbp_u_p = 0;
1095 let mut cbp_v_p = 0;
1096 let mut cbp_a_p = 0;
1105 let rflags = (row_flags[by] as u32) * 4;
1106 row_state = (row_state & 0x3FFFFFF) | ((row_state >> 4) & 0xC000000) | (rflags << 28);
1110 // row_state |= 0x8;
1112 if by + 2 >= end_by {
1116 let mut btype_lru: [u8; 4] = [ 2, 3, 1, 0 ];
1117 let mut edge_state = 0;
1118 let is_top = by == start_by;
1120 let mut blk_state = row_state | (edge_state & 0x3FC0000);
1130 let clflags = (col_flags[bx] as u32) * 4;
1131 let edge_state_c = ((blk_state >> 4) & 0x3C0000) | (blk_state & 0xFC03FFFF) | ((clflags & 0xF) << 22);
1132 let edge_state_y = (frame_flags & 0x40000) | (blk_state & 0x3FFFF);
1133 edge_state = edge_state_c;
1135 //let is_top = (edge_state & 0x88) != 0;
1136 let is_left = bx == 0; //(edge_state & 0x20) != 0;
1142 if (blk_state & 0x2000) != 0 {
1143 let val = br.read_code(UintCodeType::LimitedUnary(3, 1))?;
1146 btype = btype_lru[0];
1149 btype = btype_lru[1];
1150 btype_lru[1] = btype_lru[0];
1151 btype_lru[0] = btype;
1154 btype = btype_lru[3];
1155 btype_lru[3] = btype_lru[2];
1156 btype_lru[2] = btype;
1159 btype = btype_lru[2];
1160 btype_lru[2] = btype_lru[1];
1161 btype_lru[1] = btype;
1163 _ => unreachable!(),
1166 btype = br.read(2)? as u8;
1170 let q = self.qinfo.pred_quant(bx * 2, is_top);
1171 self.qinfo.set_quant(bx * 2, q);
1172 let q = self.qinfo.pred_quant(bx * 2 + 1, is_top);
1173 self.qinfo.set_quant(bx * 2 + 1, q);
1177 if (frame_flags & 0x2000) != 0 {
1178 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1179 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1180 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1181 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2, is_top))?;
1182 self.qinfo.set_quant(bx * 2, q);
1183 cbp_y = decode_luma_intra(br, &self.codes, cbp_y, q, &mut yblk, edge_state_y, &mut self.y_dcs, bx)?;
1184 cbp_v = decode_chroma_intra(br, &self.codes, cbp_v, q, &mut vblk, edge_state_c, &mut self.v_dcs, bx)?;
1185 cbp_u = decode_chroma_intra(br, &self.codes, cbp_u, q, &mut ublk, edge_state_c, &mut self.u_dcs, bx)?;
1187 let mut ablk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1188 cbp_a = decode_luma_intra(br, &self.codes, cbp_a, q, &mut ablk, edge_state_y, &mut self.a_dcs, bx)?;
1189 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1190 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1191 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1192 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1194 //if smth else decode one more y
1195 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1196 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1197 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1198 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1199 Bink2DSP::put_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1200 Bink2DSP::put_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1202 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1203 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1204 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1205 cbp_y = decode_luma_intra_old(br, &self.codes, cbp_y, &mut yblk, edge_state_y, &mut self.y_dcs, bx, &mut q_y)?;
1206 cbp_v = decode_chroma_intra_old(br, &self.codes, cbp_v, &mut vblk, edge_state_c, &mut self.v_dcs, bx, &mut q_v)?;
1207 cbp_u = decode_chroma_intra_old(br, &self.codes, cbp_u, &mut ublk, edge_state_c, &mut self.u_dcs, bx, &mut q_u)?;
1209 let mut ablk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1210 cbp_a = decode_luma_intra_old(br, &self.codes, cbp_a, &mut ablk, edge_state_y, &mut self.a_dcs, bx, &mut q_a)?;
1211 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1212 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1213 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1214 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1216 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1217 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1218 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1219 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1220 Bink2DSP::put_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1221 Bink2DSP::put_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1224 self.mvs.predict_mvs(bx, is_top, is_left, (frame_flags & 0x2000) != 0);
1228 if let Some(ref ref_pic) = self.ips.get_ref() {
1229 for blk_no in 0..4 {
1230 let xoff = bx * 32 + (blk_no & 1) * 16;
1231 let yoff = by * 32 + (blk_no & 2) * 8;
1232 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, ZERO_MV, 0)?;
1233 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 1)?;
1234 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 2)?;
1236 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, ZERO_MV, 3)?;
1240 return Err(DecoderError::MissingReference);
1245 if (frame_flags & 0x2000) != 0 {
1246 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1248 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1250 if let Some(ref ref_pic) = self.ips.get_ref() {
1251 for blk_no in 0..4 {
1252 let xoff = bx * 32 + (blk_no & 1) * 16;
1253 let yoff = by * 32 + (blk_no & 2) * 8;
1254 let mv = self.mvs.get_mv(bx, blk_no);
1255 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1256 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1257 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1259 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, mv, 3)?;
1263 return Err(DecoderError::MissingReference);
1267 if (frame_flags & 0x2000) != 0 {
1268 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1270 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1272 if let Some(ref ref_pic) = self.ips.get_ref() {
1273 for blk_no in 0..4 {
1274 let xoff = bx * 32 + (blk_no & 1) * 16;
1275 let yoff = by * 32 + (blk_no & 2) * 8;
1276 let mv = self.mvs.get_mv(bx, blk_no);
1277 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1278 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1279 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1281 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, mv, 3)?;
1285 return Err(DecoderError::MissingReference);
1287 if (frame_flags & 0x2000) != 0 {
1288 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1289 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1290 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1291 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2 + 1, is_top))?;
1292 self.qinfo.set_quant(bx * 2 + 1, q);
1293 cbp_y_p = decode_luma_inter(br, &self.codes, cbp_y_p, q, &mut yblk, edge_state_y, &mut self.y_dcs)?;
1294 if br.read_bool()? {
1295 cbp_v_p = decode_chroma_inter(br, &self.codes, cbp_v_p, q, &mut vblk, edge_state_y, &mut self.v_dcs)?;
1296 cbp_u_p = decode_chroma_inter(br, &self.codes, cbp_u_p, q, &mut ublk, edge_state_y, &mut self.u_dcs)?;
1302 let mut ablk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1303 cbp_a_p = decode_luma_inter(br, &self.codes, cbp_a_p, q, &mut ablk, edge_state_y, &mut self.a_dcs)?;
1304 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1305 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1306 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1307 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1309 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1310 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1311 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1312 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1313 Bink2DSP::add_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1314 Bink2DSP::add_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1316 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1317 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1318 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1319 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)?;
1320 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)?;
1321 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)?;
1323 let mut ablk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1324 cbp_a_p = decode_luma_inter_old(br, &self.codes, cbp_a_p, &mut ablk, edge_state_y, &mut self.a_dcs, &mut q_a_p)?;
1325 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1326 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1327 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1328 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1330 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1331 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1332 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1333 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1334 Bink2DSP::add_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1335 Bink2DSP::add_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1338 _ => unreachable!(),
1341 let src = &dst[off_y + bx * 32..];
1342 let dc5 = Bink2DSP::calc_dc(&src[24..], stride_y);
1343 let dc7 = Bink2DSP::calc_dc(&src[24 + stride_y * 8..], stride_y);
1344 let dc13 = Bink2DSP::calc_dc(&src[24 + stride_y * 16..], stride_y);
1345 let dc10 = Bink2DSP::calc_dc(&src[ 0 + stride_y * 24..], stride_y);
1346 let dc11 = Bink2DSP::calc_dc(&src[ 8 + stride_y * 24..], stride_y);
1347 let dc14 = Bink2DSP::calc_dc(&src[16 + stride_y * 24..], stride_y);
1348 let dc15 = Bink2DSP::calc_dc(&src[24 + stride_y * 24..], stride_y);
1349 self.y_dcs.set_dcs(bx, dc5, dc7, dc13, dc10, dc11, dc14, dc15);
1350 let src = &dst[off_u + bx * 16..];
1351 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_u);
1352 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_u * 8..], stride_u);
1353 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_u * 8..], stride_u);
1354 self.u_dcs.set_dcs(bx, dc1, dc2, dc3);
1355 let src = &dst[off_v + bx * 16..];
1356 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_v);
1357 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_v * 8..], stride_v);
1358 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_v * 8..], stride_v);
1359 self.v_dcs.set_dcs(bx, dc1, dc2, dc3);
1361 let src = &dst[off_a + bx * 32..];
1362 let dc5 = Bink2DSP::calc_dc(&src[24..], stride_a);
1363 let dc7 = Bink2DSP::calc_dc(&src[24 + stride_y * 8..], stride_a);
1364 let dc13 = Bink2DSP::calc_dc(&src[24 + stride_y * 16..], stride_a);
1365 let dc10 = Bink2DSP::calc_dc(&src[ 0 + stride_y * 24..], stride_a);
1366 let dc11 = Bink2DSP::calc_dc(&src[ 8 + stride_y * 24..], stride_a);
1367 let dc14 = Bink2DSP::calc_dc(&src[16 + stride_y * 24..], stride_a);
1368 let dc15 = Bink2DSP::calc_dc(&src[24 + stride_y * 24..], stride_a);
1369 self.a_dcs.set_dcs(bx, dc5, dc7, dc13, dc10, dc11, dc14, dc15);
1373 self.qinfo.update_line();
1374 self.y_dcs.update_line();
1375 self.u_dcs.update_line();
1376 self.v_dcs.update_line();
1377 self.a_dcs.update_line();
1378 self.mvs.update_line();
1379 off_y += stride_y * 32;
1380 off_u += stride_u * 16;
1381 off_v += stride_v * 16;
1382 off_a += stride_a * 32;
1383 row_state = (row_state & !0x190) | ((row_state & 4) << 2);
1385 start_by = self.slice_h[slice_no];
1391 fn decode_flags(br: &mut BitReader, dst: &mut Vec<bool>, start: usize, nbits: usize) -> DecoderResult<()> {
1395 if !br.read_bool()? {
1397 let bit = br.read_bool()?;
1401 let mut cur_bits = nbits;
1403 let mut lastbit = false;
1404 while cur_bits > 0 {
1405 if !br.read_bool()? {
1406 lastbit = if mode == 3 { !lastbit } else { br.read_bool()? };
1409 let len = cur_bits.min(4);
1411 let bit = br.read_bool()?;
1420 } else if cur_bits < 16 {
1425 lastbit = if mode == 3 { !lastbit } else { br.read_bool()? };
1426 let mut run = (if mode == 3 { bread + 1 } else { bread + 2 } as usize).min(cur_bits);
1427 if run != cur_bits {
1428 let add_run = br.read(bread)? as usize;
1430 mode = if add_run == (1 << bread) - 1 { 1 } else { 3 };
1442 fn get_new_quant(br: &mut BitReader, prev_q: u8) -> DecoderResult<u8> {
1443 let mut code = br.read_code(UintCodeType::LimitedUnary(4, 1))? as u8;
1448 code += br.read(1)? as u8;
1449 } else if code == 4 {
1450 code = (br.read(5)? as u8) + 5;
1453 if !br.read_bool()? {
1454 ret = prev_q.checked_add(code);
1456 ret = prev_q.checked_sub(code);
1458 validate!(ret.is_some());
1459 let val = ret.unwrap();
1460 validate!(val < (BINK2_QUANT_DC.len() as u8));
1465 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> {
1466 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1467 let _coded = dcinfo.decode_dcs(br, q)?;
1468 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1469 let dcs = &dcinfo.dcs;
1471 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTRA_LUMA, q, cbp >> (i * 4))?;
1472 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j] * 8 + 32; }
1477 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> {
1478 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1479 let _coded = dcinfo.decode_dcs(br, q)?;
1480 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1481 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTRA_CHROMA, q, cbp)?;
1482 let dcs = &dcinfo.dcs;
1483 for i in 0..4 { dst[i][0] = dcs[i] * 8 + 32; }
1487 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> {
1488 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1489 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1490 let _coded = dcinfo.decode_dcs(br, q)?;
1491 dcinfo.predict_inter(min_dc, max_dc);
1492 let dcs = &dcinfo.dcs;
1494 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTER, q, cbp >> (i * 4))?;
1495 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j] * 8; }
1500 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> {
1501 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1502 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1503 let _coded = dcinfo.decode_dcs(br, q)?;
1504 dcinfo.predict_inter(min_dc, max_dc);
1505 let dcs = &dcinfo.dcs;
1506 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTER, q, cbp)?;
1507 for i in 0..4 { dst[i][0] = dcs[i] * 8; }
1511 fn decode_cbp_luma(br: &mut BitReader, prev_cbp: u32, edge_state: u32) -> DecoderResult<u32> {
1512 let cnt = (prev_cbp as u16).count_ones() as usize;
1513 let (min_count, mask) = if cnt < 8 { (cnt, 0x0000) } else { (16 - cnt, 0xFFFF) };
1516 if br.read_bool()? {
1518 } else if min_count >= 4 {
1523 if !br.read_bool()? {
1524 let cbp4 = br.read(4)?;
1525 cbp |= cbp4 << (i * 4);
1530 if ((edge_state & 0x40000) == 0) || (cbp != 0) {
1531 if br.read_bool()? {
1537 fn decode_cbp_chroma(br: &mut BitReader, last_cbp: u32) -> DecoderResult<u32> {
1538 if br.read_bool()? {
1539 Ok((last_cbp & 0xF0000) | BINK2_CHROMA_CBPS[(last_cbp & 0xF) as usize])
1541 let ncbp = br.read(4)?;
1542 if br.read_bool()? {
1543 Ok(ncbp | (ncbp << 16))
1550 trait ReadBink2Code {
1551 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32>;
1552 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32>;
1555 impl<'a> ReadBink2Code for BitReader<'a> {
1556 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32> {
1557 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? as i32;
1561 let add_bits = self.read((pfx as u8) - 3)? as i32;
1562 val = (1 << (pfx - 3)) + add_bits + 2;
1571 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32> {
1572 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? + 1;
1575 let add_bits = self.read((pfx as u8) - 3)? as i32;
1576 val = (1 << (pfx - 3)) + add_bits + 2;
1580 if self.read_bool()? {
1588 fn decode_acs_4blocks(br: &mut BitReader, codes: &Bink2Codes, dst: &mut [[i32; 64]; 4], quant_mat: &[[i32; 64]; 4], q: u8, cbp: u32) -> DecoderResult<()> {
1589 let cb = if (cbp >> 16) != 0 { &codes.ac_cb1 } else { &codes.ac_cb2 };
1590 let qmat = &quant_mat[(q & 3) as usize];
1592 for blk_no in 0..4 {
1593 if ((cbp >> blk_no) & 1) == 0 { continue; }
1594 let mut esc_len = 0;
1600 let sym = br.read_cb(cb)?;
1603 skip = br.read(6)? as usize;
1605 skip = BINK2_AC_RUNS[sym as usize];
1608 if idx > 63 { break; }
1609 esc_len = if sym == 13 { 6 } else { 0 };
1611 let level = br.read_bink2_code_nz()?;
1612 let pos = BINK2_ZIGZAG[idx];
1613 dst[blk_no][pos] = (((level * qmat[pos]) << shift) + 0x40) >> 7;
1616 // set blk info to (dc & 0x1FFF) | (intra ? 0x8000 : 0) | (((ncoded == 0) + (ncoded < 4) + (ncoded < 8)) << 13)
1621 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> {
1622 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1623 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1625 let is_top = (edge_state & 0x88) != 0;
1626 let is_left = (edge_state & 0x20) != 0;
1627 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1628 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1629 let dcs = &dcinfo.dcs;
1631 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTRA_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1632 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1637 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> {
1638 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1639 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1641 let is_top = (edge_state & 0x88) != 0;
1642 let is_left = (edge_state & 0x20) != 0;
1643 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1644 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1645 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1646 let dcs = &dcinfo.dcs;
1647 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1652 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> {
1653 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1654 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1656 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1657 dcinfo.predict_inter(-1023, 1023);
1658 let dcs = &dcinfo.dcs;
1660 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTER_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1661 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1666 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> {
1667 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1668 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1670 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1671 dcinfo.predict_inter(-1023, 1023);
1672 let dcs = &dcinfo.dcs;
1673 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1674 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1678 fn decode_quant_old(br: &mut BitReader, quant_cb: &Codebook<u8>, prev_quant: u8) -> DecoderResult<u8> {
1679 let diff = br.read_cb(quant_cb)?;
1684 if br.read_bool()? {
1685 res = prev_quant.checked_sub(diff);
1687 res = prev_quant.checked_add(diff);
1689 validate!(res.is_some());
1690 let q = res.unwrap();
1696 fn decode_cbp_luma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1698 if br.read_bool()? {
1699 if br.read_bool()? {
1700 return Ok(prev_cbp);
1702 low = prev_cbp & 0xFFFF;
1704 let mut nib1 = (prev_cbp >> 4) & 0xF;
1705 if !br.read_bool()? {
1708 let mut new_cbp = nib1;
1709 if !br.read_bool()? {
1712 new_cbp = new_cbp | (nib1 << 4);
1713 if !br.read_bool()? {
1716 new_cbp = new_cbp | (nib1 << 8);
1717 if !br.read_bool()? {
1720 low = new_cbp | (nib1 << 12);
1722 let mut nib_hi = (prev_cbp >> 20) & 0xF;
1725 let nib = (low >> (4 * i)) & 0xF;
1726 if nib.count_ones() == 0 {
1728 } else if (nib.count_ones() == 1) || !br.read_bool()? {
1731 if (((nib >> bit) & 1) != 0) && br.read_bool()? {
1737 high = (high >> 4) | (nib_hi << 28);
1742 fn decode_cbp_chroma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1744 if !br.read_bool()? {
1747 if br.read_bool()? {
1748 return Ok(prev_cbp);
1750 low = prev_cbp & 0xF;
1753 if low.count_ones() == 0 {
1756 if low.count_ones() != 1 {
1757 high = (prev_cbp >> 16) & low;
1758 if br.read_bool()? {
1759 return Ok((high << 16) | low);
1764 if (((low >> bit) & 1) != 0) && br.read_bool()? {
1768 Ok((high << 16) | low)
1771 fn decode_dcs_old(br: &mut BitReader, dcs: &mut [i32], q: u8, read_bias: bool) -> DecoderResult<()> {
1772 let mut bits = br.read(3)? as u8;
1774 bits += br.read(2)? as u8;
1776 let scale = BINK2_OLD_DC_QUANTS[q as usize];
1778 for el in dcs.iter_mut() { *el = 0; }
1780 for dcb in dcs.chunks_mut(4) {
1781 for dc in dcb.iter_mut() {
1782 *dc = br.read(bits)? as i32;
1784 for dc in dcb.iter_mut() {
1785 if *dc == 0 { continue; }
1787 if br.read_bool()? {
1794 let add_bits = BINK2_DC_EXTRA_BITS[q as usize] + bits;
1796 let pfx = br.read(10 - add_bits)? as i32;
1799 if br.read_bool()? {
1800 base_dc = -(pfx << bits);
1802 base_dc = pfx << bits;
1807 dcs[0] += base_dc * scale;
1813 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<()> {
1814 let quant = BINK2_OLD_QUANTS[q as usize];
1815 for blk_no in 0..4 {
1816 if ((cbp >> blk_no) & 1) == 0 { continue; }
1817 let val_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.val_cb2 } else { &codes.val_cb1 };
1818 let skip_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.skip_cb2 } else { &codes.skip_cb1 };
1819 let mut esc_len = 0;
1822 let val = br.read_cb(val_cb)?;
1826 let add_bits = br.read(val - 3)? as i32;
1827 level = (1 << (val - 3)) + add_bits + 2;
1831 if br.read_bool()? {
1834 let pos = scan[idx];
1835 dst[blk_no][pos] = (level as f32) * quant_mat[(pos & 7) * 8 + (pos >> 3)] * quant;
1838 if idx >= 64 { break; }
1842 let sym = br.read_cb(skip_cb)?;
1845 skip = br.read(6)? as usize;
1847 skip = BINK2_AC_RUNS[sym as usize];
1850 if idx > 63 { break; }
1851 esc_len = if sym == 13 { 6 } else { 0 };
1858 const KB2H_NUM_SLICES: [usize; 4] = [ 2, 3, 4, 8 ];
1860 impl NADecoder for Bink2Decoder {
1861 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
1862 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1863 let w = vinfo.get_width();
1864 let h = vinfo.get_height();
1866 let edata = info.get_extradata().unwrap();
1867 validate!(edata.len() >= 8);
1869 let mut mr = MemoryReader::new_read(&edata);
1870 let mut br = ByteReader::new(&mut mr);
1871 let magic = br.read_u32be()?;
1872 let flags = br.read_u32le()?;
1874 self.version = magic;
1875 self.has_alpha = (flags & 0x100000) != 0;
1877 let height_a = (h + 31) & !31;
1878 if self.version <= mktag!(b"KB2f") {
1879 self.num_slices = 2;
1880 self.slice_h[0] = (h + 32) >> 6;
1881 } else if self.version == mktag!(b"KB2g") {
1883 self.num_slices = 1;
1885 self.num_slices = 2;
1886 self.slice_h[0] = (h + 31) >> 6;
1889 self.num_slices = KB2H_NUM_SLICES[(flags & 3) as usize];
1891 let mut end = height_a + 32 * self.num_slices - 1;
1892 for i in 0..self.num_slices - 1 {
1893 start += ((end - start) / (self.num_slices - i)) & !31;
1895 self.slice_h[i] = start >> 5;
1898 self.slice_h[self.num_slices - 1] = height_a >> 5;
1901 let aplane = if self.has_alpha { Some(NAPixelChromaton::new(0, 0, false, 8, 0, 3, 1)) } else { None };
1902 fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
1903 Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
1904 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 1, 1)),
1905 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 2, 1)),
1907 if self.has_alpha { FORMATON_FLAG_ALPHA } else { 0 },
1908 if self.has_alpha { 4 } else { 3 });
1909 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
1910 self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
1914 Err(DecoderError::InvalidData)
1917 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1918 let src = pkt.get_buffer();
1920 let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
1923 self.key_frame = pkt.is_keyframe();
1925 let bufret = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 5);
1926 if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
1927 let bufinfo = bufret.unwrap();
1928 buf = bufinfo.get_vbuf().unwrap();
1930 self.decode_frame_new(&mut br, &mut buf, pkt.is_keyframe())?;
1931 let bufinfo = NABufferType::Video(buf);
1932 self.ips.add_frame(bufinfo.get_vbuf().unwrap());
1934 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
1935 frm.set_frame_type(if self.key_frame { FrameType::I } else { FrameType::P });
1936 Ok(Rc::new(RefCell::new(frm)))
1940 pub fn get_decoder() -> Box<NADecoder> {
1941 Box::new(Bink2Decoder::new())
1946 use nihav_core::codecs::RegisteredDecoders;
1947 use nihav_core::demuxers::RegisteredDemuxers;
1948 use nihav_core::test::dec_video::*;
1949 use crate::codecs::rad_register_all_codecs;
1950 use crate::demuxers::rad_register_all_demuxers;
1953 let mut dmx_reg = RegisteredDemuxers::new();
1954 rad_register_all_demuxers(&mut dmx_reg);
1955 let mut dec_reg = RegisteredDecoders::new();
1956 rad_register_all_codecs(&mut dec_reg);
1958 //let file = "assets/RAD/Open_Logos_partial.bik";
1959 //let file = "assets/RAD/sc13_01_partial.bk2";
1960 let file = "assets/RAD/ge_video_86l.bk2";
1961 //let file = "assets/RAD/eg_club_0.bk2";
1962 test_file_decoding("bink", file, Some(8), true, false, None/*Some("bink2")*/, &dmx_reg, &dec_reg);
1966 const BINK2_ZIGZAG: [usize; 64] = [
1967 0, 8, 1, 2, 9, 16, 24, 17,
1968 10, 3, 4, 11, 18, 25, 32, 40,
1969 33, 26, 19, 12, 5, 6, 13, 20,
1970 27, 34, 41, 48, 56, 49, 42, 35,
1971 28, 21, 14, 7, 15, 22, 29, 36,
1972 43, 50, 57, 58, 51, 44, 37, 30,
1973 23, 31, 38, 45, 52, 59, 60, 53,
1974 46, 39, 47, 54, 61, 62, 55, 63
1976 const BINK2_LUMA_SCAN_OLD: &[usize; 64] = &[
1977 0, 2, 1, 8, 9, 17, 10, 16,
1978 24, 3, 18, 25, 32, 11, 33, 26,
1979 4, 40, 19, 12, 27, 41, 34, 5,
1980 20, 48, 6, 28, 15, 42, 23, 35,
1981 21, 13, 14, 7, 31, 43, 49, 36,
1982 22, 56, 39, 50, 30, 44, 29, 51,
1983 57, 47, 58, 59, 63, 61, 55, 38,
1984 52, 62, 45, 37, 60, 46, 54, 53
1986 const BINK2_CHROMA_SCAN_OLD: &[usize; 64] = &[
1987 0, 1, 8, 2, 9, 16, 10, 17,
1988 3, 24, 11, 18, 25, 13, 14, 4,
1989 15, 5, 6, 7, 12, 19, 20, 21,
1990 22, 23, 26, 27, 28, 29, 30, 31,
1991 32, 33, 34, 35, 36, 37, 38, 39,
1992 40, 41, 42, 43, 44, 45, 46, 47,
1993 48, 49, 50, 51, 52, 53, 54, 55,
1994 56, 57, 58, 59, 60, 61, 62, 63
1997 const BINK2_CHROMA_CBPS: [u32; 16] = [
2004 const BINK2_QUANT_DC: [i32; 37] = [
2005 0x400, 0x4C2, 0x5A8, 0x6BA, 0x800, 0x983, 0xB50, 0xD74,
2006 0x1000, 0x1307, 0x16A1, 0x1AE9, 0x2000, 0x260E, 0x2D41, 0x35D1,
2007 0x4000, 0x4C1C, 0x5A82, 0x6BA3, 0x8000, 0x9838, 0xB505, 0xD745,
2008 0x10000, 0x13070, 0x16A0A, 0x1AE8A, 0x20000, 0x260E0, 0x2D414, 0x35D14,
2009 0x40000, 0x4C1C0, 0x5A828, 0x6BA28, 0x80000
2012 const BINK2_QUANT_INTRA_LUMA: &[[i32; 64]; 4] = &[
2014 0x400, 0x598, 0x5E2, 0x49D, 0x733, 0x7E9, 0x1497, 0x2190,
2015 0x521, 0x685, 0x65E, 0x688, 0xA41, 0xD72, 0x1F57, 0x31FA,
2016 0x434, 0x6DB, 0x710, 0x79E, 0xF8C, 0x130B, 0x226D, 0x2E85,
2017 0x546, 0x74C, 0x84F, 0x7E0, 0x1275, 0x1162, 0x1E20, 0x25A5,
2018 0x99A, 0xC1F, 0x10CF, 0x10CF, 0x1B33, 0x1AB3, 0x2B47, 0x3435,
2019 0xD2F, 0x1648, 0x13BC, 0x17A1, 0x23EE, 0x1C40, 0x29E5, 0x266A,
2020 0x156E, 0x1D61, 0x1E75, 0x1BB3, 0x2B47, 0x2720, 0x34F7, 0x3270,
2021 0x1C6F, 0x1DE1, 0x1B6C, 0x17D1, 0x23E5, 0x2357, 0x3175, 0x35C8
2023 0x4C2, 0x6A7, 0x6FF, 0x57D, 0x890, 0x968, 0x187C, 0x27EA,
2024 0x619, 0x7C1, 0x792, 0x7C4, 0xC32, 0xFFD, 0x2545, 0x3B6F,
2025 0x4FF, 0x827, 0x866, 0x90F, 0x127D, 0x16A6, 0x28F1, 0x3752,
2026 0x646, 0x8AE, 0x9E2, 0x95E, 0x15F3, 0x14AC, 0x23D3, 0x2CC4,
2027 0xB6B, 0xE6A, 0x13FD, 0x13FE, 0x2059, 0x1FC0, 0x3378, 0x3E16,
2028 0xFAE, 0x1A7F, 0x1778, 0x1C1A, 0x2ABA, 0x2198, 0x31D3, 0x2DAE,
2029 0x197C, 0x22F0, 0x2438, 0x20F1, 0x3378, 0x2E87, 0x3EFD, 0x3BFA,
2030 0x21D1, 0x2388, 0x209C, 0x1C52, 0x2AAF, 0x2A07, 0x3AD0, 0x3FF5
2032 0x5A8, 0x7E9, 0x852, 0x687, 0xA2F, 0xB30, 0x1D1E, 0x2F77,
2033 0x740, 0x938, 0x901, 0x93C, 0xE81, 0x1303, 0x2C52, 0x46AE,
2034 0x5F1, 0x9B2, 0x9FD, 0xAC6, 0x15FC, 0x1AEE, 0x30B0, 0x41C9,
2035 0x775, 0xA52, 0xBC0, 0xB24, 0x1A1B, 0x1895, 0x2A9A, 0x353D,
2036 0xD94, 0x1124, 0x17C5, 0x17C6, 0x2677, 0x25C2, 0x3D34, 0x49D5,
2037 0x12A5, 0x1F82, 0x1BE9, 0x216B, 0x32CF, 0x27F3, 0x3B40, 0x3653,
2038 0x1E4E, 0x298D, 0x2B12, 0x272C, 0x3D34, 0x3755, 0x4AE7, 0x4753,
2039 0x2836, 0x2A41, 0x26C7, 0x21AE, 0x32C3, 0x31FA, 0x45F1, 0x4C0E
2041 0x6BA, 0x968, 0x9E5, 0x7C3, 0xC1C, 0xD4E, 0x22A0, 0x3872,
2042 0x8A0, 0xAF7, 0xAB5, 0xAFB, 0x113F, 0x169C, 0x34B5, 0x540D,
2043 0x711, 0xB87, 0xBE1, 0xCD0, 0x1A25, 0x2007, 0x39E6, 0x4E3C,
2044 0x8DF, 0xC46, 0xDFA, 0xD3F, 0x1F0B, 0x1D3C, 0x32A9, 0x3F4F,
2045 0x1025, 0x1462, 0x1C44, 0x1C46, 0x2DBF, 0x2CE7, 0x48C9, 0x57CE,
2046 0x162D, 0x2578, 0x2131, 0x27BE, 0x3C6D, 0x2F82, 0x4676, 0x409A,
2047 0x240A, 0x3169, 0x3338, 0x2E96, 0x48C9, 0x41CD, 0x5914, 0x54D3,
2048 0x2FD2, 0x3240, 0x2E1E, 0x280E, 0x3C5E, 0x3B6F, 0x532D, 0x5A73
2052 const BINK2_QUANT_INTRA_CHROMA: &[[i32; 64]; 4] = &[
2054 0x400, 0x4A9, 0x59A, 0x89B, 0x1600, 0x1221, 0x171C, 0x19A3,
2055 0x4A9, 0x656, 0x713, 0xE16, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
2056 0x59A, 0x713, 0xDBB, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
2057 0x89B, 0xE16, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
2058 0x1600, 0x19A3, 0x171C, 0x1221, 0x1600, 0x1221, 0x171C, 0x19A3,
2059 0x1221, 0x1520, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
2060 0x171C, 0x1AEE, 0x1847, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
2061 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1
2063 0x4C2, 0x58B, 0x6AA, 0xA3C, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
2064 0x58B, 0x789, 0x869, 0x10C0, 0x1E7D, 0x1920, 0x2007, 0x2388,
2065 0x6AA, 0x869, 0x1054, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
2066 0xA3C, 0x10C0, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
2067 0x1A2A, 0x1E7D, 0x1B7B, 0x158F, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
2068 0x158F, 0x1920, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
2069 0x1B7B, 0x2007, 0x1CDE, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
2070 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388
2072 0x5A8, 0x698, 0x7EC, 0xC2C, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
2073 0x698, 0x8F6, 0xA01, 0x13EB, 0x2442, 0x1DE1, 0x2616, 0x2A41,
2074 0x7EC, 0xA01, 0x136B, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
2075 0xC2C, 0x13EB, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
2076 0x1F1D, 0x2442, 0x20AF, 0x19A3, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
2077 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
2078 0x20AF, 0x2616, 0x2255, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
2079 0x2442, 0x2A41, 0x2616, 0x1DE1, 0x2442, 0x1DE1, 0x2616, 0x2A41
2081 0x6BA, 0x7D7, 0x96C, 0xE7A, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
2082 0x7D7, 0xAA9, 0xBE5, 0x17B0, 0x2B1E, 0x2388, 0x2D4B, 0x3240,
2083 0x96C, 0xBE5, 0x1718, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
2084 0xE7A, 0x17B0, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
2085 0x2500, 0x2B1E, 0x26DE, 0x1E7D, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
2086 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
2087 0x26DE, 0x2D4B, 0x28D4, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
2088 0x2B1E, 0x3240, 0x2D4B, 0x2388, 0x2B1E, 0x2388, 0x2D4B, 0x3240
2092 const BINK2_QUANT_INTER: &[[i32; 64]; 4] = &[
2094 0x400, 0x4A9, 0x434, 0x34C, 0x41C, 0x392, 0x4C9, 0x5D4,
2095 0x4A9, 0x56F, 0x4E6, 0x3D7, 0x4CB, 0x429, 0x5B7, 0x718,
2096 0x434, 0x4E6, 0x489, 0x3A8, 0x4AB, 0x40A, 0x5A4, 0x6CD,
2097 0x34C, 0x3D7, 0x3A8, 0x32B, 0x41F, 0x39F, 0x519, 0x630,
2098 0x41C, 0x4CB, 0x4AB, 0x41F, 0x5AB, 0x538, 0x778, 0x932,
2099 0x392, 0x429, 0x40A, 0x39F, 0x538, 0x521, 0x799, 0x9B6,
2100 0x4C9, 0x5B7, 0x5A4, 0x519, 0x778, 0x799, 0xBE4, 0xFC7,
2101 0x5D4, 0x718, 0x6CD, 0x630, 0x932, 0x9B6, 0xFC7, 0x162F
2103 0x4C2, 0x58B, 0x4FF, 0x3EB, 0x4E4, 0x43F, 0x5B1, 0x6EE,
2104 0x58B, 0x676, 0x5D3, 0x491, 0x5B3, 0x4F3, 0x6CB, 0x86F,
2105 0x4FF, 0x5D3, 0x565, 0x459, 0x58D, 0x4CE, 0x6B5, 0x816,
2106 0x3EB, 0x491, 0x459, 0x3C5, 0x4E6, 0x44F, 0x610, 0x75C,
2107 0x4E4, 0x5B3, 0x58D, 0x4E6, 0x6BD, 0x635, 0x8E2, 0xAEF,
2108 0x43F, 0x4F3, 0x4CE, 0x44F, 0x635, 0x61A, 0x909, 0xB8C,
2109 0x5B1, 0x6CB, 0x6B5, 0x610, 0x8E2, 0x909, 0xE24, 0x12C3,
2110 0x6EE, 0x86F, 0x816, 0x75C, 0xAEF, 0xB8C, 0x12C3, 0x1A61
2112 0x5A8, 0x698, 0x5F1, 0x4A9, 0x5D0, 0x50D, 0x6C4, 0x83E,
2113 0x698, 0x7AF, 0x6ED, 0x56F, 0x6C7, 0x5E3, 0x814, 0xA08,
2114 0x5F1, 0x6ED, 0x66A, 0x52B, 0x69A, 0x5B6, 0x7FA, 0x99E,
2115 0x4A9, 0x56F, 0x52B, 0x47B, 0x5D4, 0x51F, 0x735, 0x8C1,
2116 0x5D0, 0x6C7, 0x69A, 0x5D4, 0x804, 0x761, 0xA90, 0xD00,
2117 0x50D, 0x5E3, 0x5B6, 0x51F, 0x761, 0x741, 0xABF, 0xDBB,
2118 0x6C4, 0x814, 0x7FA, 0x735, 0xA90, 0xABF, 0x10D2, 0x1650,
2119 0x83E, 0xA08, 0x99E, 0x8C1, 0xD00, 0xDBB, 0x1650, 0x1F5F
2121 0x6BA, 0x7D7, 0x711, 0x58B, 0x6EA, 0x601, 0x80C, 0x9CD,
2122 0x7D7, 0x923, 0x83C, 0x676, 0x80F, 0x700, 0x99C, 0xBEE,
2123 0x711, 0x83C, 0x7A1, 0x626, 0x7DA, 0x6CB, 0x97C, 0xB70,
2124 0x58B, 0x676, 0x626, 0x554, 0x6EE, 0x617, 0x893, 0xA68,
2125 0x6EA, 0x80F, 0x7DA, 0x6EE, 0x988, 0x8C7, 0xC90, 0xF76,
2126 0x601, 0x700, 0x6CB, 0x617, 0x8C7, 0x8A1, 0xCC7, 0x1055,
2127 0x80C, 0x99C, 0x97C, 0x893, 0xC90, 0xCC7, 0x1400, 0x1A89,
2128 0x9CD, 0xBEE, 0xB70, 0xA68, 0xF76, 0x1055, 0x1A89, 0x254E
2132 const BINK2_AC_CODES1: &[u8] = &[
2133 0x01, 0x04, 0x00, 0x08, 0x02, 0x32, 0x0A, 0x12,
2134 0x3A, 0x7A, 0xFA, 0x72, 0x06, 0x1A
2136 const BINK2_AC_BITS1: &[u8] = &[ 1, 3, 4, 4, 5, 7, 5, 6, 7, 8, 8, 7, 3, 6 ];
2137 const BINK2_AC_CODES2: &[u16] = &[
2138 0x01, 0x00, 0x04, 0x2C, 0x6C, 0x0C, 0x4C, 0xAC,
2139 0xEC, 0x12C, 0x16C, 0x1AC, 0x02, 0x1C
2141 const BINK2_AC_BITS2: &[u8] = &[ 1, 3, 4, 9, 9, 7, 7, 9, 8, 9, 9, 9, 2, 5 ];
2143 const BINK2_AC_RUNS: [usize; 14] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 64, 0 ];
2145 const BINK2_MV_CODES: &[u8] = &[
2146 0x01, 0x06, 0x0C, 0x1C, 0x18, 0x38, 0x58, 0x78,
2147 0x68, 0x48, 0x28, 0x08, 0x14, 0x04, 0x02, 0x00
2149 const BINK2_MV_BITS: &[u8] = &[
2150 1, 3, 5, 5, 7, 7, 7, 7,
2151 7, 7, 7, 7, 5, 5, 3, 4
2153 const BINK2_MV_ESC: i8 = 42;
2154 const BINK2_MV_SYMS: &[i8] = &[
2155 0, 1, 2, 3, 4, 5, 6, 7,
2156 -7, -6, -5, -4, -3, -2, -1, BINK2_MV_ESC
2159 const BINK2_AC_VAL_CODES1: &[u16] = &[
2160 0x004, 0x01, 0x002, 0x00, 0x08, 0x18, 0xF8, 0x178,
2161 0x138, 0x38, 0x1B8, 0x78, 0xB8
2163 const BINK2_AC_VAL_BITS1: &[u8] = &[ 3, 1, 2, 4, 5, 6, 8, 9, 9, 9, 9, 9, 9 ];
2164 const BINK2_AC_VAL_CODES2: &[u16] = &[
2165 0x0A, 0x001, 0x004, 0x08, 0x06, 0x00, 0x02, 0x1A,
2166 0x2A, 0x16A, 0x1EA, 0x6A, 0xEA
2168 const BINK2_AC_VAL_BITS2: &[u8] = &[ 6, 1, 3, 4, 3, 4, 4, 5, 7, 9, 9, 9, 9 ];
2169 const BINK2_AC_SKIP_CODES1: &[u16] = &[
2170 0x00, 0x001, 0x0D, 0x15, 0x45, 0x85, 0xA5, 0x165,
2171 0x65, 0x1E5, 0xE5, 0x25, 0x03, 0x05
2173 const BINK2_AC_SKIP_BITS1: &[u8] = &[ 1, 3, 4, 5, 7, 8, 8, 9, 9, 9, 9, 8, 2, 8 ];
2174 const BINK2_AC_SKIP_CODES2: &[u16] = &[
2175 0x00, 0x01, 0x003, 0x07, 0x1F, 0x1B, 0x0F, 0x2F,
2176 0x5B, 0xDB, 0x1DB, 0x3B, 0x05, 0x0B
2178 const BINK2_AC_SKIP_BITS2: &[u8] = &[ 1, 3, 4, 4, 5, 7, 6, 6, 8, 9, 9, 6, 3, 5 ];
2179 const BINK2_QUANT_CODES: &[u8] = &[
2180 0x01, 0x02, 0x04, 0x08, 0x10, 0x30, 0x50, 0x70,
2181 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
2183 const BINK2_QUANT_BITS: &[u8] = &[ 1, 2, 3, 4, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8 ];
2185 const BINK2_OLD_QUANTS: [f32; 16] = [
2186 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
2188 const BINK2_OLD_DC_QUANTS: [i32; 16] = [
2189 4, 4, 4, 4, 4, 6, 7, 8, 10, 12, 16, 24, 32, 48, 64, 128
2191 const BINK2_DC_EXTRA_BITS: [u8; 16] = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 6 ];
2192 const BINK2_QMAT_INTRA_LUMA_OLD: &[f32; 64] = &[
2193 0.125, 0.208056, 0.22864901, 0.205778, 0.22499999, 0.235708, 0.33148301, 0.248309,
2194 0.190718, 0.288582, 0.29449099, 0.34658501, 0.38143599, 0.47678301, 0.600528, 0.44008601,
2195 0.16332, 0.31714499, 0.34142101, 0.42249799, 0.604285, 0.70576, 0.68942899, 0.42807001,
2196 0.235175, 0.38735899, 0.46090701, 0.50122303, 0.82311302, 0.73910397, 0.69206202, 0.39741901,
2197 0.30000001, 0.45078799, 0.65328097, 0.74962097, 0.85000002, 0.79551601, 0.69678998, 0.38625899,
2198 0.392847, 0.79009801, 0.73142397, 1.004719, 1.070509, 0.80251199, 0.64313799, 0.27096599,
2199 0.34501299, 0.56299502, 0.60987997, 0.636379, 0.69678998, 0.60061598, 0.43934, 0.19224399,
2200 0.210373, 0.26309499, 0.252336, 0.25142801, 0.265553, 0.24928901, 0.188511, 0.094199002
2202 const BINK2_QMAT_CHROMA_OLD: &[f32; 64] = &[
2203 0.125, 0.17338, 0.217761, 0.383793, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2204 0.17338, 0.28056601, 0.32721299, 0.74753499, 0.95358998, 0.74923098, 0.51607901, 0.26309499,
2205 0.217761, 0.32721299, 0.66387498, 1.056244, 0.89826202, 0.70576, 0.48613599, 0.24783,
2206 0.383793, 0.74753499, 1.056244, 0.95059502, 0.80841398, 0.635167, 0.437511, 0.223041,
2207 0.6875, 0.95358998, 0.89826202, 0.80841398, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2208 0.54016501, 0.74923098, 0.70576, 0.635167, 0.54016501, 0.42440501, 0.292335, 0.149031,
2209 0.37207201, 0.51607901, 0.48613599, 0.437511, 0.37207201, 0.292335, 0.201364, 0.102655,
2210 0.18968099, 0.26309499, 0.24783, 0.223041, 0.18968099, 0.149031, 0.102655, 0.052333001
2212 const BINK2_QMAT_INTER_LUMA_OLD: &[f32; 64] = &[
2213 0.125, 0.17338, 0.16332, 0.146984, 0.128475, 0.106393, 0.077045999, 0.043109,
2214 0.17338, 0.240485, 0.226532, 0.20387299, 0.17820001, 0.147571, 0.109474, 0.062454,
2215 0.16332, 0.226532, 0.219321, 0.202722, 0.181465, 0.149711, 0.112943, 0.062583998,
2216 0.146984, 0.20387299, 0.202722, 0.201647, 0.183731, 0.15397599, 0.11711, 0.065334998,
2217 0.128475, 0.17820001, 0.181465, 0.183731, 0.17708801, 0.155499, 0.120267, 0.068016,
2218 0.106393, 0.147571, 0.149711, 0.15397599, 0.155499, 0.14575601, 0.116636, 0.068494998,
2219 0.077045999, 0.109474, 0.112943, 0.11711, 0.120267, 0.116636, 0.098646, 0.060141001,
2220 0.043109, 0.062454, 0.062583998, 0.065334998, 0.068016, 0.068494998, 0.060141001, 0.038853001