projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
make all codec crates export just register_all functions and document them
[nihav.git] / nihav-rad / src / codecs / bink2.rs
CommitLineData
232deab9 1use std::mem;
606c448e 2use nihav_core::codecs::*;
232deab9
KS		 3use nihav_core::io::byteio::*;
4use nihav_core::io::bitreader::*;
5use nihav_core::io::codebook::*;
6use nihav_core::io::intcode::*;
7
9dce67e3
KS		 8macro_rules! mktag {
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)
11 });
12 ($arr:expr) => ({
13 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
14 });
15}
16
232deab9
KS		 17macro_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);
23}
24
25macro_rules! idct {
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;
44
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;
53 };
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];
c2a4fa57 56 let t01 = ($src[$off + $sstep * 2] - $src[$off + $sstep * 6]) * std::f32::consts::SQRT_2 - t00;
232deab9
KS		 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];
63 let t08 = t02 + t00;
64 let t09 = t02 - t00;
65 let t10 = t03 + t01;
66 let t11 = t03 - t01;
67 let t12 = t06 + t04;
c2a4fa57 68 let t13 = (t06 - t04) * std::f32::consts::SQRT_2;
232deab9
KS		 69 let t14 = (t07 - t05) * 1.847759;
70 let t15 = t05 * 2.613126 + t14 - t12;
71 let t16 = t13 - t15;
72 let t17 = t07 * 1.0823922 - t14 + t16;
73
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;
82 };
83}
84
c2a4fa57 85#[allow(clippy::erasing_op)]
232deab9
KS		 86fn bink2_idct(coeffs: &mut [i32; 64]) {
87 let mut tmp: [i32; 64] = [0; 64];
88 for i in 0..8 {
89 idct!(coeffs, 1, 8 * i, tmp, 8, i, 0, 0);
90 }
91 for i in 0..8 {
92 idct!(tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
93 }
94}
95
c2a4fa57 96#[allow(clippy::erasing_op)]
232deab9
KS		 97fn bink2_idct_old(coeffs: &mut [f32; 64]) {
98 let mut tmp: [f32; 64] = [0.0; 64];
3654ecf2 99 coeffs[0] += 512.5;
232deab9
KS		 100 for i in 0..8 {
101 idct!(float; coeffs, 8, i, tmp, 8, i, 0, 0);
102 }
103 for i in 0..8 {
104 idct!(float; tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
105 }
106}
107
108struct Bink2DSP { }
109
110fn clip8(val: i32) -> u8 {
111 val.min(255).max(0) as u8
112}
113
114macro_rules! el {
115 ($src: expr, $off: expr) => (
116 $src[$off] as i32
117 );
118}
119
120macro_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);
d1886673 125 (((t0 * 19) >> 1) - t1 * 2 + (t2 >> 1) + 8) >> 4
232deab9
KS		 126 });
127}
128
129macro_rules! chroma_interp {
130 ($dst: expr, $dstride: expr, $h: expr, $ty: tt, $src: expr, $sstride: expr, $step: expr, $mode: expr, $shift: expr) => {
131 let mut soff = 0;
132 for out in $dst.chunks_mut($dstride).take($h) {
133 for i in 0..8 {
134 let e0 = el!($src, soff + i);
135 let e1 = el!($src, soff + i + $step);
136 out[i] = match $mode {
137 0 => e0,
138 1 => (e0 * 3 + e1 + $shift) >> $shift,
139 2 => (e0 * 2 + e1 * 2 + $shift) >> $shift,
140 _ => (e0 + e1 * 3 + $shift) >> $shift,
141 } as $ty;
142 }
143 soff += $sstride;
144 }
145 };
146}
147
5de1b118
KS		 148macro_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)));
151}
152
c2a4fa57 153#[allow(clippy::erasing_op)]
232deab9
KS		 154impl Bink2DSP {
155 fn calc_dc(src: &[u8], stride: usize) -> i32 {
5de1b118
KS		 156 let mut sums = [0u16; 8];
157 for i in 0..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));
167 }
232deab9 168 let mut sum = 0;
5de1b118
KS		 169 for e in sums.iter() {
170 sum += e;
232deab9 171 }
5de1b118 172 sum as i32
232deab9
KS		 173 }
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]);
179 {
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]); }
184 }
185 }
186 off += stride * 8;
187 {
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]); }
192 }
193 }
194 }
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]);
200 {
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]); }
205 }
206 }
207 off += stride * 8;
208 {
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]); }
213 }
214 }
215 }
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]);
221 {
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))) {
3654ecf2
KS		 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); }
232deab9
KS		 226 }
227 }
228 off += stride * 8;
229 {
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))) {
3654ecf2
KS		 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); }
232deab9
KS		 234 }
235 }
236 }
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]);
242 {
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))) {
3654ecf2
KS		 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); }
232deab9
KS		 247 }
248 }
249 off += stride * 8;
250 {
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))) {
3654ecf2
KS		 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); }
232deab9
KS		 255 }
256 }
257 }
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) };
264
265 let (w, h) = ref_pic.get_dimensions(plane);
d1886673
KS		 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));
232deab9
KS		 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();
274
275 let dst = &mut dst[xoff + (yoff & 31) * stride..];
276
277 match mode {
278 0 => {
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]; }
282 }
283 },
284 1 => {
285 for out in dst.chunks_mut(stride).take(16) {
286 for i in 0..16 {
d1886673 287 out[i] = clip8(luma_filter!(ppix, poff + i, 1));
232deab9
KS		 288 }
289 poff += pstride;
290 }
291 },
292 2 => {
293 for out in dst.chunks_mut(stride).take(16) {
294 for i in 0..16 {
d1886673 295 out[i] = clip8(luma_filter!(ppix, poff + i, pstride));
232deab9
KS		 296 }
297 poff += pstride;
298 }
299 },
300 3 => {
d1886673 301 let mut tmp = [0i16; 21 * 16];
232deab9
KS		 302 for out in tmp.chunks_mut(16) {
303 for i in 0..16 {
d1886673 304 out[i] = luma_filter!(ppix, poff - 2 * pstride + i, 1) as i16;
232deab9
KS		 305 }
306 poff += pstride;
307 }
308 for (row, out) in dst.chunks_mut(stride).take(16).enumerate() {
309 for i in 0..16 {
d1886673 310 out[i] = clip8(luma_filter!(tmp, (row + 2) * 16 + i, 16));
232deab9
KS		 311 }
312 }
313 },
314 _ => unreachable!(),
315 };
316 Ok(())
317 }
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);
321 let mx = mv.x & 3;
322 let my = mv.y & 3;
323 let add_x = if mx != 0 { 1 } else { 0 };
324 let add_y = if my != 0 { 1 } else { 0 };
325
326 let (w, h) = ref_pic.get_dimensions(plane);
d1886673
KS		 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));
232deab9
KS		 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();
335
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]; }
341 }
342 } else if my == 0 {
343 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, 1, mx, 2);
344 } else if mx == 0 {
345 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, pstride, my, 2);
346 } else {
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);
350 }
351 Ok(())
352 }
353}
354
355fn mid_pred<T:PartialOrd>(a: T, b: T, c: T) -> T {
356 if a < b {
357 if b < c {
358 b
359 } else {
360 if a < c { c } else { a }
361 }
362 } else {
363 if b < c {
364 if a < c { a } else { c }
365 } else {
366 b
367 }
368 }
369}
370
371#[derive(Default)]
372struct QuantInfo {
373 quants: Vec<u8>,
374 qstride: usize,
375 qpos: usize,
376 pqpos: usize,
377}
378
379impl QuantInfo {
380 fn resize(&mut self, bw: usize) {
381 self.qstride = bw * 2;
382 self.quants.resize(self.qstride * 2, 0);
383 self.qpos = 0;
384 self.pqpos = self.qstride;
385 }
386 fn update_line(&mut self) {
387 mem::swap(&mut self.qpos, &mut self.pqpos);
388 }
389 fn pred_quant(&self, pos: usize, is_top: bool) -> u8 {
390 let is_left = pos < 2;
391 if is_top {
392 if is_left { 16 } else { self.quants[self.qpos + pos - 2] }
393 } else {
394 if is_left {
395 self.quants[self.pqpos + pos]
396 } else {
397 mid_pred(self.quants[self.pqpos + pos - 2],
398 self.quants[self.pqpos + pos],
399 self.quants[self.qpos + pos - 2])
400 }
401 }
402 }
403 fn set_quant(&mut self, pos: usize, q: u8) {
404 self.quants[self.qpos + pos] = q;
405 }
406}
407
408#[derive(Default)]
409struct YDCInfo {
410 dcs: [i32; 16],
411 dc_buf: [i32; 16],
412 prev_dcs: Vec<i32>,
413 new_dcs: Vec<i32>,
414 stride: usize,
415 prev_off: usize,
416}
417
418impl YDCInfo {
419 fn resize(&mut self, bw: usize) {
420 self.stride = bw * 4 + 4;
421 self.prev_off = 4;
422 self.prev_dcs.resize(self.stride, 0);
423 self.new_dcs.resize(self.stride, 0);
424 }
425 fn update_line(&mut self) {
426 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
427 }
428 fn set_dcs(&mut self, bx: usize, dc5: i32, dc7: i32, dc13: i32, dc10: i32, dc11: i32, dc14: i32, dc15: i32) {
429 self.dcs[ 5] = dc5;
430 self.dcs[ 7] = dc7;
431 self.dcs[13] = dc13;
432 self.dcs[15] = dc15;
433 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
434 new_dc[0] = dc10;
435 new_dc[1] = dc11;
436 new_dc[2] = dc14;
437 new_dc[3] = dc15;
438 }
439}
440
441#[derive(Default)]
442struct CDCInfo {
443 dcs: [i32; 4],
444 dc_buf: [i32; 4],
445 prev_dcs: Vec<i32>,
446 new_dcs: Vec<i32>,
447 stride: usize,
448 prev_off: usize,
449}
450
451impl CDCInfo {
452 fn resize(&mut self, bw: usize) {
453 self.stride = bw * 2 + 2;
454 self.prev_off = 2;
455 self.prev_dcs.resize(self.stride, 0);
456 self.new_dcs.resize(self.stride, 0);
457 }
458 fn update_line(&mut self) {
459 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
460 }
461 fn set_dcs(&mut self, bx: usize, dc1: i32, dc2: i32, dc3: i32) {
462 self.dcs[1] = dc1;
463 self.dcs[2] = dc2;
464 self.dcs[3] = dc3;
465 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
466 new_dc[0] = dc2;
467 new_dc[1] = dc3;
468 }
469}
470
471trait DCInfo {
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);
475}
476
477fn dc_pred2(a: i32, b: i32) -> i32 {
478 (a.max(b)).min(a.min(b).max(a * 2 - b))
479}
480fn 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))
482}
483
484impl 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)
487 }
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;
495 if is_left {
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);
502
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);
507
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);
512
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);
517 } else {
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);
522
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);
527
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);
532
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);
537 }
538 } else {
539 if is_top {
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);
544
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);
549
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);
554
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);
559 } else {
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);
564
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);
569
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);
574
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);
579 }
580 }
581 dst[ 0] = a0;
582 dst[ 1] = a1;
583 dst[ 2] = a2;
584 dst[ 3] = a3;
585 dst[ 4] = a4;
586 dst[ 5] = a5;
587 dst[ 6] = a6;
588 dst[ 7] = a7;
589 dst[ 8] = a8;
590 dst[ 9] = a9;
591 dst[10] = aA;
592 dst[11] = aB;
593 dst[12] = aC;
594 dst[13] = aD;
595 dst[14] = aE;
596 dst[15] = aF;
597 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
598 new_dc[0] = aA;
599 new_dc[1] = aB;
600 new_dc[2] = aE;
601 new_dc[3] = aF;
602 }
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);
613
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);
618
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);
623
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);
628
629 dst[ 0] = a0;
630 dst[ 1] = a1;
631 dst[ 2] = a2;
632 dst[ 3] = a3;
633 dst[ 4] = a4;
634 dst[ 5] = a5;
635 dst[ 6] = a6;
636 dst[ 7] = a7;
637 dst[ 8] = a8;
638 dst[ 9] = a9;
639 dst[10] = aA;
640 dst[11] = aB;
641 dst[12] = aC;
642 dst[13] = aD;
643 dst[14] = aE;
644 dst[15] = aF;
645 }
646}
647
648impl 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)
651 }
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;
656
657 let a0; let a1; let a2; let a3;
658 if is_left {
659 if is_top {
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);
663 } else {
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);
666 }
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);
669 } else {
670 if is_top {
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);
673 } else {
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);
676 }
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);
679 }
680 dst[0] = a0;
681 dst[1] = a1;
682 dst[2] = a2;
683 dst[3] = a3;
684 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
685 new_dc[0] = a2;
686 new_dc[1] = a3;
687 }
688 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
689 let dst = &mut self.dcs;
690 let dcs = &self.dc_buf;
691
692 let a0; let a1; let a2; let a3;
693
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);
698
699 dst[0] = a0;
700 dst[1] = a1;
701 dst[2] = a2;
702 dst[3] = a3;
703 }
704}
705
706fn decode_dcs(br: &mut BitReader, dcs: &mut [i32], q: u8) -> DecoderResult<bool> {
707 if !br.read_bool()? {
708 for dc in dcs.iter_mut() {
709 *dc = 0;
710 }
711 Ok(false)
712 } else {
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()?;
716 if *dc != 0 {
717 *dc = (*dc * quant + 0x1FF) >> 10;
718 if br.read_bool()? {
719 *dc = -*dc;
720 }
721 }
722 }
723 Ok(true)
724 }
725}
726#[derive(Default)]
727struct MVInfo {
728 mvs: Vec<MV>,
729 stride: usize,
730 mv_off: usize,
731 prev_off: usize,
732}
733
734impl MVInfo {
735 fn resize(&mut self, bw: usize) {
736 self.stride = bw * 4;
737 self.mv_off = 0;
738 self.prev_off = self.stride;
739 self.mvs.resize(self.stride * 2, ZERO_MV);
740 }
741 fn update_line(&mut self) {
742 mem::swap(&mut self.mv_off, &mut self.prev_off);
743 }
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;
749
750 for comp in 0..2 {
751 for i in 0..num_mv {
752 let val;
753 let raw_val = br.read_cb(mv_cb)?;
754 if raw_val != BINK2_MV_ESC {
755 val = raw_val as i16;
756 } else {
757 let len = br.read_code(UintCodeType::LimitedUnary(12, 1))? as u8;
758 let nlen = len + 4;
759 let uval = (br.read(nlen)? as i32) + (1 << nlen) - 1;
760 if (uval & 1) != 0 {
761 val = (-(uval >> 1) - 1) as i16;
762 } else {
763 val = (uval >> 1) as i16;
764 }
765 }
766 if comp == 0 {
767 mv[mv_pos + i].x = val;
768 } else {
769 mv[mv_pos + i].y = val;
770 }
771 }
772 }
773
774 if num_mv > 1 {
775 if is_top {
776 if !is_left {
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;
785 } else {
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;
792 }
793 } else {
794 if is_left {
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;
803 } else {
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;
812 }
813 }
814 } else {
815 let mut mv_pred = mv[mv_pos + 0];
816 if is_top {
817 if !is_left {
818 mv_pred += MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
819 }
820 } else {
821 if !is_left {
822 mv_pred += MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
823 } else {
824 mv_pred += MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
825 }
826 }
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;
831 }
832 Ok(())
833 }
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;
838
839 let mut basex = 0;
840 let mut basey = 0;
841 for comp in 0..2 {
842 let mut bits = br.read(3)? as u8;
843 if bits == 7 {
844 bits += br.read(2)? as u8;
845 }
846 let mut mv_c: [i16; 4] = [0; 4];
847 if bits > 0 {
848 for i in 0..4 {
849 mv_c[i] = br.read(bits)? as i16;
850 }
851 for i in 0..4 {
852 if (mv_c[i] != 0) && br.read_bool()? {
853 mv_c[i] = -mv_c[i];
854 }
855 }
856 }
857 if is_top && is_left {
858 let mut val = br.read(5)? as i16;
859 if (val != 0) && br.read_bool()? {
860 val = -val;
861 }
862 if comp == 0 {
863 basex = val;
864 } else {
865 basey = val;
866 }
867 }
868 if comp == 0 {
869 for i in 0..4 {
870 mv[mv_pos + i].x = mv_c[i];
871 }
872 } else {
873 for i in 0..4 {
874 mv[mv_pos + i].y = mv_c[i];
875 }
876 }
877 }
878 if !is_top {
879 if is_left {
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;
888 } else {
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;
897 }
898 } else {
899 if is_left {
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;
905 } else {
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;
914 }
915 }
916 Ok(())
917 }
918
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;
923
924 if is_top {
925 if is_left {
926 for i in 0..4 {
927 mv[mv_pos + i] = ZERO_MV;
928 }
929 } else {
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]);
934 }
935 } else {
936 if is_left {
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]);
941 } else {
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]);
944 if is_new {
945 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
946 } else {
947 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
948 }
949 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
950 }
951 }
952 }
953
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;
961 }
962}
963
964struct Bink2Codes {
965 ac_cb1: Codebook<u8>,
966 ac_cb2: Codebook<u8>,
967 mv_cb: Codebook<i8>,
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>,
973}
974
975fn map_ac(idx: usize) -> u8 { idx as u8 }
d24468d9 976fn map_mv(idx: usize) -> i8 { BINK2_MV_SYMS[idx] }
232deab9
KS		 977
978impl 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 }
997 }
998}
999
1000#[derive(Default)]
1001struct Bink2Decoder {
2422d969 1002 info: NACodecInfoRef,
232deab9
KS		 1003 ips: IPShuffler,
1004
1005 version: u32,
9dce67e3
KS		 1006 has_alpha: bool,
1007 slice_h: [usize; 8],
1008 num_slices: usize,
1009
232deab9
KS		 1010 key_frame: bool,
1011 cur_w: usize,
1012 cur_h: usize,
1013 qinfo: QuantInfo,
1014 y_dcs: YDCInfo,
1015 u_dcs: CDCInfo,
1016 v_dcs: CDCInfo,
9dce67e3 1017 a_dcs: YDCInfo,
232deab9
KS		 1018 mvs: MVInfo,
1019
1020 codes: Bink2Codes,
1021}
1022
c2a4fa57 1023#[allow(clippy::erasing_op)]
232deab9
KS		 1024impl Bink2Decoder {
1025 fn new() -> Self {
1026 Self::default()
1027 }
1028
1029 fn decode_frame_new(&mut self, br: &mut BitReader, buf: &mut NAVideoBuffer<u8>, is_intra: bool) -> DecoderResult<()> {
9dce67e3
KS		 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);
232deab9 1033 let (width, height) = buf.get_dimensions(0);
1a967e6b 1034 let data = buf.get_data_mut().unwrap();
232deab9
KS		 1035 let dst = data.as_mut_slice();
1036 let bw = (width + 31) >> 5;
d1886673 1037 let bheight = (height + 31) >> 5;
232deab9
KS		 1038 self.cur_w = (width + 7) & !7;
1039 self.cur_h = ((height + 7) & !7) >> 1;
1040
1041 let frame_flags = br.read(32)?;
9dce67e3
KS		 1042 let mut offsets: [u32; 7] = [0; 7];
1043 for i in 0..self.num_slices-1 {
1044 offsets[i] = br.read(32)?;
1045 }
1046 let mut do_alpha = self.has_alpha;
1047 if (frame_flags & 0x80000) != 0 && self.has_alpha {
1048 do_alpha = false;
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() {
1052 *el = fillval;
1053 }
232deab9 1054 }
e2392676
KS		 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 {
9dce67e3
KS		 1059 let len = (height + 15) >> 4;
1060 decode_flags(br, &mut row_flags, 1, len * 2 - 1)?;
e2392676
KS		 1061 }
1062 if (frame_flags & 0x4000) == 0 {
9dce67e3
KS		 1063 let len = (width + 15) >> 4;
1064 decode_flags(br, &mut col_flags, 1, len * 2 - 1)?;
e2392676 1065 }
e2392676 1066 }
9dce67e3
KS		 1067 row_flags.resize(bheight * 4, false);
1068 col_flags.resize(bw * 4, false);
e2392676
KS		 1069 //store frame_flags * 8 & 0x7F8
1070
9dce67e3
KS		 1071 let mut start_by = 0;
1072 for slice_no in 0..self.num_slices {
1073 let end_by = self.slice_h[slice_no];
1074 if slice_no != 0 {
1075 br.seek(offsets[slice_no - 1] * 8)?;
232deab9 1076 }
9dce67e3
KS		 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;
232deab9
KS		 1081
1082 let mut row_state = frame_flags & 0x2E000;
1083 if is_intra {
1084 row_state |= 0x10000;
1085 }
1086 self.qinfo.resize(bw);
1087 self.y_dcs.resize(bw);
1088 self.u_dcs.resize(bw);
1089 self.v_dcs.resize(bw);
9dce67e3 1090 self.a_dcs.resize(bw);
232deab9 1091 self.mvs.resize(bw);
9dce67e3 1092 for by in start_by..end_by {
232deab9
KS		 1093 let mut cbp_y = 0;
1094 let mut cbp_u = 0;
1095 let mut cbp_v = 0;
9dce67e3 1096 let mut cbp_a = 0;
232deab9
KS		 1097 let mut cbp_y_p = 0;
1098 let mut cbp_u_p = 0;
1099 let mut cbp_v_p = 0;
9dce67e3 1100 let mut cbp_a_p = 0;
232deab9
KS		 1101 let mut q_y = 8;
1102 let mut q_u = 8;
1103 let mut q_v = 8;
9dce67e3 1104 let mut q_a = 8;
232deab9
KS		 1105 let mut q_y_p = 8;
1106 let mut q_u_p = 8;
1107 let mut q_v_p = 8;
9dce67e3
KS		 1108 let mut q_a_p = 8;
1109 let rflags = (row_flags[by] as u32) * 4;
232deab9 1110 row_state = (row_state & 0x3FFFFFF) | ((row_state >> 4) & 0xC000000) | (rflags << 28);
9dce67e3 1111 if by == start_by {
232deab9
KS		 1112 row_state |= 0x80;
1113// } else {
1114// row_state |= 0x8;
1115 }
9dce67e3 1116 if by + 2 >= end_by {
232deab9
KS		 1117 row_state |= 0x100;
1118 }
1119
1120 let mut btype_lru: [u8; 4] = [ 2, 3, 1, 0 ];
1121 let mut edge_state = 0;
9dce67e3 1122 let is_top = by == start_by;
232deab9
KS		 1123 for bx in 0..bw {
1124 let mut blk_state = row_state | (edge_state & 0x3FC0000);
1125 if bx == 0 {
1126 blk_state |= 0x20;
1127 }
1128 if bx + 2 < bw {
1129 blk_state |= 0x40;
1130 }
1131 if (bx & 1) != 0 {
1132 blk_state |= 0x200;
1133 }
e2392676 1134 let clflags = (col_flags[bx] as u32) * 4;
232deab9
KS		 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;
1138
1139 //let is_top = (edge_state & 0x88) != 0;
1140 let is_left = bx == 0; //(edge_state & 0x20) != 0;
1141
1142 let btype;
1143 if is_intra {
1144 btype = 0;
1145 } else {
1146 if (blk_state & 0x2000) != 0 {
1147 let val = br.read_code(UintCodeType::LimitedUnary(3, 1))?;
1148 match val {
1149 0 => {
1150 btype = btype_lru[0];
1151 },
1152 1 => {
1153 btype = btype_lru[1];
1154 btype_lru[1] = btype_lru[0];
1155 btype_lru[0] = btype;
1156 },
1157 2 => {
1158 btype = btype_lru[3];
1159 btype_lru[3] = btype_lru[2];
1160 btype_lru[2] = btype;
1161 },
1162 3 => {
1163 btype = btype_lru[2];
1164 btype_lru[2] = btype_lru[1];
1165 btype_lru[1] = btype;
1166 },
1167 _ => unreachable!(),
1168 };
1169 } else {
1170 btype = br.read(2)? as u8;
1171 }
1172 }
1173 if !is_intra {
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);
1178 }
1179 match btype {
1180 0 => { // intra
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)?;
9dce67e3
KS		 1190 if do_alpha {
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]);
1197 }
232deab9
KS		 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);
1205 } else {
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)?;
9dce67e3
KS		 1212 if do_alpha {
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]);
1219 }
232deab9
KS		 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);
1226 }
1227 if !is_intra {
1228 self.mvs.predict_mvs(bx, is_top, is_left, (frame_flags & 0x2000) != 0);
1229 }
1230 },
1231 1 => { // skip
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;
9dce67e3 1235 let yoff = by * 32 + (blk_no & 2) * 8;
232deab9
KS		 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)?;
9dce67e3
KS		 1239 if do_alpha {
1240 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, ZERO_MV, 3)?;
1241 }
232deab9
KS		 1242 }
1243 } else {
1244 return Err(DecoderError::MissingReference);
1245 }
1246 self.mvs.zero(bx);
1247 },
1248 2 => { // motion
1249 if (frame_flags & 0x2000) != 0 {
1250 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1251 } else {
1252 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1253 }
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;
9dce67e3 1257 let yoff = by * 32 + (blk_no & 2) * 8;
232deab9
KS		 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)?;
9dce67e3
KS		 1262 if do_alpha {
1263 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, mv, 3)?;
1264 }
232deab9
KS		 1265 }
1266 } else {
1267 return Err(DecoderError::MissingReference);
1268 }
1269 },
1270 3 => { // inter
1271 if (frame_flags & 0x2000) != 0 {
1272 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1273 } else {
1274 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1275 }
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;
9dce67e3 1279 let yoff = by * 32 + (blk_no & 2) * 8;
232deab9
KS		 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)?;
9dce67e3
KS		 1284 if do_alpha {
1285 Bink2DSP::mc_luma(&mut dst[off_a..], stride_a, ref_pic, xoff, yoff, mv, 3)?;
1286 }
232deab9
KS		 1287 }
1288 } else {
1289 return Err(DecoderError::MissingReference);
1290 }
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)?;
1301 } else {
1302 cbp_v_p = 0;
1303 cbp_u_p = 0;
1304 }
9dce67e3
KS		 1305 if do_alpha {
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]);
1312 }
232deab9
KS		 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);
1319 } else {
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)?;
9dce67e3
KS		 1326 if do_alpha {
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]);
1333 }
232deab9
KS		 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);
1340 }
1341 },
1342 _ => unreachable!(),
1343 };
1344 if btype != 0 {
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);
9dce67e3
KS		 1364 if do_alpha {
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);
1374 }
232deab9
KS		 1375 }
1376 }
1377 self.qinfo.update_line();
1378 self.y_dcs.update_line();
1379 self.u_dcs.update_line();
1380 self.v_dcs.update_line();
9dce67e3 1381 self.a_dcs.update_line();
232deab9
KS		 1382 self.mvs.update_line();
1383 off_y += stride_y * 32;
1384 off_u += stride_u * 16;
1385 off_v += stride_v * 16;
9dce67e3 1386 off_a += stride_a * 32;
232deab9
KS		 1387 row_state = (row_state & !0x190) | ((row_state & 4) << 2);
1388 }
9dce67e3 1389 start_by = self.slice_h[slice_no];
232deab9
KS		 1390 }
1391 Ok(())
1392 }
1393}
1394
e2392676
KS		 1395fn decode_flags(br: &mut BitReader, dst: &mut Vec<bool>, start: usize, nbits: usize) -> DecoderResult<()> {
1396 if start > 0 {
1397 dst.push(false);
1398 }
1399 if !br.read_bool()? {
1400 for _ in 0..nbits {
1401 let bit = br.read_bool()?;
1402 dst.push(bit);
232deab9 1403 }
232deab9
KS		 1404 } else {
1405 let mut cur_bits = nbits;
1406 let mut mode = 0;
e2392676 1407 let mut lastbit = false;
232deab9
KS		 1408 while cur_bits > 0 {
1409 if !br.read_bool()? {
e2392676
KS		 1410 lastbit = if mode == 3 { !lastbit } else { br.read_bool()? };
1411 dst.push(lastbit);
1412 cur_bits -= 1;
1413 let len = cur_bits.min(4);
1414 for _ in 0..len {
1415 let bit = br.read_bool()?;
1416 dst.push(bit);
232deab9 1417 }
e2392676
KS		 1418 cur_bits -= len;
1419 mode = 2;
232deab9 1420 } else {
e2392676 1421 let bread: u8;
232deab9
KS		 1422 if cur_bits < 4 {
1423 bread = 2;
1424 } else if cur_bits < 16 {
1425 bread = 4;
1426 } else {
1427 bread = 4 | 1;
1428 }
e2392676
KS		 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 {
232deab9
KS		 1432 let add_run = br.read(bread)? as usize;
1433 run += add_run;
e2392676
KS		 1434 mode = if add_run == (1 << bread) - 1 { 1 } else { 3 };
1435 }
1436 for _ in 0..run {
1437 dst.push(lastbit);
232deab9 1438 }
e2392676 1439 cur_bits -= run;
232deab9
KS		 1440 }
1441 }
1442 }
e2392676 1443 Ok(())
232deab9
KS		 1444}
1445
1446fn get_new_quant(br: &mut BitReader, prev_q: u8) -> DecoderResult<u8> {
1447 let mut code = br.read_code(UintCodeType::LimitedUnary(4, 1))? as u8;
1448 if code == 0 {
1449 Ok(prev_q)
1450 } else {
1451 if code == 3 {
1452 code += br.read(1)? as u8;
1453 } else if code == 4 {
1454 code = (br.read(5)? as u8) + 5;
1455 }
1456 let ret;
1457 if !br.read_bool()? {
1458 ret = prev_q.checked_add(code);
1459 } else {
1460 ret = prev_q.checked_sub(code);
1461 }
1462 validate!(ret.is_some());
1463 let val = ret.unwrap();
1464 validate!(val < (BINK2_QUANT_DC.len() as u8));
1465 Ok(val)
1466 }
1467}
1468
1469fn 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;
1474 for i in 0..4 {
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; }
1477 }
1478 Ok(cbp)
1479}
1480
1481fn 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; }
1488 Ok(cbp)
1489}
1490
1491fn 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;
1497 for i in 0..4 {
1498 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTER, q, cbp >> (i * 4))?;
3c38de0f 1499 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j] * 8; }
232deab9
KS		 1500 }
1501 Ok(cbp)
1502}
1503
1504fn 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)?;
3c38de0f 1511 for i in 0..4 { dst[i][0] = dcs[i] * 8; }
232deab9
KS		 1512 Ok(cbp)
1513}
1514
1515fn 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) };
1518
1519 let mut cbp;
1520 if br.read_bool()? {
1521 cbp = 0;
1522 } else if min_count >= 4 {
1523 cbp = br.read(16)?;
1524 } else {
1525 cbp = 0;
1526 for i in 0..4 {
1527 if !br.read_bool()? {
1528 let cbp4 = br.read(4)?;
1529 cbp |= cbp4 << (i * 4);
1530 }
1531 }
1532 }
1533 cbp ^= mask;
1534 if ((edge_state & 0x40000) == 0) || (cbp != 0) {
1535 if br.read_bool()? {
1536 cbp |= cbp << 16;
1537 }
1538 }
1539 Ok(cbp)
1540}
1541fn 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])
1544 } else {
1545 let ncbp = br.read(4)?;
1546 if br.read_bool()? {
1547 Ok(ncbp | (ncbp << 16))
1548 } else {
1549 Ok(ncbp)
1550 }
1551 }
1552}
1553
1554trait ReadBink2Code {
1555 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32>;
1556 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32>;
1557}
1558
1559impl<'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;
1562 if pfx > 0 {
1563 let val: i32;
1564 if pfx >= 4 {
1565 let add_bits = self.read((pfx as u8) - 3)? as i32;
1566 val = (1 << (pfx - 3)) + add_bits + 2;
1567 } else {
1568 val = pfx;
1569 }
1570 Ok(val)
1571 } else {
1572 Ok(0)
1573 }
1574 }
1575 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32> {
1576 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? + 1;
1577 let val: i32;
1578 if pfx >= 4 {
1579 let add_bits = self.read((pfx as u8) - 3)? as i32;
1580 val = (1 << (pfx - 3)) + add_bits + 2;
1581 } else {
1582 val = pfx as i32;
1583 }
1584 if self.read_bool()? {
1585 Ok(-val)
1586 } else {
1587 Ok(val)
1588 }
1589 }
1590}
1591
1592fn 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];
1595 let shift = q >> 2;
1596 for blk_no in 0..4 {
1597 if ((cbp >> blk_no) & 1) == 0 { continue; }
1598 let mut esc_len = 0;
1599 let mut idx = 1;
1600 while idx < 64 {
1601 if esc_len >= 1 {
1602 esc_len -= 1;
1603 } else {
1604 let sym = br.read_cb(cb)?;
1605 let skip;
1606 if sym == 11 {
1607 skip = br.read(6)? as usize;
1608 } else {
1609 skip = BINK2_AC_RUNS[sym as usize];
1610 }
1611 idx += skip;
1612 if idx > 63 { break; }
1613 esc_len = if sym == 13 { 6 } else { 0 };
1614 }
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;
1618 idx += 1;
1619 }
1620// set blk info to (dc & 0x1FFF) | (intra ? 0x8000 : 0) | (((ncoded == 0) + (ncoded < 4) + (ncoded < 8)) << 13)
1621 }
1622 Ok(())
1623}
1624
1625fn 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)?;
1628 *old_q = 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;
1634 for i in 0..4 {
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; }
1637 }
1638 Ok(cbp)
1639}
1640
1641fn 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)?;
1644 *old_q = 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; }
1652 Ok(cbp)
1653}
1654
1655
1656fn 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)?;
1659 *old_q = q;
1660 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1661 dcinfo.predict_inter(-1023, 1023);
1662 let dcs = &dcinfo.dcs;
1663 for i in 0..4 {
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; }
1666 }
1667 Ok(cbp)
1668}
1669
1670fn 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)?;
1673 *old_q = 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; }
1679 Ok(cbp)
1680}
1681
1682fn decode_quant_old(br: &mut BitReader, quant_cb: &Codebook<u8>, prev_quant: u8) -> DecoderResult<u8> {
1683 let diff = br.read_cb(quant_cb)?;
1684 if diff == 0 {
1685 Ok(prev_quant)
1686 } else {
1687 let res;
1688 if br.read_bool()? {
1689 res = prev_quant.checked_sub(diff);
1690 } else {
1691 res = prev_quant.checked_add(diff);
1692 }
1693 validate!(res.is_some());
1694 let q = res.unwrap();
1695 validate!(q < 16);
1696 Ok(q)
1697 }
1698}
1699
1700fn decode_cbp_luma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1701 let low;
1702 if br.read_bool()? {
1703 if br.read_bool()? {
1704 return Ok(prev_cbp);
1705 }
1706 low = prev_cbp & 0xFFFF;
1707 } else {
1708 let mut nib1 = (prev_cbp >> 4) & 0xF;
1709 if !br.read_bool()? {
1710 nib1 = br.read(4)?;
1711 }
1712 let mut new_cbp = nib1;
1713 if !br.read_bool()? {
1714 nib1 = br.read(4)?;
1715 }
7e6086e5 1716 new_cbp |= nib1 << 4;
232deab9
KS		 1717 if !br.read_bool()? {
1718 nib1 = br.read(4)?;
1719 }
7e6086e5 1720 new_cbp |= nib1 << 8;
232deab9
KS		 1721 if !br.read_bool()? {
1722 nib1 = br.read(4)?;
1723 }
1724 low = new_cbp | (nib1 << 12);
1725 }
1726 let mut nib_hi = (prev_cbp >> 20) & 0xF;
1727 let mut high = 0;
1728 for i in 0..4 {
1729 let nib = (low >> (4 * i)) & 0xF;
1730 if nib.count_ones() == 0 {
1731 nib_hi = 0;
1732 } else if (nib.count_ones() == 1) || !br.read_bool()? {
1733 nib_hi = 0;
1734 for bit in 0..4 {
1735 if (((nib >> bit) & 1) != 0) && br.read_bool()? {
1736 nib_hi |= 1 << bit;
1737 }
1738 }
1739 }
1740 nib_hi &= nib;
1741 high = (high >> 4) | (nib_hi << 28);
1742 }
1743 Ok(low | high)
1744}
1745
1746fn decode_cbp_chroma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1747 let low;
1748 if !br.read_bool()? {
1749 low = br.read(4)?;
1750 } else {
1751 if br.read_bool()? {
1752 return Ok(prev_cbp);
1753 }
1754 low = prev_cbp & 0xF;
1755 }
1756 let mut high;
1757 if low.count_ones() == 0 {
1758 return Ok(low);
1759 }
1760 if low.count_ones() != 1 {
1761 high = (prev_cbp >> 16) & low;
1762 if br.read_bool()? {
1763 return Ok((high << 16) | low);
1764 }
1765 }
1766 high = 0;
1767 for bit in 0..4 {
1768 if (((low >> bit) & 1) != 0) && br.read_bool()? {
1769 high |= 1 << bit;
1770 }
1771 }
1772 Ok((high << 16) | low)
1773}
1774
1775fn decode_dcs_old(br: &mut BitReader, dcs: &mut [i32], q: u8, read_bias: bool) -> DecoderResult<()> {
1776 let mut bits = br.read(3)? as u8;
1777 if bits == 7 {
1778 bits += br.read(2)? as u8;
1779 }
1780 let scale = BINK2_OLD_DC_QUANTS[q as usize];
1781 if bits == 0 {
1782 for el in dcs.iter_mut() { *el = 0; }
1783 } else {
1784 for dcb in dcs.chunks_mut(4) {
1785 for dc in dcb.iter_mut() {
1786 *dc = br.read(bits)? as i32;
1787 }
1788 for dc in dcb.iter_mut() {
1789 if *dc == 0 { continue; }
1790 *dc *= scale;
1791 if br.read_bool()? {
1792 *dc = -*dc;
1793 }
1794 }
1795 }
1796 }
1797 if read_bias {
1798 let add_bits = BINK2_DC_EXTRA_BITS[q as usize] + bits;
1799 if add_bits < 10 {
1800 let pfx = br.read(10 - add_bits)? as i32;
1801 let base_dc;
1802 if pfx > 0 {
1803 if br.read_bool()? {
1804 base_dc = -(pfx << bits);
1805 } else {
1806 base_dc = pfx << bits;
1807 }
1808 } else {
1809 base_dc = 0;
1810 }
1811 dcs[0] += base_dc * scale;
1812 }
1813 }
1814 Ok(())
1815}
1816
1817fn 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;
1824 let mut idx = 1;
1825 while idx < 64 {
1826 let val = br.read_cb(val_cb)?;
1827 if val != 0 {
1828 let mut level;
1829 if val >= 4 {
1830 let add_bits = br.read(val - 3)? as i32;
1831 level = (1 << (val - 3)) + add_bits + 2;
1832 } else {
1833 level = val as i32;
1834 }
1835 if br.read_bool()? {
1836 level = -level;
1837 }
1838 let pos = scan[idx];
9e9e49d1 1839 dst[blk_no][pos] = (level as f32) * quant_mat[(pos & 7) * 8 + (pos >> 3)] * quant;
232deab9
KS		 1840 }
1841 idx += 1;
1842 if idx >= 64 { break; }
1843 if esc_len >= 1 {
1844 esc_len -= 1;
1845 } else {
1846 let sym = br.read_cb(skip_cb)?;
1847 let skip;
1848 if sym == 11 {
1849 skip = br.read(6)? as usize;
1850 } else {
1851 skip = BINK2_AC_RUNS[sym as usize];
1852 }
1853 idx += skip;
1854 if idx > 63 { break; }
1855 esc_len = if sym == 13 { 6 } else { 0 };
1856 }
1857 }
1858 }
1859 Ok(())
1860}
1861
9dce67e3
KS		 1862const KB2H_NUM_SLICES: [usize; 4] = [ 2, 3, 4, 8 ];
1863
232deab9 1864impl NADecoder for Bink2Decoder {
01613464 1865 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
232deab9
KS		 1866 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1867 let w = vinfo.get_width();
1868 let h = vinfo.get_height();
1869
1870 let edata = info.get_extradata().unwrap();
1871 validate!(edata.len() >= 8);
1872
1873 let mut mr = MemoryReader::new_read(&edata);
1874 let mut br = ByteReader::new(&mut mr);
1875 let magic = br.read_u32be()?;
9dce67e3 1876 let flags = br.read_u32le()?;
232deab9
KS		 1877
1878 self.version = magic;
9dce67e3
KS		 1879 self.has_alpha = (flags & 0x100000) != 0;
1880
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") {
1886 if height_a < 128 {
1887 self.num_slices = 1;
1888 } else {
1889 self.num_slices = 2;
1890 self.slice_h[0] = (h + 31) >> 6;
1891 }
1892 } else {
1893 self.num_slices = KB2H_NUM_SLICES[(flags & 3) as usize];
1894 let mut start = 0;
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;
1898 end -= 32;
1899 self.slice_h[i] = start >> 5;
1900 }
1901 }
1902 self.slice_h[self.num_slices - 1] = height_a >> 5;
232deab9
KS		 1903
1904 let fmt;
9dce67e3 1905 let aplane = if self.has_alpha { Some(NAPixelChromaton::new(0, 0, false, 8, 0, 3, 1)) } else { None };
232deab9
KS		 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)),
9dce67e3
KS		 1910 aplane, None,
1911 if self.has_alpha { FORMATON_FLAG_ALPHA } else { 0 },
1912 if self.has_alpha { 4 } else { 3 });
232deab9 1913 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
2422d969 1914 self.info = NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()).into_ref();
232deab9
KS		 1915
1916 Ok(())
1917 } else {
1918 Err(DecoderError::InvalidData)
1919 }
1920 }
01613464 1921 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
232deab9
KS		 1922 let src = pkt.get_buffer();
1923
fa90ccfb 1924 let mut br = BitReader::new(&src, BitReaderMode::LE);
232deab9
KS		 1925
1926 let mut buf;
1927 self.key_frame = pkt.is_keyframe();
1928
7e6086e5 1929 let bufinfo = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 5)?;
232deab9
KS		 1930 buf = bufinfo.get_vbuf().unwrap();
1931
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());
1935
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 });
171860fc 1938 Ok(frm.into_ref())
232deab9 1939 }
f9be4e75
KS		 1940 fn flush(&mut self) {
1941 self.ips.clear();
1942 }
232deab9 1943}
606c448e 1944
08a1fab7 1945pub fn get_decoder() -> Box<dyn NADecoder + Send> {
232deab9
KS		 1946 Box::new(Bink2Decoder::new())
1947}
1948
1949#[cfg(test)]
1950mod test {
1951 use nihav_core::codecs::RegisteredDecoders;
1952 use nihav_core::demuxers::RegisteredDemuxers;
1953 use nihav_core::test::dec_video::*;
e64739f8
KS		 1954 use crate::rad_register_all_codecs;
1955 use crate::rad_register_all_demuxers;
232deab9
KS		 1956 #[test]
1957 fn test_bink2() {
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);
1962
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";
68331a50 1967 test_file_decoding("bink", file, Some(8), true, false, None/*Some("bink2")*/, &dmx_reg, &dec_reg);
232deab9 1968 }
606c448e
KS		 1969}
1970
232deab9
KS		 1971const 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
1980];
1981const 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
1990];
1991const 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
2000];
2001
2002const BINK2_CHROMA_CBPS: [u32; 16] = [
2003 0x0, 0x0, 0x0, 0xF,
2004 0x0, 0xF, 0xF, 0xF,
2005 0x0, 0xF, 0xF, 0xF,
2006 0xF, 0xF, 0xF, 0xF
2007];
2008
2009const 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
2015];
2016
2017const BINK2_QUANT_INTRA_LUMA: &[[i32; 64]; 4] = &[
2018 [
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
2027 ], [
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
2036 ], [
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
2045 ], [
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
2054 ]
2055];
2056
2057const BINK2_QUANT_INTRA_CHROMA: &[[i32; 64]; 4] = &[
2058 [
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
2067 ], [
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
2076 ], [
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
2085 ], [
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
2094 ]
2095];
2096
2097const BINK2_QUANT_INTER: &[[i32; 64]; 4] = &[
2098 [
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
2107 ], [
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
2116 ], [
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
2125 ], [
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
2134 ]
2135];
2136
2137const BINK2_AC_CODES1: &[u8] = &[
2138 0x01, 0x04, 0x00, 0x08, 0x02, 0x32, 0x0A, 0x12,
2139 0x3A, 0x7A, 0xFA, 0x72, 0x06, 0x1A
2140];
2141const BINK2_AC_BITS1: &[u8] = &[ 1, 3, 4, 4, 5, 7, 5, 6, 7, 8, 8, 7, 3, 6 ];
2142const BINK2_AC_CODES2: &[u16] = &[
2143 0x01, 0x00, 0x04, 0x2C, 0x6C, 0x0C, 0x4C, 0xAC,
2144 0xEC, 0x12C, 0x16C, 0x1AC, 0x02, 0x1C
2145];
2146const BINK2_AC_BITS2: &[u8] = &[ 1, 3, 4, 9, 9, 7, 7, 9, 8, 9, 9, 9, 2, 5 ];
2147
2148const BINK2_AC_RUNS: [usize; 14] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 64, 0 ];
2149
2150const BINK2_MV_CODES: &[u8] = &[
2151 0x01, 0x06, 0x0C, 0x1C, 0x18, 0x38, 0x58, 0x78,
2152 0x68, 0x48, 0x28, 0x08, 0x14, 0x04, 0x02, 0x00
2153];
2154const BINK2_MV_BITS: &[u8] = &[
2155 1, 3, 5, 5, 7, 7, 7, 7,
2156 7, 7, 7, 7, 5, 5, 3, 4
2157];
2158const BINK2_MV_ESC: i8 = 42;
2159const BINK2_MV_SYMS: &[i8] = &[
2160 0, 1, 2, 3, 4, 5, 6, 7,
2161 -7, -6, -5, -4, -3, -2, -1, BINK2_MV_ESC
2162];
2163
2164const BINK2_AC_VAL_CODES1: &[u16] = &[
2165 0x004, 0x01, 0x002, 0x00, 0x08, 0x18, 0xF8, 0x178,
2166 0x138, 0x38, 0x1B8, 0x78, 0xB8
2167];
2168const BINK2_AC_VAL_BITS1: &[u8] = &[ 3, 1, 2, 4, 5, 6, 8, 9, 9, 9, 9, 9, 9 ];
2169const BINK2_AC_VAL_CODES2: &[u16] = &[
2170 0x0A, 0x001, 0x004, 0x08, 0x06, 0x00, 0x02, 0x1A,
2171 0x2A, 0x16A, 0x1EA, 0x6A, 0xEA
2172];
2173const BINK2_AC_VAL_BITS2: &[u8] = &[ 6, 1, 3, 4, 3, 4, 4, 5, 7, 9, 9, 9, 9 ];
2174const BINK2_AC_SKIP_CODES1: &[u16] = &[
2175 0x00, 0x001, 0x0D, 0x15, 0x45, 0x85, 0xA5, 0x165,
2176 0x65, 0x1E5, 0xE5, 0x25, 0x03, 0x05
2177];
2178const BINK2_AC_SKIP_BITS1: &[u8] = &[ 1, 3, 4, 5, 7, 8, 8, 9, 9, 9, 9, 8, 2, 8 ];
2179const BINK2_AC_SKIP_CODES2: &[u16] = &[
2180 0x00, 0x01, 0x003, 0x07, 0x1F, 0x1B, 0x0F, 0x2F,
2181 0x5B, 0xDB, 0x1DB, 0x3B, 0x05, 0x0B
2182];
2183const BINK2_AC_SKIP_BITS2: &[u8] = &[ 1, 3, 4, 4, 5, 7, 6, 6, 8, 9, 9, 6, 3, 5 ];
2184const BINK2_QUANT_CODES: &[u8] = &[
2185 0x01, 0x02, 0x04, 0x08, 0x10, 0x30, 0x50, 0x70,
2186 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
2187];
2188const BINK2_QUANT_BITS: &[u8] = &[ 1, 2, 3, 4, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8 ];
2189
2190const 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
2192];
2193const BINK2_OLD_DC_QUANTS: [i32; 16] = [
2194 4, 4, 4, 4, 4, 6, 7, 8, 10, 12, 16, 24, 32, 48, 64, 128
2195];
2196const BINK2_DC_EXTRA_BITS: [u8; 16] = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 6 ];
2197const 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
2206];
2207const 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
2216];
2217const 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
2226];
NihAV is a research multimedia framework