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]) * std::f32::consts::SQRT_2 - 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) * std::f32::consts::SQRT_2;
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 #[allow(clippy::erasing_op)]
86 fn bink2_idct(coeffs: &mut [i32; 64]) {
87 let mut tmp: [i32; 64] = [0; 64];
89 idct!(coeffs, 1, 8 * i, tmp, 8, i, 0, 0);
92 idct!(tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
96 #[allow(clippy::erasing_op)]
97 fn bink2_idct_old(coeffs: &mut [f32; 64]) {
98 let mut tmp: [f32; 64] = [0.0; 64];
101 idct!(float; coeffs, 8, i, tmp, 8, i, 0, 0);
104 idct!(float; tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
110 fn clip8(val: i32) -> u8 {
111 val.min(255).max(0) as u8
115 ($src: expr, $off: expr) => (
120 macro_rules! luma_filter {
121 ($src: expr, $off: expr, $step: expr) => ({
122 let t0 = el!($src, $off - 0 * $step) + el!($src, $off + 1 * $step);
123 let t1 = el!($src, $off - 1 * $step) + el!($src, $off + 2 * $step);
124 let t2 = el!($src, $off - 2 * $step) + el!($src, $off + 3 * $step);
125 (((t0 * 19) >> 1) - t1 * 2 + (t2 >> 1) + 8) >> 4
129 macro_rules! chroma_interp {
130 ($dst: expr, $dstride: expr, $h: expr, $ty: tt, $src: expr, $sstride: expr, $step: expr, $mode: expr, $shift: expr) => {
132 for out in $dst.chunks_mut($dstride).take($h) {
134 let e0 = el!($src, soff + i);
135 let e1 = el!($src, soff + i + $step);
136 out[i] = match $mode {
138 1 => (e0 * 3 + e1 + $shift) >> $shift,
139 2 => (e0 * 2 + e1 * 2 + $shift) >> $shift,
140 _ => (e0 + e1 * 3 + $shift) >> $shift,
148 macro_rules! avg_tree {
149 ($a: expr, $b: expr) => (($a + $b + 1) >> 1);
150 ($a: expr, $b: expr, $c: expr, $d: expr) => (avg_tree!(avg_tree!($a, $b), avg_tree!($c, $d)));
153 #[allow(clippy::erasing_op)]
155 fn calc_dc(src: &[u8], stride: usize) -> i32 {
156 let mut sums = [0u16; 8];
158 let s0 = src[i + stride * 0] as u16;
159 let s1 = src[i + stride * 1] as u16;
160 let s2 = src[i + stride * 2] as u16;
161 let s3 = src[i + stride * 3] as u16;
162 let s4 = src[i + stride * 4] as u16;
163 let s5 = src[i + stride * 5] as u16;
164 let s6 = src[i + stride * 6] as u16;
165 let s7 = src[i + stride * 7] as u16;
166 sums[i] = avg_tree!(avg_tree!(s0, s1, s2, s3), avg_tree!(s4, s5, s6, s7));
169 for e in sums.iter() {
174 fn put_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
175 bink2_idct(&mut blk[0]);
176 bink2_idct(&mut blk[1]);
177 bink2_idct(&mut blk[2]);
178 bink2_idct(&mut blk[3]);
180 let dout = &mut dst[off..];
181 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
182 for i in 0..8 { row[i + 0] = clip8(b0[i]); }
183 for i in 0..8 { row[i + 8] = clip8(b1[i]); }
188 let dout = &mut dst[off..];
189 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
190 for i in 0..8 { row[i + 0] = clip8(b2[i]); }
191 for i in 0..8 { row[i + 8] = clip8(b3[i]); }
195 fn add_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
196 bink2_idct(&mut blk[0]);
197 bink2_idct(&mut blk[1]);
198 bink2_idct(&mut blk[2]);
199 bink2_idct(&mut blk[3]);
201 let dout = &mut dst[off..];
202 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
203 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b0[i]); }
204 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b1[i]); }
209 let dout = &mut dst[off..];
210 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
211 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b2[i]); }
212 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b3[i]); }
216 fn put_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
217 bink2_idct_old(&mut blk[0]);
218 bink2_idct_old(&mut blk[1]);
219 bink2_idct_old(&mut blk[2]);
220 bink2_idct_old(&mut blk[3]);
222 let dout = &mut dst[off..];
223 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
224 for i in 0..8 { row[i + 0] = clip8((b0[i] as i32) - 512); }
225 for i in 0..8 { row[i + 8] = clip8((b1[i] as i32) - 512); }
230 let dout = &mut dst[off..];
231 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
232 for i in 0..8 { row[i + 0] = clip8((b2[i] as i32) - 512); }
233 for i in 0..8 { row[i + 8] = clip8((b3[i] as i32) - 512); }
237 fn add_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
238 bink2_idct_old(&mut blk[0]);
239 bink2_idct_old(&mut blk[1]);
240 bink2_idct_old(&mut blk[2]);
241 bink2_idct_old(&mut blk[3]);
243 let dout = &mut dst[off..];
244 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
245 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b0[i] as i32) - 512); }
246 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b1[i] as i32) - 512); }
251 let dout = &mut dst[off..];
252 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
253 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b2[i] as i32) - 512); }
254 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b3[i] as i32) - 512); }
258 fn mc_luma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
259 let sx = (xoff as isize) + ((mv.x >> 1) as isize);
260 let sy = (yoff as isize) + ((mv.y >> 1) as isize);
261 let mode = (mv.x & 1) + (mv.y & 1) * 2;
262 let (d_x, add_x) = if (mv.x & 1) != 0 { (2, 5) } else { (0, 0) };
263 let (d_y, add_y) = if (mv.y & 1) != 0 { (2, 5) } else { (0, 0) };
265 let (w, h) = ref_pic.get_dimensions(plane);
266 let align_w = ((w + 31) & !31) as isize;
267 let align_h = ((h + 31) & !31) as isize;
268 validate!((sx - d_x >= 0) && (sx - d_x + add_x + 16 <= align_w));
269 validate!((sy - d_y >= 0) && (sy - d_y + add_y + 16 <= align_h));
270 let pstride = ref_pic.get_stride(plane);
271 let mut poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
272 let pdata = ref_pic.get_data();
273 let ppix = pdata.as_slice();
275 let dst = &mut dst[xoff + (yoff & 31) * stride..];
279 let src = &ppix[poff..];
280 for (out, row) in dst.chunks_mut(stride).take(16).zip(src.chunks(pstride)) {
281 for i in 0..16 { out[i] = row[i]; }
285 for out in dst.chunks_mut(stride).take(16) {
287 out[i] = clip8(luma_filter!(ppix, poff + i, 1));
293 for out in dst.chunks_mut(stride).take(16) {
295 out[i] = clip8(luma_filter!(ppix, poff + i, pstride));
301 let mut tmp = [0i16; 21 * 16];
302 for out in tmp.chunks_mut(16) {
304 out[i] = luma_filter!(ppix, poff - 2 * pstride + i, 1) as i16;
308 for (row, out) in dst.chunks_mut(stride).take(16).enumerate() {
310 out[i] = clip8(luma_filter!(tmp, (row + 2) * 16 + i, 16));
318 fn mc_chroma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
319 let sx = (xoff as isize) + ((mv.x >> 2) as isize);
320 let sy = (yoff as isize) + ((mv.y >> 2) as isize);
323 let add_x = if mx != 0 { 1 } else { 0 };
324 let add_y = if my != 0 { 1 } else { 0 };
326 let (w, h) = ref_pic.get_dimensions(plane);
327 let align_w = ((w + 15) & !15) as isize;
328 let align_h = ((h + 15) & !15) as isize;
329 validate!((sx >= 0) && (sx + add_x + 8 <= align_w));
330 validate!((sy >= 0) && (sy + add_y + 8 <= align_h));
331 let pstride = ref_pic.get_stride(plane);
332 let poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
333 let pdata = ref_pic.get_data();
334 let ppix = pdata.as_slice();
336 let dst = &mut dst[xoff + (yoff & 15) * stride..];
337 if (mx == 0) && (my == 0) {
338 let inpix = &ppix[poff..];
339 for (out, src) in dst.chunks_mut(stride).take(8).zip(inpix.chunks(pstride)) {
340 for i in 0..8 { out[i] = src[i]; }
343 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, 1, mx, 2);
345 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, pstride, my, 2);
347 let mut tmp = [0u16; 9 * 8];
348 chroma_interp!(tmp, 8, 9, u16, &ppix[poff..], pstride, 1, mx, 0);
349 chroma_interp!(dst, stride, 8, u8, &tmp, 8, 8, my, 4);
355 fn mid_pred<T:PartialOrd>(a: T, b: T, c: T) -> T {
360 if a < c { c } else { a }
364 if a < c { a } else { c }
380 fn resize(&mut self, bw: usize) {
381 self.qstride = bw * 2;
382 self.quants.resize(self.qstride * 2, 0);
384 self.pqpos = self.qstride;
386 fn update_line(&mut self) {
387 mem::swap(&mut self.qpos, &mut self.pqpos);
389 fn pred_quant(&self, pos: usize, is_top: bool) -> u8 {
390 let is_left = pos < 2;
392 if is_left { 16 } else { self.quants[self.qpos + pos - 2] }
395 self.quants[self.pqpos + pos]
397 mid_pred(self.quants[self.pqpos + pos - 2],
398 self.quants[self.pqpos + pos],
399 self.quants[self.qpos + pos - 2])
403 fn set_quant(&mut self, pos: usize, q: u8) {
404 self.quants[self.qpos + pos] = q;
419 fn resize(&mut self, bw: usize) {
420 self.stride = bw * 4 + 4;
422 self.prev_dcs.resize(self.stride, 0);
423 self.new_dcs.resize(self.stride, 0);
425 fn update_line(&mut self) {
426 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
428 fn set_dcs(&mut self, bx: usize, dc5: i32, dc7: i32, dc13: i32, dc10: i32, dc11: i32, dc14: i32, dc15: i32) {
433 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
452 fn resize(&mut self, bw: usize) {
453 self.stride = bw * 2 + 2;
455 self.prev_dcs.resize(self.stride, 0);
456 self.new_dcs.resize(self.stride, 0);
458 fn update_line(&mut self) {
459 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
461 fn set_dcs(&mut self, bx: usize, dc1: i32, dc2: i32, dc3: i32) {
465 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
472 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool>;
473 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32);
474 fn predict_inter(&mut self, min_dc: i32, max_dc: i32);
477 fn dc_pred2(a: i32, b: i32) -> i32 {
478 (a.max(b)).min(a.min(b).max(a * 2 - b))
480 fn dc_pred(a: i32, b: i32, c: i32) -> i32 {
481 (a.max(b).max(c)).min((a.min(b).min(c)).max(b - a + c))
484 impl DCInfo for YDCInfo {
485 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
486 decode_dcs(br, &mut self.dc_buf, q)
488 #[allow(non_snake_case)]
489 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
490 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
491 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
492 let prev_dc = &self.prev_dcs[bx * 4..];
493 let dst = &mut self.dcs;
494 let dcs = &self.dc_buf;
496 if is_top { //zigzag in 2x2 blocks
497 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
498 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
499 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
500 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
501 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
503 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
504 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
505 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
506 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
508 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
509 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
510 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
511 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
513 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
514 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
515 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
516 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
518 a0 = (dcs[ 0] + dc_pred2(prev_dc[4], prev_dc[5])).max(min_dc).min(max_dc);
519 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
520 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
521 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
523 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
524 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
525 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
526 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
528 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
529 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
530 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
531 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
533 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
534 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
535 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
536 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
540 a0 = (dcs[ 0] + dc_pred2(dst[5], dst[7])).max(min_dc).min(max_dc);
541 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
542 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
543 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
545 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
546 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
547 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
548 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
550 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
551 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
552 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
553 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
555 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
556 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
557 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
558 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
560 a0 = (dcs[ 0] + dc_pred(prev_dc[3], prev_dc[4], dst[5])).max(min_dc).min(max_dc);
561 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
562 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
563 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
565 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
566 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
567 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
568 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
570 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
571 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
572 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
573 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
575 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
576 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
577 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
578 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
597 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
603 #[allow(non_snake_case)]
604 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
605 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
606 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
607 let dst = &mut self.dcs;
608 let dcs = &self.dc_buf;
609 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
610 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
611 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
612 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
614 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
615 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
616 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
617 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
619 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
620 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
621 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
622 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
624 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
625 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
626 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
627 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
648 impl DCInfo for CDCInfo {
649 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
650 decode_dcs(br, &mut self.dc_buf, q)
652 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
653 let prev_dc = &self.prev_dcs[bx * 2..];
654 let dst = &mut self.dcs;
655 let dcs = &self.dc_buf;
657 let a0; let a1; let a2; let a3;
660 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
661 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
662 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
664 a0 = (dcs[ 0] + dc_pred2(prev_dc[2], prev_dc[3])).max(min_dc).min(max_dc);
665 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
667 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
668 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
671 a0 = (dcs[ 0] + dc_pred2(dst[1], dst[3])).max(min_dc).min(max_dc);
672 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
674 a0 = (dcs[ 0] + dc_pred(prev_dc[1], prev_dc[2], dst[1])).max(min_dc).min(max_dc);
675 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
677 a2 = (dcs[ 2] + dc_pred(dst[1], dst[3], a0)).max(min_dc).min(max_dc);
678 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
684 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
688 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
689 let dst = &mut self.dcs;
690 let dcs = &self.dc_buf;
692 let a0; let a1; let a2; let a3;
694 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
695 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
696 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
697 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
706 fn decode_dcs(br: &mut BitReader, dcs: &mut [i32], q: u8) -> DecoderResult<bool> {
707 if !br.read_bool()? {
708 for dc in dcs.iter_mut() {
713 let quant = BINK2_QUANT_DC[q.max(8) as usize];
714 for dc in dcs.iter_mut() {
715 *dc = br.read_bink2_code_zero()?;
717 *dc = (*dc * quant + 0x1FF) >> 10;
735 fn resize(&mut self, bw: usize) {
736 self.stride = bw * 4;
738 self.prev_off = self.stride;
739 self.mvs.resize(self.stride * 2, ZERO_MV);
741 fn update_line(&mut self) {
742 mem::swap(&mut self.mv_off, &mut self.prev_off);
744 fn decode_mv_new(&mut self, br: &mut BitReader, mv_cb: &Codebook<i8>, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
745 let num_mv = if br.read_bool()? { 1 } else { 4 };
746 let mv = &mut self.mvs;
747 let mv_pos = self.mv_off + bx * 4;
748 let ref_pos = self.prev_off + bx * 4;
753 let raw_val = br.read_cb(mv_cb)?;
754 if raw_val != BINK2_MV_ESC {
755 val = raw_val as i16;
757 let len = br.read_code(UintCodeType::LimitedUnary(12, 1))? as u8;
759 let uval = (br.read(nlen)? as i32) + (1 << nlen) - 1;
761 val = (-(uval >> 1) - 1) as i16;
763 val = (uval >> 1) as i16;
767 mv[mv_pos + i].x = val;
769 mv[mv_pos + i].y = val;
777 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
778 mv[mv_pos + 0] = mv0;
779 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
780 mv[mv_pos + 2] = mv2;
781 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
782 mv[mv_pos + 1] = mv1;
783 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
784 mv[mv_pos + 3] = mv3;
786 let mv1 = mv[mv_pos + 1] + mv[mv_pos + 0];
787 mv[mv_pos + 1] = mv1;
788 let mv2 = mv[mv_pos + 2] + mv[mv_pos + 0];
789 mv[mv_pos + 2] = mv2;
790 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
791 mv[mv_pos + 3] = mv3;
795 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
796 mv[mv_pos + 0] = mv0;
797 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
798 mv[mv_pos + 1] = mv1;
799 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
800 mv[mv_pos + 2] = mv2;
801 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
802 mv[mv_pos + 3] = mv3;
804 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 2], mv[ref_pos - 1], mv[mv_pos - 3]);
805 mv[mv_pos + 0] = mv0;
806 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
807 mv[mv_pos + 1] = mv1;
808 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
809 mv[mv_pos + 2] = mv2;
810 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
811 mv[mv_pos + 3] = mv3;
815 let mut mv_pred = mv[mv_pos + 0];
818 mv_pred += MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
822 mv_pred += MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
824 mv_pred += MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
827 mv[mv_pos + 0] = mv_pred;
828 mv[mv_pos + 1] = mv_pred;
829 mv[mv_pos + 2] = mv_pred;
830 mv[mv_pos + 3] = mv_pred;
834 fn decode_mv_old(&mut self, br: &mut BitReader, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
835 let mv = &mut self.mvs;
836 let mv_pos = self.mv_off + bx * 4;
837 let ref_pos = self.prev_off + bx * 4;
842 let mut bits = br.read(3)? as u8;
844 bits += br.read(2)? as u8;
846 let mut mv_c: [i16; 4] = [0; 4];
849 mv_c[i] = br.read(bits)? as i16;
852 if (mv_c[i] != 0) && br.read_bool()? {
857 if is_top && is_left {
858 let mut val = br.read(5)? as i16;
859 if (val != 0) && br.read_bool()? {
870 mv[mv_pos + i].x = mv_c[i];
874 mv[mv_pos + i].y = mv_c[i];
880 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
881 mv[mv_pos + 0] = mv0;
882 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
883 mv[mv_pos + 1] = mv1;
884 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
885 mv[mv_pos + 2] = mv2;
886 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
887 mv[mv_pos + 3] = mv3;
889 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
890 mv[mv_pos + 0] = mv0;
891 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
892 mv[mv_pos + 1] = mv1;
893 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
894 mv[mv_pos + 2] = mv2;
895 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
896 mv[mv_pos + 3] = mv3;
900 let base_mv = MV { x: basex * 16, y: basey * 16 };
901 mv[mv_pos + 0] += base_mv;
902 mv[mv_pos + 1] += base_mv;
903 mv[mv_pos + 2] += base_mv;
904 mv[mv_pos + 3] += base_mv;
906 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
907 mv[mv_pos + 0] = mv0;
908 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
909 mv[mv_pos + 2] = mv2;
910 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
911 mv[mv_pos + 1] = mv1;
912 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
913 mv[mv_pos + 3] = mv3;
919 fn predict_mvs(&mut self, bx: usize, is_top: bool, is_left: bool, is_new: bool) {
920 let mv = &mut self.mvs;
921 let mv_pos = self.mv_off + bx * 4;
922 let ref_pos = self.prev_off + bx * 4;
927 mv[mv_pos + i] = ZERO_MV;
930 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
931 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
932 mv[mv_pos + 1] = MV::pred(mv[mv_pos - 1], mv[mv_pos + 0], mv[mv_pos + 2]);
933 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
937 mv[mv_pos + 0] = MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
938 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
939 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
940 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
942 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 3], mv[ref_pos - 1], mv[ref_pos + 2]);
943 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
945 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
947 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
949 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
954 fn get_mv(&self, bx: usize, blk: usize) -> MV { self.mvs[self.mv_off + bx * 4 + blk] }
955 fn zero(&mut self, bx: usize) {
956 let pos = self.mv_off + bx * 4;
957 self.mvs[pos + 0] = ZERO_MV;
958 self.mvs[pos + 1] = ZERO_MV;
959 self.mvs[pos + 2] = ZERO_MV;
960 self.mvs[pos + 3] = ZERO_MV;
965 ac_cb1: Codebook<u8>,
966 ac_cb2: Codebook<u8>,
968 val_cb1: Codebook<u8>,
969 val_cb2: Codebook<u8>,
970 skip_cb1: Codebook<u8>,
971 skip_cb2: Codebook<u8>,
972 quant_cb: Codebook<u8>,
975 fn map_ac(idx: usize) -> u8 { idx as u8 }
976 fn map_mv(idx: usize) -> i8 { BINK2_MV_SYMS[idx] }
978 impl Default for Bink2Codes {
979 fn default() -> Self {
980 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES1, BINK2_AC_BITS1, map_ac);
981 let ac_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
982 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES2, BINK2_AC_BITS2, map_ac);
983 let ac_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
984 let mut cbr = TableCodebookDescReader::new(BINK2_MV_CODES, BINK2_MV_BITS, map_mv);
985 let mv_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
986 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES1, BINK2_AC_VAL_BITS1, map_ac);
987 let val_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
988 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES2, BINK2_AC_VAL_BITS2, map_ac);
989 let val_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
990 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES1, BINK2_AC_SKIP_BITS1, map_ac);
991 let skip_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
992 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES2, BINK2_AC_SKIP_BITS2, map_ac);
993 let skip_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
994 let mut cbr = TableCodebookDescReader::new(BINK2_QUANT_CODES, BINK2_QUANT_BITS, map_ac);
995 let quant_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
996 Self { ac_cb1, ac_cb2, mv_cb, val_cb1, val_cb2, skip_cb1, skip_cb2, quant_cb }
1001 struct Bink2Decoder {
1002 info: NACodecInfoRef,
1007 slice_h: [usize; 8],
1023 #[allow(clippy::erasing_op)]
1029 fn decode_frame_new(&mut self, br: &mut BitReader, buf: &mut NAVideoBuffer<u8>, is_intra: bool) -> DecoderResult<()> {
1030 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));
1031 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));
1032 let (ooff_y, ooff_u, ooff_v, ooff_a) = (off_y, off_u, off_v, off_a);
1033 let (width, height) = buf.get_dimensions(0);
1034 let data = buf.get_data_mut().unwrap();
1035 let dst = data.as_mut_slice();
1036 let bw = (width + 31) >> 5;
1037 let bheight = (height + 31) >> 5;
1038 self.cur_w = (width + 7) & !7;
1039 self.cur_h = ((height + 7) & !7) >> 1;
1041 let frame_flags = br.read(32)?;
1042 let mut offsets: [u32; 7] = [0; 7];
1043 for i in 0..self.num_slices-1 {
1044 offsets[i] = br.read(32)?;
1046 let mut do_alpha = self.has_alpha;
1047 if (frame_flags & 0x80000) != 0 && self.has_alpha {
1049 let fillval = (frame_flags >> 24) as u8;
1050 let aplane = &mut dst[off_a..][..stride_a * bheight * 32];
1051 for el in aplane.iter_mut() {
1055 let mut row_flags: Vec<bool> = Vec::with_capacity(bheight * 4);
1056 let mut col_flags: Vec<bool> = Vec::with_capacity(bw * 4);
1057 if (frame_flags & 0x10000) != 0 {
1058 if (frame_flags & 0x8000) == 0 {
1059 let len = (height + 15) >> 4;
1060 decode_flags(br, &mut row_flags, 1, len * 2 - 1)?;
1062 if (frame_flags & 0x4000) == 0 {
1063 let len = (width + 15) >> 4;
1064 decode_flags(br, &mut col_flags, 1, len * 2 - 1)?;
1067 row_flags.resize(bheight * 4, false);
1068 col_flags.resize(bw * 4, false);
1069 //store frame_flags * 8 & 0x7F8
1071 let mut start_by = 0;
1072 for slice_no in 0..self.num_slices {
1073 let end_by = self.slice_h[slice_no];
1075 br.seek(offsets[slice_no - 1] * 8)?;
1077 off_y = ooff_y + stride_y * start_by * 32;
1078 off_u = ooff_u + stride_u * start_by * 16;
1079 off_v = ooff_v + stride_v * start_by * 16;
1080 off_a = ooff_a + stride_a * start_by * 32;
1082 let mut row_state = frame_flags & 0x2E000;
1084 row_state |= 0x10000;
1086 self.qinfo.resize(bw);
1087 self.y_dcs.resize(bw);
1088 self.u_dcs.resize(bw);
1089 self.v_dcs.resize(bw);
1090 self.a_dcs.resize(bw);
1091 self.mvs.resize(bw);
1092 for by in start_by..end_by {
1097 let mut cbp_y_p = 0;
1098 let mut cbp_u_p = 0;
1099 let mut cbp_v_p = 0;
1100 let mut cbp_a_p = 0;
1109 let rflags = (row_flags[by] as u32) * 4;
1110 row_state = (row_state & 0x3FFFFFF) | ((row_state >> 4) & 0xC000000) | (rflags << 28);
1114 // row_state |= 0x8;
1116 if by + 2 >= end_by {
1120 let mut btype_lru: [u8; 4] = [ 2, 3, 1, 0 ];
1121 let mut edge_state = 0;
1122 let is_top = by == start_by;
1124 let mut blk_state = row_state | (edge_state & 0x3FC0000);
1134 let clflags = (col_flags[bx] as u32) * 4;
1135 let edge_state_c = ((blk_state >> 4) & 0x3C0000) | (blk_state & 0xFC03FFFF) | ((clflags & 0xF) << 22);
1136 let edge_state_y = (frame_flags & 0x40000) | (blk_state & 0x3FFFF);
1137 edge_state = edge_state_c;
1139 //let is_top = (edge_state & 0x88) != 0;
1140 let is_left = bx == 0; //(edge_state & 0x20) != 0;
1146 if (blk_state & 0x2000) != 0 {
1147 let val = br.read_code(UintCodeType::LimitedUnary(3, 1))?;
1150 btype = btype_lru[0];
1153 btype = btype_lru[1];
1154 btype_lru[1] = btype_lru[0];
1155 btype_lru[0] = btype;
1158 btype = btype_lru[3];
1159 btype_lru[3] = btype_lru[2];
1160 btype_lru[2] = btype;
1163 btype = btype_lru[2];
1164 btype_lru[2] = btype_lru[1];
1165 btype_lru[1] = btype;
1167 _ => unreachable!(),
1170 btype = br.read(2)? as u8;
1174 let q = self.qinfo.pred_quant(bx * 2, is_top);
1175 self.qinfo.set_quant(bx * 2, q);
1176 let q = self.qinfo.pred_quant(bx * 2 + 1, is_top);
1177 self.qinfo.set_quant(bx * 2 + 1, q);
1181 if (frame_flags & 0x2000) != 0 {
1182 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1183 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1184 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1185 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2, is_top))?;
1186 self.qinfo.set_quant(bx * 2, q);
1187 cbp_y = decode_luma_intra(br, &self.codes, cbp_y, q, &mut yblk, edge_state_y, &mut self.y_dcs, bx)?;
1188 cbp_v = decode_chroma_intra(br, &self.codes, cbp_v, q, &mut vblk, edge_state_c, &mut self.v_dcs, bx)?;
1189 cbp_u = decode_chroma_intra(br, &self.codes, cbp_u, q, &mut ublk, edge_state_c, &mut self.u_dcs, bx)?;
1191 let mut ablk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1192 cbp_a = decode_luma_intra(br, &self.codes, cbp_a, q, &mut ablk, edge_state_y, &mut self.a_dcs, bx)?;
1193 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1194 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1195 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1196 Bink2DSP::put_mb4(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1198 //if smth else decode one more y
1199 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1200 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1201 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1202 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1203 Bink2DSP::put_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1204 Bink2DSP::put_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1206 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1207 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1208 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1209 cbp_y = decode_luma_intra_old(br, &self.codes, cbp_y, &mut yblk, edge_state_y, &mut self.y_dcs, bx, &mut q_y)?;
1210 cbp_v = decode_chroma_intra_old(br, &self.codes, cbp_v, &mut vblk, edge_state_c, &mut self.v_dcs, bx, &mut q_v)?;
1211 cbp_u = decode_chroma_intra_old(br, &self.codes, cbp_u, &mut ublk, edge_state_c, &mut self.u_dcs, bx, &mut q_u)?;
1213 let mut ablk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1214 cbp_a = decode_luma_intra_old(br, &self.codes, cbp_a, &mut ablk, edge_state_y, &mut self.a_dcs, bx, &mut q_a)?;
1215 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1216 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1217 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1218 Bink2DSP::put_mb4_old(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1220 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1221 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1222 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1223 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1224 Bink2DSP::put_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1225 Bink2DSP::put_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1228 self.mvs.predict_mvs(bx, is_top, is_left, (frame_flags & 0x2000) != 0);
1232 if let Some(ref ref_pic) = self.ips.get_ref() {
1233 for blk_no in 0..4 {
1234 let xoff = bx * 32 + (blk_no & 1) * 16;
1235 let yoff = by * 32 + (blk_no & 2) * 8;
1236 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, ZERO_MV, 0)?;
1237 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 1)?;
1238 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 2)?;
1240 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, ZERO_MV, 3)?;
1244 return Err(DecoderError::MissingReference);
1249 if (frame_flags & 0x2000) != 0 {
1250 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1252 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1254 if let Some(ref ref_pic) = self.ips.get_ref() {
1255 for blk_no in 0..4 {
1256 let xoff = bx * 32 + (blk_no & 1) * 16;
1257 let yoff = by * 32 + (blk_no & 2) * 8;
1258 let mv = self.mvs.get_mv(bx, blk_no);
1259 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1260 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1261 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1263 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, mv, 3)?;
1267 return Err(DecoderError::MissingReference);
1271 if (frame_flags & 0x2000) != 0 {
1272 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1274 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1276 if let Some(ref ref_pic) = self.ips.get_ref() {
1277 for blk_no in 0..4 {
1278 let xoff = bx * 32 + (blk_no & 1) * 16;
1279 let yoff = by * 32 + (blk_no & 2) * 8;
1280 let mv = self.mvs.get_mv(bx, blk_no);
1281 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1282 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1283 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1285 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, mv, 3)?;
1289 return Err(DecoderError::MissingReference);
1291 if (frame_flags & 0x2000) != 0 {
1292 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1293 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1294 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1295 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2 + 1, is_top))?;
1296 self.qinfo.set_quant(bx * 2 + 1, q);
1297 cbp_y_p = decode_luma_inter(br, &self.codes, cbp_y_p, q, &mut yblk, edge_state_y, &mut self.y_dcs)?;
1298 if br.read_bool()? {
1299 cbp_v_p = decode_chroma_inter(br, &self.codes, cbp_v_p, q, &mut vblk, edge_state_y, &mut self.v_dcs)?;
1300 cbp_u_p = decode_chroma_inter(br, &self.codes, cbp_u_p, q, &mut ublk, edge_state_y, &mut self.u_dcs)?;
1306 let mut ablk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1307 cbp_a_p = decode_luma_inter(br, &self.codes, cbp_a_p, q, &mut ablk, edge_state_y, &mut self.a_dcs)?;
1308 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1309 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1310 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1311 Bink2DSP::add_mb4(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1313 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1314 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1315 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1316 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1317 Bink2DSP::add_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1318 Bink2DSP::add_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1320 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1321 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1322 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1323 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)?;
1324 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)?;
1325 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)?;
1327 let mut ablk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1328 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)?;
1329 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 0 + 0 * stride_a, stride_a, &mut ablk[0]);
1330 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 16 + 0 * stride_a, stride_a, &mut ablk[1]);
1331 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 0 + 16 * stride_a, stride_a, &mut ablk[2]);
1332 Bink2DSP::add_mb4_old(dst, off_a + bx * 32 + 16 + 16 * stride_a, stride_a, &mut ablk[3]);
1334 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1335 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1336 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1337 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1338 Bink2DSP::add_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1339 Bink2DSP::add_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1342 _ => unreachable!(),
1345 let src = &dst[off_y + bx * 32..];
1346 let dc5 = Bink2DSP::calc_dc(&src[24..], stride_y);
1347 let dc7 = Bink2DSP::calc_dc(&src[24 + stride_y * 8..], stride_y);
1348 let dc13 = Bink2DSP::calc_dc(&src[24 + stride_y * 16..], stride_y);
1349 let dc10 = Bink2DSP::calc_dc(&src[ 0 + stride_y * 24..], stride_y);
1350 let dc11 = Bink2DSP::calc_dc(&src[ 8 + stride_y * 24..], stride_y);
1351 let dc14 = Bink2DSP::calc_dc(&src[16 + stride_y * 24..], stride_y);
1352 let dc15 = Bink2DSP::calc_dc(&src[24 + stride_y * 24..], stride_y);
1353 self.y_dcs.set_dcs(bx, dc5, dc7, dc13, dc10, dc11, dc14, dc15);
1354 let src = &dst[off_u + bx * 16..];
1355 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_u);
1356 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_u * 8..], stride_u);
1357 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_u * 8..], stride_u);
1358 self.u_dcs.set_dcs(bx, dc1, dc2, dc3);
1359 let src = &dst[off_v + bx * 16..];
1360 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_v);
1361 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_v * 8..], stride_v);
1362 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_v * 8..], stride_v);
1363 self.v_dcs.set_dcs(bx, dc1, dc2, dc3);
1365 let src = &dst[off_a + bx * 32..];
1366 let dc5 = Bink2DSP::calc_dc(&src[24..], stride_a);
1367 let dc7 = Bink2DSP::calc_dc(&src[24 + stride_y * 8..], stride_a);
1368 let dc13 = Bink2DSP::calc_dc(&src[24 + stride_y * 16..], stride_a);
1369 let dc10 = Bink2DSP::calc_dc(&src[ 0 + stride_y * 24..], stride_a);
1370 let dc11 = Bink2DSP::calc_dc(&src[ 8 + stride_y * 24..], stride_a);
1371 let dc14 = Bink2DSP::calc_dc(&src[16 + stride_y * 24..], stride_a);
1372 let dc15 = Bink2DSP::calc_dc(&src[24 + stride_y * 24..], stride_a);
1373 self.a_dcs.set_dcs(bx, dc5, dc7, dc13, dc10, dc11, dc14, dc15);
1377 self.qinfo.update_line();
1378 self.y_dcs.update_line();
1379 self.u_dcs.update_line();
1380 self.v_dcs.update_line();
1381 self.a_dcs.update_line();
1382 self.mvs.update_line();
1383 off_y += stride_y * 32;
1384 off_u += stride_u * 16;
1385 off_v += stride_v * 16;
1386 off_a += stride_a * 32;
1387 row_state = (row_state & !0x190) | ((row_state & 4) << 2);
1389 start_by = self.slice_h[slice_no];
1395 fn decode_flags(br: &mut BitReader, dst: &mut Vec<bool>, start: usize, nbits: usize) -> DecoderResult<()> {
1399 if !br.read_bool()? {
1401 let bit = br.read_bool()?;
1405 let mut cur_bits = nbits;
1407 let mut lastbit = false;
1408 while cur_bits > 0 {
1409 if !br.read_bool()? {
1410 lastbit = if mode == 3 { !lastbit } else { br.read_bool()? };
1413 let len = cur_bits.min(4);
1415 let bit = br.read_bool()?;
1424 } else if cur_bits < 16 {
1429 lastbit = if mode == 3 { !lastbit } else { br.read_bool()? };
1430 let mut run = (if mode == 3 { bread + 1 } else { bread + 2 } as usize).min(cur_bits);
1431 if run != cur_bits {
1432 let add_run = br.read(bread)? as usize;
1434 mode = if add_run == (1 << bread) - 1 { 1 } else { 3 };
1446 fn get_new_quant(br: &mut BitReader, prev_q: u8) -> DecoderResult<u8> {
1447 let mut code = br.read_code(UintCodeType::LimitedUnary(4, 1))? as u8;
1452 code += br.read(1)? as u8;
1453 } else if code == 4 {
1454 code = (br.read(5)? as u8) + 5;
1457 if !br.read_bool()? {
1458 ret = prev_q.checked_add(code);
1460 ret = prev_q.checked_sub(code);
1462 validate!(ret.is_some());
1463 let val = ret.unwrap();
1464 validate!(val < (BINK2_QUANT_DC.len() as u8));
1469 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> {
1470 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1471 let _coded = dcinfo.decode_dcs(br, q)?;
1472 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1473 let dcs = &dcinfo.dcs;
1475 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTRA_LUMA, q, cbp >> (i * 4))?;
1476 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j] * 8 + 32; }
1481 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> {
1482 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1483 let _coded = dcinfo.decode_dcs(br, q)?;
1484 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1485 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTRA_CHROMA, q, cbp)?;
1486 let dcs = &dcinfo.dcs;
1487 for i in 0..4 { dst[i][0] = dcs[i] * 8 + 32; }
1491 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> {
1492 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1493 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1494 let _coded = dcinfo.decode_dcs(br, q)?;
1495 dcinfo.predict_inter(min_dc, max_dc);
1496 let dcs = &dcinfo.dcs;
1498 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTER, q, cbp >> (i * 4))?;
1499 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j] * 8; }
1504 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> {
1505 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1506 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1507 let _coded = dcinfo.decode_dcs(br, q)?;
1508 dcinfo.predict_inter(min_dc, max_dc);
1509 let dcs = &dcinfo.dcs;
1510 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTER, q, cbp)?;
1511 for i in 0..4 { dst[i][0] = dcs[i] * 8; }
1515 fn decode_cbp_luma(br: &mut BitReader, prev_cbp: u32, edge_state: u32) -> DecoderResult<u32> {
1516 let cnt = (prev_cbp as u16).count_ones() as usize;
1517 let (min_count, mask) = if cnt < 8 { (cnt, 0x0000) } else { (16 - cnt, 0xFFFF) };
1520 if br.read_bool()? {
1522 } else if min_count >= 4 {
1527 if !br.read_bool()? {
1528 let cbp4 = br.read(4)?;
1529 cbp |= cbp4 << (i * 4);
1534 if ((edge_state & 0x40000) == 0) || (cbp != 0) {
1535 if br.read_bool()? {
1541 fn decode_cbp_chroma(br: &mut BitReader, last_cbp: u32) -> DecoderResult<u32> {
1542 if br.read_bool()? {
1543 Ok((last_cbp & 0xF0000) | BINK2_CHROMA_CBPS[(last_cbp & 0xF) as usize])
1545 let ncbp = br.read(4)?;
1546 if br.read_bool()? {
1547 Ok(ncbp | (ncbp << 16))
1554 trait ReadBink2Code {
1555 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32>;
1556 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32>;
1559 impl<'a> ReadBink2Code for BitReader<'a> {
1560 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32> {
1561 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? as i32;
1565 let add_bits = self.read((pfx as u8) - 3)? as i32;
1566 val = (1 << (pfx - 3)) + add_bits + 2;
1575 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32> {
1576 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? + 1;
1579 let add_bits = self.read((pfx as u8) - 3)? as i32;
1580 val = (1 << (pfx - 3)) + add_bits + 2;
1584 if self.read_bool()? {
1592 fn decode_acs_4blocks(br: &mut BitReader, codes: &Bink2Codes, dst: &mut [[i32; 64]; 4], quant_mat: &[[i32; 64]; 4], q: u8, cbp: u32) -> DecoderResult<()> {
1593 let cb = if (cbp >> 16) != 0 { &codes.ac_cb1 } else { &codes.ac_cb2 };
1594 let qmat = &quant_mat[(q & 3) as usize];
1596 for blk_no in 0..4 {
1597 if ((cbp >> blk_no) & 1) == 0 { continue; }
1598 let mut esc_len = 0;
1604 let sym = br.read_cb(cb)?;
1607 skip = br.read(6)? as usize;
1609 skip = BINK2_AC_RUNS[sym as usize];
1612 if idx > 63 { break; }
1613 esc_len = if sym == 13 { 6 } else { 0 };
1615 let level = br.read_bink2_code_nz()?;
1616 let pos = BINK2_ZIGZAG[idx];
1617 dst[blk_no][pos] = (((level * qmat[pos]) << shift) + 0x40) >> 7;
1620 // set blk info to (dc & 0x1FFF) | (intra ? 0x8000 : 0) | (((ncoded == 0) + (ncoded < 4) + (ncoded < 8)) << 13)
1625 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> {
1626 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1627 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1629 let is_top = (edge_state & 0x88) != 0;
1630 let is_left = (edge_state & 0x20) != 0;
1631 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1632 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1633 let dcs = &dcinfo.dcs;
1635 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTRA_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1636 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1641 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> {
1642 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1643 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1645 let is_top = (edge_state & 0x88) != 0;
1646 let is_left = (edge_state & 0x20) != 0;
1647 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1648 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1649 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1650 let dcs = &dcinfo.dcs;
1651 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1656 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> {
1657 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1658 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1660 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1661 dcinfo.predict_inter(-1023, 1023);
1662 let dcs = &dcinfo.dcs;
1664 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTER_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1665 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1670 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> {
1671 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1672 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1674 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1675 dcinfo.predict_inter(-1023, 1023);
1676 let dcs = &dcinfo.dcs;
1677 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1678 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1682 fn decode_quant_old(br: &mut BitReader, quant_cb: &Codebook<u8>, prev_quant: u8) -> DecoderResult<u8> {
1683 let diff = br.read_cb(quant_cb)?;
1688 if br.read_bool()? {
1689 res = prev_quant.checked_sub(diff);
1691 res = prev_quant.checked_add(diff);
1693 validate!(res.is_some());
1694 let q = res.unwrap();
1700 fn decode_cbp_luma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1702 if br.read_bool()? {
1703 if br.read_bool()? {
1704 return Ok(prev_cbp);
1706 low = prev_cbp & 0xFFFF;
1708 let mut nib1 = (prev_cbp >> 4) & 0xF;
1709 if !br.read_bool()? {
1712 let mut new_cbp = nib1;
1713 if !br.read_bool()? {
1716 new_cbp |= nib1 << 4;
1717 if !br.read_bool()? {
1720 new_cbp |= nib1 << 8;
1721 if !br.read_bool()? {
1724 low = new_cbp | (nib1 << 12);
1726 let mut nib_hi = (prev_cbp >> 20) & 0xF;
1729 let nib = (low >> (4 * i)) & 0xF;
1730 if nib.count_ones() == 0 {
1732 } else if (nib.count_ones() == 1) || !br.read_bool()? {
1735 if (((nib >> bit) & 1) != 0) && br.read_bool()? {
1741 high = (high >> 4) | (nib_hi << 28);
1746 fn decode_cbp_chroma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1748 if !br.read_bool()? {
1751 if br.read_bool()? {
1752 return Ok(prev_cbp);
1754 low = prev_cbp & 0xF;
1757 if low.count_ones() == 0 {
1760 if low.count_ones() != 1 {
1761 high = (prev_cbp >> 16) & low;
1762 if br.read_bool()? {
1763 return Ok((high << 16) | low);
1768 if (((low >> bit) & 1) != 0) && br.read_bool()? {
1772 Ok((high << 16) | low)
1775 fn decode_dcs_old(br: &mut BitReader, dcs: &mut [i32], q: u8, read_bias: bool) -> DecoderResult<()> {
1776 let mut bits = br.read(3)? as u8;
1778 bits += br.read(2)? as u8;
1780 let scale = BINK2_OLD_DC_QUANTS[q as usize];
1782 for el in dcs.iter_mut() { *el = 0; }
1784 for dcb in dcs.chunks_mut(4) {
1785 for dc in dcb.iter_mut() {
1786 *dc = br.read(bits)? as i32;
1788 for dc in dcb.iter_mut() {
1789 if *dc == 0 { continue; }
1791 if br.read_bool()? {
1798 let add_bits = BINK2_DC_EXTRA_BITS[q as usize] + bits;
1800 let pfx = br.read(10 - add_bits)? as i32;
1803 if br.read_bool()? {
1804 base_dc = -(pfx << bits);
1806 base_dc = pfx << bits;
1811 dcs[0] += base_dc * scale;
1817 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<()> {
1818 let quant = BINK2_OLD_QUANTS[q as usize];
1819 for blk_no in 0..4 {
1820 if ((cbp >> blk_no) & 1) == 0 { continue; }
1821 let val_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.val_cb2 } else { &codes.val_cb1 };
1822 let skip_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.skip_cb2 } else { &codes.skip_cb1 };
1823 let mut esc_len = 0;
1826 let val = br.read_cb(val_cb)?;
1830 let add_bits = br.read(val - 3)? as i32;
1831 level = (1 << (val - 3)) + add_bits + 2;
1835 if br.read_bool()? {
1838 let pos = scan[idx];
1839 dst[blk_no][pos] = (level as f32) * quant_mat[(pos & 7) * 8 + (pos >> 3)] * quant;
1842 if idx >= 64 { break; }
1846 let sym = br.read_cb(skip_cb)?;
1849 skip = br.read(6)? as usize;
1851 skip = BINK2_AC_RUNS[sym as usize];
1854 if idx > 63 { break; }
1855 esc_len = if sym == 13 { 6 } else { 0 };
1862 const KB2H_NUM_SLICES: [usize; 4] = [ 2, 3, 4, 8 ];
1864 impl NADecoder for Bink2Decoder {
1865 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
1866 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1867 let w = vinfo.get_width();
1868 let h = vinfo.get_height();
1870 let edata = info.get_extradata().unwrap();
1871 validate!(edata.len() >= 8);
1873 let mut mr = MemoryReader::new_read(&edata);
1874 let mut br = ByteReader::new(&mut mr);
1875 let magic = br.read_u32be()?;
1876 let flags = br.read_u32le()?;
1878 self.version = magic;
1879 self.has_alpha = (flags & 0x100000) != 0;
1881 let height_a = (h + 31) & !31;
1882 if self.version <= mktag!(b"KB2f") {
1883 self.num_slices = 2;
1884 self.slice_h[0] = (h + 32) >> 6;
1885 } else if self.version == mktag!(b"KB2g") {
1887 self.num_slices = 1;
1889 self.num_slices = 2;
1890 self.slice_h[0] = (h + 31) >> 6;
1893 self.num_slices = KB2H_NUM_SLICES[(flags & 3) as usize];
1895 let mut end = height_a + 32 * self.num_slices - 1;
1896 for i in 0..self.num_slices - 1 {
1897 start += ((end - start) / (self.num_slices - i)) & !31;
1899 self.slice_h[i] = start >> 5;
1902 self.slice_h[self.num_slices - 1] = height_a >> 5;
1905 let aplane = if self.has_alpha { Some(NAPixelChromaton::new(0, 0, false, 8, 0, 3, 1)) } else { None };
1906 fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
1907 Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
1908 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 1, 1)),
1909 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 2, 1)),
1911 if self.has_alpha { FORMATON_FLAG_ALPHA } else { 0 },
1912 if self.has_alpha { 4 } else { 3 });
1913 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
1914 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
1918 Err(DecoderError::InvalidData)
1921 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1922 let src = pkt.get_buffer();
1924 let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
1927 self.key_frame = pkt.is_keyframe();
1929 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 5)?;
1930 buf = bufinfo.get_vbuf().unwrap();
1932 self.decode_frame_new(&mut br, &mut buf, pkt.is_keyframe())?;
1933 let bufinfo = NABufferType::Video(buf);
1934 self.ips.add_frame(bufinfo.get_vbuf().unwrap());
1936 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
1937 frm.set_frame_type(if self.key_frame { FrameType::I } else { FrameType::P });
1940 fn flush(&mut self) {
1945 pub fn get_decoder() -> Box<dyn NADecoder> {
1946 Box::new(Bink2Decoder::new())
1951 use nihav_core::codecs::RegisteredDecoders;
1952 use nihav_core::demuxers::RegisteredDemuxers;
1953 use nihav_core::test::dec_video::*;
1954 use crate::codecs::rad_register_all_codecs;
1955 use crate::demuxers::rad_register_all_demuxers;
1958 let mut dmx_reg = RegisteredDemuxers::new();
1959 rad_register_all_demuxers(&mut dmx_reg);
1960 let mut dec_reg = RegisteredDecoders::new();
1961 rad_register_all_codecs(&mut dec_reg);
1963 //let file = "assets/RAD/Open_Logos_partial.bik";
1964 //let file = "assets/RAD/sc13_01_partial.bk2";
1965 let file = "assets/RAD/ge_video_86l.bk2";
1966 //let file = "assets/RAD/eg_club_0.bk2";
1967 test_file_decoding("bink", file, Some(8), true, false, None/*Some("bink2")*/, &dmx_reg, &dec_reg);
1971 const BINK2_ZIGZAG: [usize; 64] = [
1972 0, 8, 1, 2, 9, 16, 24, 17,
1973 10, 3, 4, 11, 18, 25, 32, 40,
1974 33, 26, 19, 12, 5, 6, 13, 20,
1975 27, 34, 41, 48, 56, 49, 42, 35,
1976 28, 21, 14, 7, 15, 22, 29, 36,
1977 43, 50, 57, 58, 51, 44, 37, 30,
1978 23, 31, 38, 45, 52, 59, 60, 53,
1979 46, 39, 47, 54, 61, 62, 55, 63
1981 const BINK2_LUMA_SCAN_OLD: &[usize; 64] = &[
1982 0, 2, 1, 8, 9, 17, 10, 16,
1983 24, 3, 18, 25, 32, 11, 33, 26,
1984 4, 40, 19, 12, 27, 41, 34, 5,
1985 20, 48, 6, 28, 15, 42, 23, 35,
1986 21, 13, 14, 7, 31, 43, 49, 36,
1987 22, 56, 39, 50, 30, 44, 29, 51,
1988 57, 47, 58, 59, 63, 61, 55, 38,
1989 52, 62, 45, 37, 60, 46, 54, 53
1991 const BINK2_CHROMA_SCAN_OLD: &[usize; 64] = &[
1992 0, 1, 8, 2, 9, 16, 10, 17,
1993 3, 24, 11, 18, 25, 13, 14, 4,
1994 15, 5, 6, 7, 12, 19, 20, 21,
1995 22, 23, 26, 27, 28, 29, 30, 31,
1996 32, 33, 34, 35, 36, 37, 38, 39,
1997 40, 41, 42, 43, 44, 45, 46, 47,
1998 48, 49, 50, 51, 52, 53, 54, 55,
1999 56, 57, 58, 59, 60, 61, 62, 63
2002 const BINK2_CHROMA_CBPS: [u32; 16] = [
2009 const BINK2_QUANT_DC: [i32; 37] = [
2010 0x400, 0x4C2, 0x5A8, 0x6BA, 0x800, 0x983, 0xB50, 0xD74,
2011 0x1000, 0x1307, 0x16A1, 0x1AE9, 0x2000, 0x260E, 0x2D41, 0x35D1,
2012 0x4000, 0x4C1C, 0x5A82, 0x6BA3, 0x8000, 0x9838, 0xB505, 0xD745,
2013 0x10000, 0x13070, 0x16A0A, 0x1AE8A, 0x20000, 0x260E0, 0x2D414, 0x35D14,
2014 0x40000, 0x4C1C0, 0x5A828, 0x6BA28, 0x80000
2017 const BINK2_QUANT_INTRA_LUMA: &[[i32; 64]; 4] = &[
2019 0x400, 0x598, 0x5E2, 0x49D, 0x733, 0x7E9, 0x1497, 0x2190,
2020 0x521, 0x685, 0x65E, 0x688, 0xA41, 0xD72, 0x1F57, 0x31FA,
2021 0x434, 0x6DB, 0x710, 0x79E, 0xF8C, 0x130B, 0x226D, 0x2E85,
2022 0x546, 0x74C, 0x84F, 0x7E0, 0x1275, 0x1162, 0x1E20, 0x25A5,
2023 0x99A, 0xC1F, 0x10CF, 0x10CF, 0x1B33, 0x1AB3, 0x2B47, 0x3435,
2024 0xD2F, 0x1648, 0x13BC, 0x17A1, 0x23EE, 0x1C40, 0x29E5, 0x266A,
2025 0x156E, 0x1D61, 0x1E75, 0x1BB3, 0x2B47, 0x2720, 0x34F7, 0x3270,
2026 0x1C6F, 0x1DE1, 0x1B6C, 0x17D1, 0x23E5, 0x2357, 0x3175, 0x35C8
2028 0x4C2, 0x6A7, 0x6FF, 0x57D, 0x890, 0x968, 0x187C, 0x27EA,
2029 0x619, 0x7C1, 0x792, 0x7C4, 0xC32, 0xFFD, 0x2545, 0x3B6F,
2030 0x4FF, 0x827, 0x866, 0x90F, 0x127D, 0x16A6, 0x28F1, 0x3752,
2031 0x646, 0x8AE, 0x9E2, 0x95E, 0x15F3, 0x14AC, 0x23D3, 0x2CC4,
2032 0xB6B, 0xE6A, 0x13FD, 0x13FE, 0x2059, 0x1FC0, 0x3378, 0x3E16,
2033 0xFAE, 0x1A7F, 0x1778, 0x1C1A, 0x2ABA, 0x2198, 0x31D3, 0x2DAE,
2034 0x197C, 0x22F0, 0x2438, 0x20F1, 0x3378, 0x2E87, 0x3EFD, 0x3BFA,
2035 0x21D1, 0x2388, 0x209C, 0x1C52, 0x2AAF, 0x2A07, 0x3AD0, 0x3FF5
2037 0x5A8, 0x7E9, 0x852, 0x687, 0xA2F, 0xB30, 0x1D1E, 0x2F77,
2038 0x740, 0x938, 0x901, 0x93C, 0xE81, 0x1303, 0x2C52, 0x46AE,
2039 0x5F1, 0x9B2, 0x9FD, 0xAC6, 0x15FC, 0x1AEE, 0x30B0, 0x41C9,
2040 0x775, 0xA52, 0xBC0, 0xB24, 0x1A1B, 0x1895, 0x2A9A, 0x353D,
2041 0xD94, 0x1124, 0x17C5, 0x17C6, 0x2677, 0x25C2, 0x3D34, 0x49D5,
2042 0x12A5, 0x1F82, 0x1BE9, 0x216B, 0x32CF, 0x27F3, 0x3B40, 0x3653,
2043 0x1E4E, 0x298D, 0x2B12, 0x272C, 0x3D34, 0x3755, 0x4AE7, 0x4753,
2044 0x2836, 0x2A41, 0x26C7, 0x21AE, 0x32C3, 0x31FA, 0x45F1, 0x4C0E
2046 0x6BA, 0x968, 0x9E5, 0x7C3, 0xC1C, 0xD4E, 0x22A0, 0x3872,
2047 0x8A0, 0xAF7, 0xAB5, 0xAFB, 0x113F, 0x169C, 0x34B5, 0x540D,
2048 0x711, 0xB87, 0xBE1, 0xCD0, 0x1A25, 0x2007, 0x39E6, 0x4E3C,
2049 0x8DF, 0xC46, 0xDFA, 0xD3F, 0x1F0B, 0x1D3C, 0x32A9, 0x3F4F,
2050 0x1025, 0x1462, 0x1C44, 0x1C46, 0x2DBF, 0x2CE7, 0x48C9, 0x57CE,
2051 0x162D, 0x2578, 0x2131, 0x27BE, 0x3C6D, 0x2F82, 0x4676, 0x409A,
2052 0x240A, 0x3169, 0x3338, 0x2E96, 0x48C9, 0x41CD, 0x5914, 0x54D3,
2053 0x2FD2, 0x3240, 0x2E1E, 0x280E, 0x3C5E, 0x3B6F, 0x532D, 0x5A73
2057 const BINK2_QUANT_INTRA_CHROMA: &[[i32; 64]; 4] = &[
2059 0x400, 0x4A9, 0x59A, 0x89B, 0x1600, 0x1221, 0x171C, 0x19A3,
2060 0x4A9, 0x656, 0x713, 0xE16, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
2061 0x59A, 0x713, 0xDBB, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
2062 0x89B, 0xE16, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
2063 0x1600, 0x19A3, 0x171C, 0x1221, 0x1600, 0x1221, 0x171C, 0x19A3,
2064 0x1221, 0x1520, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
2065 0x171C, 0x1AEE, 0x1847, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
2066 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1
2068 0x4C2, 0x58B, 0x6AA, 0xA3C, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
2069 0x58B, 0x789, 0x869, 0x10C0, 0x1E7D, 0x1920, 0x2007, 0x2388,
2070 0x6AA, 0x869, 0x1054, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
2071 0xA3C, 0x10C0, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
2072 0x1A2A, 0x1E7D, 0x1B7B, 0x158F, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
2073 0x158F, 0x1920, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
2074 0x1B7B, 0x2007, 0x1CDE, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
2075 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388
2077 0x5A8, 0x698, 0x7EC, 0xC2C, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
2078 0x698, 0x8F6, 0xA01, 0x13EB, 0x2442, 0x1DE1, 0x2616, 0x2A41,
2079 0x7EC, 0xA01, 0x136B, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
2080 0xC2C, 0x13EB, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
2081 0x1F1D, 0x2442, 0x20AF, 0x19A3, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
2082 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
2083 0x20AF, 0x2616, 0x2255, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
2084 0x2442, 0x2A41, 0x2616, 0x1DE1, 0x2442, 0x1DE1, 0x2616, 0x2A41
2086 0x6BA, 0x7D7, 0x96C, 0xE7A, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
2087 0x7D7, 0xAA9, 0xBE5, 0x17B0, 0x2B1E, 0x2388, 0x2D4B, 0x3240,
2088 0x96C, 0xBE5, 0x1718, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
2089 0xE7A, 0x17B0, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
2090 0x2500, 0x2B1E, 0x26DE, 0x1E7D, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
2091 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
2092 0x26DE, 0x2D4B, 0x28D4, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
2093 0x2B1E, 0x3240, 0x2D4B, 0x2388, 0x2B1E, 0x2388, 0x2D4B, 0x3240
2097 const BINK2_QUANT_INTER: &[[i32; 64]; 4] = &[
2099 0x400, 0x4A9, 0x434, 0x34C, 0x41C, 0x392, 0x4C9, 0x5D4,
2100 0x4A9, 0x56F, 0x4E6, 0x3D7, 0x4CB, 0x429, 0x5B7, 0x718,
2101 0x434, 0x4E6, 0x489, 0x3A8, 0x4AB, 0x40A, 0x5A4, 0x6CD,
2102 0x34C, 0x3D7, 0x3A8, 0x32B, 0x41F, 0x39F, 0x519, 0x630,
2103 0x41C, 0x4CB, 0x4AB, 0x41F, 0x5AB, 0x538, 0x778, 0x932,
2104 0x392, 0x429, 0x40A, 0x39F, 0x538, 0x521, 0x799, 0x9B6,
2105 0x4C9, 0x5B7, 0x5A4, 0x519, 0x778, 0x799, 0xBE4, 0xFC7,
2106 0x5D4, 0x718, 0x6CD, 0x630, 0x932, 0x9B6, 0xFC7, 0x162F
2108 0x4C2, 0x58B, 0x4FF, 0x3EB, 0x4E4, 0x43F, 0x5B1, 0x6EE,
2109 0x58B, 0x676, 0x5D3, 0x491, 0x5B3, 0x4F3, 0x6CB, 0x86F,
2110 0x4FF, 0x5D3, 0x565, 0x459, 0x58D, 0x4CE, 0x6B5, 0x816,
2111 0x3EB, 0x491, 0x459, 0x3C5, 0x4E6, 0x44F, 0x610, 0x75C,
2112 0x4E4, 0x5B3, 0x58D, 0x4E6, 0x6BD, 0x635, 0x8E2, 0xAEF,
2113 0x43F, 0x4F3, 0x4CE, 0x44F, 0x635, 0x61A, 0x909, 0xB8C,
2114 0x5B1, 0x6CB, 0x6B5, 0x610, 0x8E2, 0x909, 0xE24, 0x12C3,
2115 0x6EE, 0x86F, 0x816, 0x75C, 0xAEF, 0xB8C, 0x12C3, 0x1A61
2117 0x5A8, 0x698, 0x5F1, 0x4A9, 0x5D0, 0x50D, 0x6C4, 0x83E,
2118 0x698, 0x7AF, 0x6ED, 0x56F, 0x6C7, 0x5E3, 0x814, 0xA08,
2119 0x5F1, 0x6ED, 0x66A, 0x52B, 0x69A, 0x5B6, 0x7FA, 0x99E,
2120 0x4A9, 0x56F, 0x52B, 0x47B, 0x5D4, 0x51F, 0x735, 0x8C1,
2121 0x5D0, 0x6C7, 0x69A, 0x5D4, 0x804, 0x761, 0xA90, 0xD00,
2122 0x50D, 0x5E3, 0x5B6, 0x51F, 0x761, 0x741, 0xABF, 0xDBB,
2123 0x6C4, 0x814, 0x7FA, 0x735, 0xA90, 0xABF, 0x10D2, 0x1650,
2124 0x83E, 0xA08, 0x99E, 0x8C1, 0xD00, 0xDBB, 0x1650, 0x1F5F
2126 0x6BA, 0x7D7, 0x711, 0x58B, 0x6EA, 0x601, 0x80C, 0x9CD,
2127 0x7D7, 0x923, 0x83C, 0x676, 0x80F, 0x700, 0x99C, 0xBEE,
2128 0x711, 0x83C, 0x7A1, 0x626, 0x7DA, 0x6CB, 0x97C, 0xB70,
2129 0x58B, 0x676, 0x626, 0x554, 0x6EE, 0x617, 0x893, 0xA68,
2130 0x6EA, 0x80F, 0x7DA, 0x6EE, 0x988, 0x8C7, 0xC90, 0xF76,
2131 0x601, 0x700, 0x6CB, 0x617, 0x8C7, 0x8A1, 0xCC7, 0x1055,
2132 0x80C, 0x99C, 0x97C, 0x893, 0xC90, 0xCC7, 0x1400, 0x1A89,
2133 0x9CD, 0xBEE, 0xB70, 0xA68, 0xF76, 0x1055, 0x1A89, 0x254E
2137 const BINK2_AC_CODES1: &[u8] = &[
2138 0x01, 0x04, 0x00, 0x08, 0x02, 0x32, 0x0A, 0x12,
2139 0x3A, 0x7A, 0xFA, 0x72, 0x06, 0x1A
2141 const BINK2_AC_BITS1: &[u8] = &[ 1, 3, 4, 4, 5, 7, 5, 6, 7, 8, 8, 7, 3, 6 ];
2142 const BINK2_AC_CODES2: &[u16] = &[
2143 0x01, 0x00, 0x04, 0x2C, 0x6C, 0x0C, 0x4C, 0xAC,
2144 0xEC, 0x12C, 0x16C, 0x1AC, 0x02, 0x1C
2146 const BINK2_AC_BITS2: &[u8] = &[ 1, 3, 4, 9, 9, 7, 7, 9, 8, 9, 9, 9, 2, 5 ];
2148 const BINK2_AC_RUNS: [usize; 14] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 64, 0 ];
2150 const BINK2_MV_CODES: &[u8] = &[
2151 0x01, 0x06, 0x0C, 0x1C, 0x18, 0x38, 0x58, 0x78,
2152 0x68, 0x48, 0x28, 0x08, 0x14, 0x04, 0x02, 0x00
2154 const BINK2_MV_BITS: &[u8] = &[
2155 1, 3, 5, 5, 7, 7, 7, 7,
2156 7, 7, 7, 7, 5, 5, 3, 4
2158 const BINK2_MV_ESC: i8 = 42;
2159 const BINK2_MV_SYMS: &[i8] = &[
2160 0, 1, 2, 3, 4, 5, 6, 7,
2161 -7, -6, -5, -4, -3, -2, -1, BINK2_MV_ESC
2164 const BINK2_AC_VAL_CODES1: &[u16] = &[
2165 0x004, 0x01, 0x002, 0x00, 0x08, 0x18, 0xF8, 0x178,
2166 0x138, 0x38, 0x1B8, 0x78, 0xB8
2168 const BINK2_AC_VAL_BITS1: &[u8] = &[ 3, 1, 2, 4, 5, 6, 8, 9, 9, 9, 9, 9, 9 ];
2169 const BINK2_AC_VAL_CODES2: &[u16] = &[
2170 0x0A, 0x001, 0x004, 0x08, 0x06, 0x00, 0x02, 0x1A,
2171 0x2A, 0x16A, 0x1EA, 0x6A, 0xEA
2173 const BINK2_AC_VAL_BITS2: &[u8] = &[ 6, 1, 3, 4, 3, 4, 4, 5, 7, 9, 9, 9, 9 ];
2174 const BINK2_AC_SKIP_CODES1: &[u16] = &[
2175 0x00, 0x001, 0x0D, 0x15, 0x45, 0x85, 0xA5, 0x165,
2176 0x65, 0x1E5, 0xE5, 0x25, 0x03, 0x05
2178 const BINK2_AC_SKIP_BITS1: &[u8] = &[ 1, 3, 4, 5, 7, 8, 8, 9, 9, 9, 9, 8, 2, 8 ];
2179 const BINK2_AC_SKIP_CODES2: &[u16] = &[
2180 0x00, 0x01, 0x003, 0x07, 0x1F, 0x1B, 0x0F, 0x2F,
2181 0x5B, 0xDB, 0x1DB, 0x3B, 0x05, 0x0B
2183 const BINK2_AC_SKIP_BITS2: &[u8] = &[ 1, 3, 4, 4, 5, 7, 6, 6, 8, 9, 9, 6, 3, 5 ];
2184 const BINK2_QUANT_CODES: &[u8] = &[
2185 0x01, 0x02, 0x04, 0x08, 0x10, 0x30, 0x50, 0x70,
2186 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
2188 const BINK2_QUANT_BITS: &[u8] = &[ 1, 2, 3, 4, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8 ];
2190 const BINK2_OLD_QUANTS: [f32; 16] = [
2191 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
2193 const BINK2_OLD_DC_QUANTS: [i32; 16] = [
2194 4, 4, 4, 4, 4, 6, 7, 8, 10, 12, 16, 24, 32, 48, 64, 128
2196 const BINK2_DC_EXTRA_BITS: [u8; 16] = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 6 ];
2197 const BINK2_QMAT_INTRA_LUMA_OLD: &[f32; 64] = &[
2198 0.125, 0.208056, 0.22864901, 0.205778, 0.22499999, 0.235708, 0.33148301, 0.248309,
2199 0.190718, 0.288582, 0.29449099, 0.34658501, 0.38143599, 0.47678301, 0.600528, 0.44008601,
2200 0.16332, 0.31714499, 0.34142101, 0.42249799, 0.604285, 0.70576, 0.68942899, 0.42807001,
2201 0.235175, 0.38735899, 0.46090701, 0.50122303, 0.82311302, 0.73910397, 0.69206202, 0.39741901,
2202 0.30000001, 0.45078799, 0.65328097, 0.74962097, 0.85000002, 0.79551601, 0.69678998, 0.38625899,
2203 0.392847, 0.79009801, 0.73142397, 1.004719, 1.070509, 0.80251199, 0.64313799, 0.27096599,
2204 0.34501299, 0.56299502, 0.60987997, 0.636379, 0.69678998, 0.60061598, 0.43934, 0.19224399,
2205 0.210373, 0.26309499, 0.252336, 0.25142801, 0.265553, 0.24928901, 0.188511, 0.094199002
2207 const BINK2_QMAT_CHROMA_OLD: &[f32; 64] = &[
2208 0.125, 0.17338, 0.217761, 0.383793, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2209 0.17338, 0.28056601, 0.32721299, 0.74753499, 0.95358998, 0.74923098, 0.51607901, 0.26309499,
2210 0.217761, 0.32721299, 0.66387498, 1.056244, 0.89826202, 0.70576, 0.48613599, 0.24783,
2211 0.383793, 0.74753499, 1.056244, 0.95059502, 0.80841398, 0.635167, 0.437511, 0.223041,
2212 0.6875, 0.95358998, 0.89826202, 0.80841398, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2213 0.54016501, 0.74923098, 0.70576, 0.635167, 0.54016501, 0.42440501, 0.292335, 0.149031,
2214 0.37207201, 0.51607901, 0.48613599, 0.437511, 0.37207201, 0.292335, 0.201364, 0.102655,
2215 0.18968099, 0.26309499, 0.24783, 0.223041, 0.18968099, 0.149031, 0.102655, 0.052333001
2217 const BINK2_QMAT_INTER_LUMA_OLD: &[f32; 64] = &[
2218 0.125, 0.17338, 0.16332, 0.146984, 0.128475, 0.106393, 0.077045999, 0.043109,
2219 0.17338, 0.240485, 0.226532, 0.20387299, 0.17820001, 0.147571, 0.109474, 0.062454,
2220 0.16332, 0.226532, 0.219321, 0.202722, 0.181465, 0.149711, 0.112943, 0.062583998,
2221 0.146984, 0.20387299, 0.202722, 0.201647, 0.183731, 0.15397599, 0.11711, 0.065334998,
2222 0.128475, 0.17820001, 0.181465, 0.183731, 0.17708801, 0.155499, 0.120267, 0.068016,
2223 0.106393, 0.147571, 0.149711, 0.15397599, 0.155499, 0.14575601, 0.116636, 0.068494998,
2224 0.077045999, 0.109474, 0.112943, 0.11711, 0.120267, 0.116636, 0.098646, 0.060141001,
2225 0.043109, 0.062454, 0.062583998, 0.065334998, 0.068016, 0.068494998, 0.060141001, 0.038853001