projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bink2: implement calc_dc as in the reference
[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
8macro_rules! idct_mul {
9 (a; $val: expr) => ($val + ($val >> 2));
10 (b; $val: expr) => ($val >> 1);
11 (c; $val: expr) => ($val - ($val >> 2) - ($val >> 4));
12 (d; $val: expr) => ($val + ($val >> 2) - ($val >> 4));
13 (e; $val: expr) => ($val >> 2);
14}
15
16macro_rules! idct {
17 ($src: expr, $sstep: expr, $off: expr, $dst: expr, $dstep: expr, $doff: expr, $bias: expr, $shift: expr) => {
18 let tmp00 = $src[$off + 3 * $sstep] + $src[$off + 5 * $sstep];
19 let tmp01 = $src[$off + 3 * $sstep] - $src[$off + 5 * $sstep];
20 let tmp02 = idct_mul!(a; $src[$off + 2 * $sstep]) + idct_mul!(b; $src[$off + 6 * $sstep]);
21 let tmp03 = idct_mul!(b; $src[$off + 2 * $sstep]) - idct_mul!(a; $src[$off + 6 * $sstep]);
22 let tmp0 = ($src[$off + 0 * $sstep] + $src[$off + 4 * $sstep]) + tmp02;
23 let tmp1 = ($src[$off + 0 * $sstep] + $src[$off + 4 * $sstep]) - tmp02;
24 let tmp2 = $src[$off + 0 * $sstep] - $src[$off + 4 * $sstep];
25 let tmp3 = $src[$off + 1 * $sstep] + tmp00;
26 let tmp4 = $src[$off + 1 * $sstep] - tmp00;
27 let tmp5 = tmp01 + $src[$off + 7 * $sstep];
28 let tmp6 = tmp01 - $src[$off + 7 * $sstep];
29 let tmp7 = tmp4 + idct_mul!(c; tmp6);
30 let tmp8 = idct_mul!(c; tmp4) - tmp6;
31 let tmp9 = idct_mul!(d; tmp3) + idct_mul!(e; tmp5);
32 let tmp10 = idct_mul!(e; tmp3) - idct_mul!(d; tmp5);
33 let tmp11 = tmp2 + tmp03;
34 let tmp12 = tmp2 - tmp03;
35
36 $dst[$doff + 0 * $dstep] = (tmp0 + tmp9 + $bias) >> $shift;
37 $dst[$doff + 1 * $dstep] = (tmp11 + tmp7 + $bias) >> $shift;
38 $dst[$doff + 2 * $dstep] = (tmp12 + tmp8 + $bias) >> $shift;
39 $dst[$doff + 3 * $dstep] = (tmp1 + tmp10 + $bias) >> $shift;
40 $dst[$doff + 4 * $dstep] = (tmp1 - tmp10 + $bias) >> $shift;
41 $dst[$doff + 5 * $dstep] = (tmp12 - tmp8 + $bias) >> $shift;
42 $dst[$doff + 6 * $dstep] = (tmp11 - tmp7 + $bias) >> $shift;
43 $dst[$doff + 7 * $dstep] = (tmp0 - tmp9 + $bias) >> $shift;
44 };
45 (float; $src: expr, $sstep: expr, $off: expr, $dst: expr, $dstep: expr, $doff: expr, $bias: expr, $shift: expr) => {
46 let t00 = $src[$off + $sstep * 2] + $src[$off + $sstep * 6];
47 let t01 = ($src[$off + $sstep * 2] - $src[$off + $sstep * 6]) * 1.4142135 - t00;
48 let t02 = $src[$off + $sstep * 0] + $src[$off + $sstep * 4];
49 let t03 = $src[$off + $sstep * 0] - $src[$off + $sstep * 4];
50 let t04 = $src[$off + $sstep * 3] + $src[$off + $sstep * 5];
51 let t05 = $src[$off + $sstep * 3] - $src[$off + $sstep * 5];
52 let t06 = $src[$off + $sstep * 1] + $src[$off + $sstep * 7];
53 let t07 = $src[$off + $sstep * 1] - $src[$off + $sstep * 7];
54 let t08 = t02 + t00;
55 let t09 = t02 - t00;
56 let t10 = t03 + t01;
57 let t11 = t03 - t01;
58 let t12 = t06 + t04;
59 let t13 = (t06 - t04) * 1.4142135;
60 let t14 = (t07 - t05) * 1.847759;
61 let t15 = t05 * 2.613126 + t14 - t12;
62 let t16 = t13 - t15;
63 let t17 = t07 * 1.0823922 - t14 + t16;
64
65 $dst[$doff + 0 * $dstep] = t08 + t12;
66 $dst[$doff + 1 * $dstep] = t10 + t15;
67 $dst[$doff + 2 * $dstep] = t11 + t16;
68 $dst[$doff + 3 * $dstep] = t09 - t17;
69 $dst[$doff + 4 * $dstep] = t09 + t17;
70 $dst[$doff + 5 * $dstep] = t11 - t16;
71 $dst[$doff + 6 * $dstep] = t10 - t15;
72 $dst[$doff + 7 * $dstep] = t08 - t12;
73 };
74}
75
76fn bink2_idct(coeffs: &mut [i32; 64]) {
77 let mut tmp: [i32; 64] = [0; 64];
78 for i in 0..8 {
79 idct!(coeffs, 1, 8 * i, tmp, 8, i, 0, 0);
80 }
81 for i in 0..8 {
82 idct!(tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
83 }
84}
85
86fn bink2_idct_old(coeffs: &mut [f32; 64]) {
87 let mut tmp: [f32; 64] = [0.0; 64];
88 for i in 0..8 {
89 idct!(float; coeffs, 8, i, tmp, 8, i, 0, 0);
90 }
91 for i in 0..8 {
92 idct!(float; tmp, 1, 8 * i, coeffs, 1, 8 * i, 0, 6);
93 }
94}
95
96struct Bink2DSP { }
97
98fn clip8(val: i32) -> u8 {
99 val.min(255).max(0) as u8
100}
101
102macro_rules! el {
103 ($src: expr, $off: expr) => (
104 $src[$off] as i32
105 );
106}
107
108macro_rules! luma_filter {
109 ($src: expr, $off: expr, $step: expr) => ({
110 let t0 = el!($src, $off - 0 * $step) + el!($src, $off + 1 * $step);
111 let t1 = el!($src, $off - 1 * $step) + el!($src, $off + 2 * $step);
112 let t2 = el!($src, $off - 2 * $step) + el!($src, $off + 3 * $step);
113 clip8((((t0 * 19) >> 1) - t1 * 2 + (t2 >> 1) + 8) >> 4)
114 });
115}
116
117macro_rules! chroma_interp {
118 ($dst: expr, $dstride: expr, $h: expr, $ty: tt, $src: expr, $sstride: expr, $step: expr, $mode: expr, $shift: expr) => {
119 let mut soff = 0;
120 for out in $dst.chunks_mut($dstride).take($h) {
121 for i in 0..8 {
122 let e0 = el!($src, soff + i);
123 let e1 = el!($src, soff + i + $step);
124 out[i] = match $mode {
125 0 => e0,
126 1 => (e0 * 3 + e1 + $shift) >> $shift,
127 2 => (e0 * 2 + e1 * 2 + $shift) >> $shift,
128 _ => (e0 + e1 * 3 + $shift) >> $shift,
129 } as $ty;
130 }
131 soff += $sstride;
132 }
133 };
134}
135
5de1b118
KS		 136macro_rules! avg_tree {
137 ($a: expr, $b: expr) => (($a + $b + 1) >> 1);
138 ($a: expr, $b: expr, $c: expr, $d: expr) => (avg_tree!(avg_tree!($a, $b), avg_tree!($c, $d)));
139}
140
232deab9
KS		 141impl Bink2DSP {
142 fn calc_dc(src: &[u8], stride: usize) -> i32 {
5de1b118
KS		 143 let mut sums = [0u16; 8];
144 for i in 0..8 {
145 let s0 = src[i + stride * 0] as u16;
146 let s1 = src[i + stride * 1] as u16;
147 let s2 = src[i + stride * 2] as u16;
148 let s3 = src[i + stride * 3] as u16;
149 let s4 = src[i + stride * 4] as u16;
150 let s5 = src[i + stride * 5] as u16;
151 let s6 = src[i + stride * 6] as u16;
152 let s7 = src[i + stride * 7] as u16;
153 sums[i] = avg_tree!(avg_tree!(s0, s1, s2, s3), avg_tree!(s4, s5, s6, s7));
154 }
232deab9 155 let mut sum = 0;
5de1b118
KS		 156 for e in sums.iter() {
157 sum += e;
232deab9 158 }
5de1b118 159 sum as i32
232deab9
KS		 160 }
161 fn put_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
162 bink2_idct(&mut blk[0]);
163 bink2_idct(&mut blk[1]);
164 bink2_idct(&mut blk[2]);
165 bink2_idct(&mut blk[3]);
166 {
167 let dout = &mut dst[off..];
168 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
169 for i in 0..8 { row[i + 0] = clip8(b0[i]); }
170 for i in 0..8 { row[i + 8] = clip8(b1[i]); }
171 }
172 }
173 off += stride * 8;
174 {
175 let dout = &mut dst[off..];
176 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
177 for i in 0..8 { row[i + 0] = clip8(b2[i]); }
178 for i in 0..8 { row[i + 8] = clip8(b3[i]); }
179 }
180 }
181 }
182 fn add_mb4(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[i32; 64]; 4]) {
183 bink2_idct(&mut blk[0]);
184 bink2_idct(&mut blk[1]);
185 bink2_idct(&mut blk[2]);
186 bink2_idct(&mut blk[3]);
187 {
188 let dout = &mut dst[off..];
189 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
190 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b0[i]); }
191 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b1[i]); }
192 }
193 }
194 off += stride * 8;
195 {
196 let dout = &mut dst[off..];
197 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
198 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + b2[i]); }
199 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + b3[i]); }
200 }
201 }
202 }
203 fn put_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
204 bink2_idct_old(&mut blk[0]);
205 bink2_idct_old(&mut blk[1]);
206 bink2_idct_old(&mut blk[2]);
207 bink2_idct_old(&mut blk[3]);
208 {
209 let dout = &mut dst[off..];
210 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
211 for i in 0..8 { row[i + 0] = clip8(b0[i] as i32); }
212 for i in 0..8 { row[i + 8] = clip8(b1[i] as i32); }
213 }
214 }
215 off += stride * 8;
216 {
217 let dout = &mut dst[off..];
218 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
219 for i in 0..8 { row[i + 0] = clip8(b2[i] as i32); }
220 for i in 0..8 { row[i + 8] = clip8(b3[i] as i32); }
221 }
222 }
223 }
224 fn add_mb4_old(dst: &mut [u8], mut off: usize, stride: usize, blk: &mut [[f32; 64]; 4]) {
225 bink2_idct_old(&mut blk[0]);
226 bink2_idct_old(&mut blk[1]);
227 bink2_idct_old(&mut blk[2]);
228 bink2_idct_old(&mut blk[3]);
229 {
230 let dout = &mut dst[off..];
231 for (row, (b0, b1)) in dout.chunks_mut(stride).zip(blk[0].chunks(8).zip(blk[1].chunks(8))) {
232 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b0[i] as i32)); }
233 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b1[i] as i32)); }
234 }
235 }
236 off += stride * 8;
237 {
238 let dout = &mut dst[off..];
239 for (row, (b2, b3)) in dout.chunks_mut(stride).zip(blk[2].chunks(8).zip(blk[3].chunks(8))) {
240 for i in 0..8 { row[i + 0] = clip8((row[i + 0] as i32) + (b2[i] as i32)); }
241 for i in 0..8 { row[i + 8] = clip8((row[i + 8] as i32) + (b3[i] as i32)); }
242 }
243 }
244 }
245 fn mc_luma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
246 let sx = (xoff as isize) + ((mv.x >> 1) as isize);
247 let sy = (yoff as isize) + ((mv.y >> 1) as isize);
248 let mode = (mv.x & 1) + (mv.y & 1) * 2;
249 let (d_x, add_x) = if (mv.x & 1) != 0 { (2, 5) } else { (0, 0) };
250 let (d_y, add_y) = if (mv.y & 1) != 0 { (2, 5) } else { (0, 0) };
251
252 let (w, h) = ref_pic.get_dimensions(plane);
253 validate!((sx - d_x >= 0) && (sx - d_x + add_x + 16 <= (w as isize)));
254 validate!((sy - d_y >= 0) && (sy - d_y + add_y + 16 <= (h as isize)));
255 let pstride = ref_pic.get_stride(plane);
256 let mut poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
257 let pdata = ref_pic.get_data();
258 let ppix = pdata.as_slice();
259
260 let dst = &mut dst[xoff + (yoff & 31) * stride..];
261
262 match mode {
263 0 => {
264 let src = &ppix[poff..];
265 for (out, row) in dst.chunks_mut(stride).take(16).zip(src.chunks(pstride)) {
266 for i in 0..16 { out[i] = row[i]; }
267 }
268 },
269 1 => {
270 for out in dst.chunks_mut(stride).take(16) {
271 for i in 0..16 {
272 out[i] = luma_filter!(ppix, poff + i, 1);
273 }
274 poff += pstride;
275 }
276 },
277 2 => {
278 for out in dst.chunks_mut(stride).take(16) {
279 for i in 0..16 {
280 out[i] = luma_filter!(ppix, poff + i, pstride);
281 }
282 poff += pstride;
283 }
284 },
285 3 => {
286 let mut tmp = [0u8; 21 * 16];
287 for out in tmp.chunks_mut(16) {
288 for i in 0..16 {
289 out[i] = luma_filter!(ppix, poff - 2 * pstride + i, 1);
290 }
291 poff += pstride;
292 }
293 for (row, out) in dst.chunks_mut(stride).take(16).enumerate() {
294 for i in 0..16 {
295 out[i] = luma_filter!(tmp, (row + 2) * 16 + i, 16);
296 }
297 }
298 },
299 _ => unreachable!(),
300 };
301 Ok(())
302 }
303 fn mc_chroma(dst: &mut [u8], stride: usize, ref_pic: &NAVideoBuffer<u8>, xoff: usize, yoff: usize, mv: MV, plane: usize) -> DecoderResult<()> {
304 let sx = (xoff as isize) + ((mv.x >> 2) as isize);
305 let sy = (yoff as isize) + ((mv.y >> 2) as isize);
306 let mx = mv.x & 3;
307 let my = mv.y & 3;
308 let add_x = if mx != 0 { 1 } else { 0 };
309 let add_y = if my != 0 { 1 } else { 0 };
310
311 let (w, h) = ref_pic.get_dimensions(plane);
312 validate!((sx >= 0) && (sx + add_x + 8 <= (w as isize)));
313 validate!((sy >= 0) && (sy + add_y + 8 <= (h as isize)));
314 let pstride = ref_pic.get_stride(plane);
315 let poff = ref_pic.get_offset(plane) + (sx as usize) + (sy as usize) * pstride;
316 let pdata = ref_pic.get_data();
317 let ppix = pdata.as_slice();
318
319 let dst = &mut dst[xoff + (yoff & 15) * stride..];
320 if (mx == 0) && (my == 0) {
321 let inpix = &ppix[poff..];
322 for (out, src) in dst.chunks_mut(stride).take(8).zip(inpix.chunks(pstride)) {
323 for i in 0..8 { out[i] = src[i]; }
324 }
325 } else if my == 0 {
326 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, 1, mx, 2);
327 } else if mx == 0 {
328 chroma_interp!(dst, stride, 8, u8, &ppix[poff..], pstride, pstride, my, 2);
329 } else {
330 let mut tmp = [0u16; 9 * 8];
331 chroma_interp!(tmp, 8, 9, u16, &ppix[poff..], pstride, 1, mx, 0);
332 chroma_interp!(dst, stride, 8, u8, &tmp, 8, 8, my, 4);
333 }
334 Ok(())
335 }
336}
337
338fn mid_pred<T:PartialOrd>(a: T, b: T, c: T) -> T {
339 if a < b {
340 if b < c {
341 b
342 } else {
343 if a < c { c } else { a }
344 }
345 } else {
346 if b < c {
347 if a < c { a } else { c }
348 } else {
349 b
350 }
351 }
352}
353
354#[derive(Default)]
355struct QuantInfo {
356 quants: Vec<u8>,
357 qstride: usize,
358 qpos: usize,
359 pqpos: usize,
360}
361
362impl QuantInfo {
363 fn resize(&mut self, bw: usize) {
364 self.qstride = bw * 2;
365 self.quants.resize(self.qstride * 2, 0);
366 self.qpos = 0;
367 self.pqpos = self.qstride;
368 }
369 fn update_line(&mut self) {
370 mem::swap(&mut self.qpos, &mut self.pqpos);
371 }
372 fn pred_quant(&self, pos: usize, is_top: bool) -> u8 {
373 let is_left = pos < 2;
374 if is_top {
375 if is_left { 16 } else { self.quants[self.qpos + pos - 2] }
376 } else {
377 if is_left {
378 self.quants[self.pqpos + pos]
379 } else {
380 mid_pred(self.quants[self.pqpos + pos - 2],
381 self.quants[self.pqpos + pos],
382 self.quants[self.qpos + pos - 2])
383 }
384 }
385 }
386 fn set_quant(&mut self, pos: usize, q: u8) {
387 self.quants[self.qpos + pos] = q;
388 }
389}
390
391#[derive(Default)]
392struct YDCInfo {
393 dcs: [i32; 16],
394 dc_buf: [i32; 16],
395 prev_dcs: Vec<i32>,
396 new_dcs: Vec<i32>,
397 stride: usize,
398 prev_off: usize,
399}
400
401impl YDCInfo {
402 fn resize(&mut self, bw: usize) {
403 self.stride = bw * 4 + 4;
404 self.prev_off = 4;
405 self.prev_dcs.resize(self.stride, 0);
406 self.new_dcs.resize(self.stride, 0);
407 }
408 fn update_line(&mut self) {
409 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
410 }
411 fn set_dcs(&mut self, bx: usize, dc5: i32, dc7: i32, dc13: i32, dc10: i32, dc11: i32, dc14: i32, dc15: i32) {
412 self.dcs[ 5] = dc5;
413 self.dcs[ 7] = dc7;
414 self.dcs[13] = dc13;
415 self.dcs[15] = dc15;
416 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
417 new_dc[0] = dc10;
418 new_dc[1] = dc11;
419 new_dc[2] = dc14;
420 new_dc[3] = dc15;
421 }
422}
423
424#[derive(Default)]
425struct CDCInfo {
426 dcs: [i32; 4],
427 dc_buf: [i32; 4],
428 prev_dcs: Vec<i32>,
429 new_dcs: Vec<i32>,
430 stride: usize,
431 prev_off: usize,
432}
433
434impl CDCInfo {
435 fn resize(&mut self, bw: usize) {
436 self.stride = bw * 2 + 2;
437 self.prev_off = 2;
438 self.prev_dcs.resize(self.stride, 0);
439 self.new_dcs.resize(self.stride, 0);
440 }
441 fn update_line(&mut self) {
442 mem::swap(&mut self.prev_dcs, &mut self.new_dcs);
443 }
444 fn set_dcs(&mut self, bx: usize, dc1: i32, dc2: i32, dc3: i32) {
445 self.dcs[1] = dc1;
446 self.dcs[2] = dc2;
447 self.dcs[3] = dc3;
448 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
449 new_dc[0] = dc2;
450 new_dc[1] = dc3;
451 }
452}
453
454trait DCInfo {
455 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool>;
456 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32);
457 fn predict_inter(&mut self, min_dc: i32, max_dc: i32);
458}
459
460fn dc_pred2(a: i32, b: i32) -> i32 {
461 (a.max(b)).min(a.min(b).max(a * 2 - b))
462}
463fn dc_pred(a: i32, b: i32, c: i32) -> i32 {
464 (a.max(b).max(c)).min((a.min(b).min(c)).max(b - a + c))
465}
466
467impl DCInfo for YDCInfo {
468 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
469 decode_dcs(br, &mut self.dc_buf, q)
470 }
471 #[allow(non_snake_case)]
472 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
473 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
474 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
475 let prev_dc = &self.prev_dcs[bx * 4..];
476 let dst = &mut self.dcs;
477 let dcs = &self.dc_buf;
478 if is_left {
479 if is_top { //zigzag in 2x2 blocks
480 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
481 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
482 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
483 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
484 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
485
486 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
487 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
488 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
489 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
490
491 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
492 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
493 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
494 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
495
496 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
497 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
498 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
499 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
500 } else {
501 a0 = (dcs[ 0] + dc_pred2(prev_dc[4], prev_dc[5])).max(min_dc).min(max_dc);
502 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
503 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
504 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
505
506 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
507 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
508 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
509 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
510
511 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
512 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
513 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
514 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
515
516 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
517 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
518 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
519 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
520 }
521 } else {
522 if is_top {
523 a0 = (dcs[ 0] + dc_pred2(dst[5], dst[7])).max(min_dc).min(max_dc);
524 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
525 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
526 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
527
528 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
529 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
530 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
531 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
532
533 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
534 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
535 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
536 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
537
538 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
539 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
540 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
541 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
542 } else {
543 a0 = (dcs[ 0] + dc_pred(prev_dc[3], prev_dc[4], dst[5])).max(min_dc).min(max_dc);
544 a1 = (dcs[ 1] + dc_pred(prev_dc[4], prev_dc[5], a0)).max(min_dc).min(max_dc);
545 a2 = (dcs[ 2] + dc_pred(dst[5], dst[7], a0)).max(min_dc).min(max_dc);
546 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
547
548 a4 = (dcs[ 4] + dc_pred(prev_dc[5], prev_dc[6], a1)).max(min_dc).min(max_dc);
549 a5 = (dcs[ 5] + dc_pred(prev_dc[6], prev_dc[7], a4)).max(min_dc).min(max_dc);
550 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
551 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
552
553 a8 = (dcs[ 8] + dc_pred(dst[7], dst[13], a2)).max(min_dc).min(max_dc);
554 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
555 aA = (dcs[10] + dc_pred(dst[13], dst[15], a8)).max(min_dc).min(max_dc);
556 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
557
558 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
559 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
560 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
561 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
562 }
563 }
564 dst[ 0] = a0;
565 dst[ 1] = a1;
566 dst[ 2] = a2;
567 dst[ 3] = a3;
568 dst[ 4] = a4;
569 dst[ 5] = a5;
570 dst[ 6] = a6;
571 dst[ 7] = a7;
572 dst[ 8] = a8;
573 dst[ 9] = a9;
574 dst[10] = aA;
575 dst[11] = aB;
576 dst[12] = aC;
577 dst[13] = aD;
578 dst[14] = aE;
579 dst[15] = aF;
580 let new_dc = &mut self.new_dcs[bx * 4 + 4..];
581 new_dc[0] = aA;
582 new_dc[1] = aB;
583 new_dc[2] = aE;
584 new_dc[3] = aF;
585 }
586 #[allow(non_snake_case)]
587 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
588 let a0; let a1; let a2; let a3; let a4; let a5; let a6; let a7;
589 let a8; let a9; let aA; let aB; let aC; let aD; let aE; let aF;
590 let dst = &mut self.dcs;
591 let dcs = &self.dc_buf;
592 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
593 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
594 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
595 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
596
597 a4 = (dcs[ 4] + dc_pred2(a1, a3)).max(min_dc).min(max_dc);
598 a5 = (dcs[ 5] + a4).max(min_dc).min(max_dc);
599 a6 = (dcs[ 6] + dc_pred(a1, a3, a4)).max(min_dc).min(max_dc);
600 a7 = (dcs[ 7] + dc_pred(a4, a5, a6)).max(min_dc).min(max_dc);
601
602 a8 = (dcs[ 8] + dc_pred2(a2, a3)).max(min_dc).min(max_dc);
603 a9 = (dcs[ 9] + dc_pred(a2, a3, a8)).max(min_dc).min(max_dc);
604 aA = (dcs[10] + dc_pred2(a8, a9)).max(min_dc).min(max_dc);
605 aB = (dcs[11] + dc_pred(a8, a9, aA)).max(min_dc).min(max_dc);
606
607 aC = (dcs[12] + dc_pred(a3, a6, a9)).max(min_dc).min(max_dc);
608 aD = (dcs[13] + dc_pred(a6, a7, aC)).max(min_dc).min(max_dc);
609 aE = (dcs[14] + dc_pred(a9, aB, aC)).max(min_dc).min(max_dc);
610 aF = (dcs[15] + dc_pred(aC, aD, aE)).max(min_dc).min(max_dc);
611
612 dst[ 0] = a0;
613 dst[ 1] = a1;
614 dst[ 2] = a2;
615 dst[ 3] = a3;
616 dst[ 4] = a4;
617 dst[ 5] = a5;
618 dst[ 6] = a6;
619 dst[ 7] = a7;
620 dst[ 8] = a8;
621 dst[ 9] = a9;
622 dst[10] = aA;
623 dst[11] = aB;
624 dst[12] = aC;
625 dst[13] = aD;
626 dst[14] = aE;
627 dst[15] = aF;
628 }
629}
630
631impl DCInfo for CDCInfo {
632 fn decode_dcs(&mut self, br: &mut BitReader, q: u8) -> DecoderResult<bool> {
633 decode_dcs(br, &mut self.dc_buf, q)
634 }
635 fn predict(&mut self, bx: usize, is_top: bool, is_left: bool, min_dc: i32, max_dc: i32) {
636 let prev_dc = &self.prev_dcs[bx * 2..];
637 let dst = &mut self.dcs;
638 let dcs = &self.dc_buf;
639
640 let a0; let a1; let a2; let a3;
641 if is_left {
642 if is_top {
643 let add = 1 << 10;//if has_prev_dc { 1 << 10 } else { 0 };
644 a0 = (dcs[ 0] + add).max(min_dc).min(max_dc);
645 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
646 } else {
647 a0 = (dcs[ 0] + dc_pred2(prev_dc[2], prev_dc[3])).max(min_dc).min(max_dc);
648 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
649 }
650 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
651 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
652 } else {
653 if is_top {
654 a0 = (dcs[ 0] + dc_pred2(dst[1], dst[3])).max(min_dc).min(max_dc);
655 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
656 } else {
657 a0 = (dcs[ 0] + dc_pred(prev_dc[1], prev_dc[2], dst[1])).max(min_dc).min(max_dc);
658 a1 = (dcs[ 1] + dc_pred(prev_dc[2], prev_dc[3], a0)).max(min_dc).min(max_dc);
659 }
660 a2 = (dcs[ 2] + dc_pred(dst[1], dst[3], a0)).max(min_dc).min(max_dc);
661 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
662 }
663 dst[0] = a0;
664 dst[1] = a1;
665 dst[2] = a2;
666 dst[3] = a3;
667 let new_dc = &mut self.new_dcs[bx * 2 + 2..];
668 new_dc[0] = a2;
669 new_dc[1] = a3;
670 }
671 fn predict_inter(&mut self, min_dc: i32, max_dc: i32) {
672 let dst = &mut self.dcs;
673 let dcs = &self.dc_buf;
674
675 let a0; let a1; let a2; let a3;
676
677 a0 = (dcs[ 0] + 0).max(min_dc).min(max_dc);
678 a1 = (dcs[ 1] + a0).max(min_dc).min(max_dc);
679 a2 = (dcs[ 2] + dc_pred2(a0, a1)).max(min_dc).min(max_dc);
680 a3 = (dcs[ 3] + dc_pred(a0, a1, a2)).max(min_dc).min(max_dc);
681
682 dst[0] = a0;
683 dst[1] = a1;
684 dst[2] = a2;
685 dst[3] = a3;
686 }
687}
688
689fn decode_dcs(br: &mut BitReader, dcs: &mut [i32], q: u8) -> DecoderResult<bool> {
690 if !br.read_bool()? {
691 for dc in dcs.iter_mut() {
692 *dc = 0;
693 }
694 Ok(false)
695 } else {
696 let quant = BINK2_QUANT_DC[q.max(8) as usize];
697 for dc in dcs.iter_mut() {
698 *dc = br.read_bink2_code_zero()?;
699 if *dc != 0 {
700 *dc = (*dc * quant + 0x1FF) >> 10;
701 if br.read_bool()? {
702 *dc = -*dc;
703 }
704 }
705 }
706 Ok(true)
707 }
708}
709#[derive(Default)]
710struct MVInfo {
711 mvs: Vec<MV>,
712 stride: usize,
713 mv_off: usize,
714 prev_off: usize,
715}
716
717impl MVInfo {
718 fn resize(&mut self, bw: usize) {
719 self.stride = bw * 4;
720 self.mv_off = 0;
721 self.prev_off = self.stride;
722 self.mvs.resize(self.stride * 2, ZERO_MV);
723 }
724 fn update_line(&mut self) {
725 mem::swap(&mut self.mv_off, &mut self.prev_off);
726 }
727 fn decode_mv_new(&mut self, br: &mut BitReader, mv_cb: &Codebook<i8>, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
728 let num_mv = if br.read_bool()? { 1 } else { 4 };
729 let mv = &mut self.mvs;
730 let mv_pos = self.mv_off + bx * 4;
731 let ref_pos = self.prev_off + bx * 4;
732
733 for comp in 0..2 {
734 for i in 0..num_mv {
735 let val;
736 let raw_val = br.read_cb(mv_cb)?;
737 if raw_val != BINK2_MV_ESC {
738 val = raw_val as i16;
739 } else {
740 let len = br.read_code(UintCodeType::LimitedUnary(12, 1))? as u8;
741 let nlen = len + 4;
742 let uval = (br.read(nlen)? as i32) + (1 << nlen) - 1;
743 if (uval & 1) != 0 {
744 val = (-(uval >> 1) - 1) as i16;
745 } else {
746 val = (uval >> 1) as i16;
747 }
748 }
749 if comp == 0 {
750 mv[mv_pos + i].x = val;
751 } else {
752 mv[mv_pos + i].y = val;
753 }
754 }
755 }
756
757 if num_mv > 1 {
758 if is_top {
759 if !is_left {
760 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
761 mv[mv_pos + 0] = mv0;
762 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
763 mv[mv_pos + 2] = mv2;
764 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
765 mv[mv_pos + 1] = mv1;
766 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
767 mv[mv_pos + 3] = mv3;
768 } else {
769 let mv1 = mv[mv_pos + 1] + mv[mv_pos + 0];
770 mv[mv_pos + 1] = mv1;
771 let mv2 = mv[mv_pos + 2] + mv[mv_pos + 0];
772 mv[mv_pos + 2] = mv2;
773 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
774 mv[mv_pos + 3] = mv3;
775 }
776 } else {
777 if is_left {
778 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
779 mv[mv_pos + 0] = mv0;
780 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
781 mv[mv_pos + 1] = mv1;
782 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
783 mv[mv_pos + 2] = mv2;
784 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
785 mv[mv_pos + 3] = mv3;
786 } else {
787 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 2], mv[ref_pos - 1], mv[mv_pos - 3]);
788 mv[mv_pos + 0] = mv0;
789 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
790 mv[mv_pos + 1] = mv1;
791 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
792 mv[mv_pos + 2] = mv2;
793 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
794 mv[mv_pos + 3] = mv3;
795 }
796 }
797 } else {
798 let mut mv_pred = mv[mv_pos + 0];
799 if is_top {
800 if !is_left {
801 mv_pred += MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
802 }
803 } else {
804 if !is_left {
805 mv_pred += MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
806 } else {
807 mv_pred += MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
808 }
809 }
810 mv[mv_pos + 0] = mv_pred;
811 mv[mv_pos + 1] = mv_pred;
812 mv[mv_pos + 2] = mv_pred;
813 mv[mv_pos + 3] = mv_pred;
814 }
815 Ok(())
816 }
817 fn decode_mv_old(&mut self, br: &mut BitReader, bx: usize, is_top: bool, is_left: bool) -> DecoderResult<()> {
818 let mv = &mut self.mvs;
819 let mv_pos = self.mv_off + bx * 4;
820 let ref_pos = self.prev_off + bx * 4;
821
822 let mut basex = 0;
823 let mut basey = 0;
824 for comp in 0..2 {
825 let mut bits = br.read(3)? as u8;
826 if bits == 7 {
827 bits += br.read(2)? as u8;
828 }
829 let mut mv_c: [i16; 4] = [0; 4];
830 if bits > 0 {
831 for i in 0..4 {
832 mv_c[i] = br.read(bits)? as i16;
833 }
834 for i in 0..4 {
835 if (mv_c[i] != 0) && br.read_bool()? {
836 mv_c[i] = -mv_c[i];
837 }
838 }
839 }
840 if is_top && is_left {
841 let mut val = br.read(5)? as i16;
842 if (val != 0) && br.read_bool()? {
843 val = -val;
844 }
845 if comp == 0 {
846 basex = val;
847 } else {
848 basey = val;
849 }
850 }
851 if comp == 0 {
852 for i in 0..4 {
853 mv[mv_pos + i].x = mv_c[i];
854 }
855 } else {
856 for i in 0..4 {
857 mv[mv_pos + i].y = mv_c[i];
858 }
859 }
860 }
861 if !is_top {
862 if is_left {
863 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
864 mv[mv_pos + 0] = mv0;
865 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
866 mv[mv_pos + 1] = mv1;
867 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
868 mv[mv_pos + 2] = mv2;
869 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
870 mv[mv_pos + 3] = mv3;
871 } else {
872 let mv0 = mv[mv_pos + 0] + MV::pred(mv[ref_pos - 1], mv[ref_pos + 2], mv[mv_pos - 3]);
873 mv[mv_pos + 0] = mv0;
874 let mv1 = mv[mv_pos + 1] + MV::pred(mv[ref_pos + 2], mv[ref_pos + 3], mv[mv_pos + 0]);
875 mv[mv_pos + 1] = mv1;
876 let mv2 = mv[mv_pos + 2] + MV::pred(mv[ref_pos + 2], mv[mv_pos + 0], mv[mv_pos + 1]);
877 mv[mv_pos + 2] = mv2;
878 let mv3 = mv[mv_pos + 3] + MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
879 mv[mv_pos + 3] = mv3;
880 }
881 } else {
882 if is_left {
883 let base_mv = MV { x: basex * 16, y: basey * 16 };
884 mv[mv_pos + 0] += base_mv;
885 mv[mv_pos + 1] += base_mv;
886 mv[mv_pos + 2] += base_mv;
887 mv[mv_pos + 3] += base_mv;
888 } else {
889 let mv0 = mv[mv_pos + 0] + MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
890 mv[mv_pos + 0] = mv0;
891 let mv2 = mv[mv_pos + 2] + MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
892 mv[mv_pos + 2] = mv2;
893 let mv1 = mv[mv_pos + 1] + MV::pred(mv[mv_pos - 3], mv[mv_pos + 0], mv[mv_pos + 2]);
894 mv[mv_pos + 1] = mv1;
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 }
899 Ok(())
900 }
901
902 fn predict_mvs(&mut self, bx: usize, is_top: bool, is_left: bool, is_new: bool) {
903 let mv = &mut self.mvs;
904 let mv_pos = self.mv_off + bx * 4;
905 let ref_pos = self.prev_off + bx * 4;
906
907 if is_top {
908 if is_left {
909 for i in 0..4 {
910 mv[mv_pos + i] = ZERO_MV;
911 }
912 } else {
913 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 4], mv[mv_pos - 3], mv[mv_pos - 1]);
914 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
915 mv[mv_pos + 1] = MV::pred(mv[mv_pos - 1], mv[mv_pos + 0], mv[mv_pos + 2]);
916 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
917 }
918 } else {
919 if is_left {
920 mv[mv_pos + 0] = MV::pred(mv[ref_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
921 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
922 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
923 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
924 } else {
925 mv[mv_pos + 0] = MV::pred(mv[mv_pos - 3], mv[ref_pos - 1], mv[ref_pos + 2]);
926 mv[mv_pos + 1] = MV::pred(mv[mv_pos + 0], mv[ref_pos + 2], mv[ref_pos + 3]);
927 if is_new {
928 mv[mv_pos + 2] = MV::pred(mv[mv_pos - 3], mv[mv_pos - 1], mv[mv_pos + 0]);
929 } else {
930 mv[mv_pos + 2] = MV::pred(mv[ref_pos + 2], mv[mv_pos + 1], mv[mv_pos + 0]);
931 }
932 mv[mv_pos + 3] = MV::pred(mv[mv_pos + 0], mv[mv_pos + 1], mv[mv_pos + 2]);
933 }
934 }
935 }
936
937 fn get_mv(&self, bx: usize, blk: usize) -> MV { self.mvs[self.mv_off + bx * 4 + blk] }
938 fn zero(&mut self, bx: usize) {
939 let pos = self.mv_off + bx * 4;
940 self.mvs[pos + 0] = ZERO_MV;
941 self.mvs[pos + 1] = ZERO_MV;
942 self.mvs[pos + 2] = ZERO_MV;
943 self.mvs[pos + 3] = ZERO_MV;
944 }
945}
946
947struct Bink2Codes {
948 ac_cb1: Codebook<u8>,
949 ac_cb2: Codebook<u8>,
950 mv_cb: Codebook<i8>,
951 val_cb1: Codebook<u8>,
952 val_cb2: Codebook<u8>,
953 skip_cb1: Codebook<u8>,
954 skip_cb2: Codebook<u8>,
955 quant_cb: Codebook<u8>,
956}
957
958fn map_ac(idx: usize) -> u8 { idx as u8 }
959fn map_mv(idx: usize) -> i8 { BINK2_MV_SYMS[idx] }
960
961impl Default for Bink2Codes {
962 fn default() -> Self {
963 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES1, BINK2_AC_BITS1, map_ac);
964 let ac_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
965 let mut cbr = TableCodebookDescReader::new(BINK2_AC_CODES2, BINK2_AC_BITS2, map_ac);
966 let ac_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
967 let mut cbr = TableCodebookDescReader::new(BINK2_MV_CODES, BINK2_MV_BITS, map_mv);
968 let mv_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
969 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES1, BINK2_AC_VAL_BITS1, map_ac);
970 let val_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
971 let mut cbr = TableCodebookDescReader::new(BINK2_AC_VAL_CODES2, BINK2_AC_VAL_BITS2, map_ac);
972 let val_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
973 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES1, BINK2_AC_SKIP_BITS1, map_ac);
974 let skip_cb1 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
975 let mut cbr = TableCodebookDescReader::new(BINK2_AC_SKIP_CODES2, BINK2_AC_SKIP_BITS2, map_ac);
976 let skip_cb2 = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
977 let mut cbr = TableCodebookDescReader::new(BINK2_QUANT_CODES, BINK2_QUANT_BITS, map_ac);
978 let quant_cb = Codebook::new(&mut cbr, CodebookMode::LSB).unwrap();
979 Self { ac_cb1, ac_cb2, mv_cb, val_cb1, val_cb2, skip_cb1, skip_cb2, quant_cb }
980 }
981}
982
983#[derive(Default)]
984struct Bink2Decoder {
985 info: Rc<NACodecInfo>,
986 ips: IPShuffler,
987
988 version: u32,
989 key_frame: bool,
990 cur_w: usize,
991 cur_h: usize,
992 qinfo: QuantInfo,
993 y_dcs: YDCInfo,
994 u_dcs: CDCInfo,
995 v_dcs: CDCInfo,
996 mvs: MVInfo,
997
998 codes: Bink2Codes,
999}
1000
1001impl Bink2Decoder {
1002 fn new() -> Self {
1003 Self::default()
1004 }
1005
1006 fn decode_frame_new(&mut self, br: &mut BitReader, buf: &mut NAVideoBuffer<u8>, is_intra: bool) -> DecoderResult<()> {
1007 let (stride_y, stride_u, stride_v) = (buf.get_stride(0), buf.get_stride(1), buf.get_stride(2));
1008 let (mut off_y, mut off_u, mut off_v) = (buf.get_offset(0), buf.get_offset(1), buf.get_offset(2));
1009 let (ooff_y, ooff_u, ooff_v) = (off_y, off_u, off_v);
1010 let (width, height) = buf.get_dimensions(0);
1011 let mut data = buf.get_data_mut();
1012 let dst = data.as_mut_slice();
1013 let bw = (width + 31) >> 5;
1014 let bh = (height + 31) >> 6;
1015 self.cur_w = (width + 7) & !7;
1016 self.cur_h = ((height + 7) & !7) >> 1;
1017
1018 let frame_flags = br.read(32)?;
1019 let offset2 = br.read(32)?;
1020 if (frame_flags & 0x80000) != 0 {
1021println!("fill {:X}", frame_flags);
1022unimplemented!();
1023 }
1024 for slice_no in 0..2 {
1025 if slice_no == 1 {
1026 br.seek(offset2 * 8)?;
1027 off_y = ooff_y + stride_y * bh * 32;
1028 off_u = ooff_u + stride_u * bh * 16;
1029 off_v = ooff_v + stride_v * bh * 16;
1030 }
1031 let mut row_flags: Vec<u8> = Vec::with_capacity(height >> 3);
1032 let mut col_flags: Vec<u8> = Vec::with_capacity(width >> 3);
1033 if (frame_flags & 0x1000) != 0 {
1034 if (frame_flags & 0x8000) != 0 {
1035 decode_flags(br, &mut row_flags, 1, (height >> 3) - 1)?;
1036 }
1037 if (frame_flags & 0x4000) != 0 {
1038 decode_flags(br, &mut col_flags, 1, (width >> 3) - 1)?;
1039 }
1040 }
1041 row_flags.resize(height >> 3, 0);
1042 col_flags.resize(width >> 3, 0);
1043 //store frame_flags * 8 & 0x7F8
1044
1045 let mut row_state = frame_flags & 0x2E000;
1046 if is_intra {
1047 row_state |= 0x10000;
1048 }
1049 self.qinfo.resize(bw);
1050 self.y_dcs.resize(bw);
1051 self.u_dcs.resize(bw);
1052 self.v_dcs.resize(bw);
1053 self.mvs.resize(bw);
1054 for by in 0..bh {
1055 let mut cbp_y = 0;
1056 let mut cbp_u = 0;
1057 let mut cbp_v = 0;
1058 let mut cbp_y_p = 0;
1059 let mut cbp_u_p = 0;
1060 let mut cbp_v_p = 0;
1061 let mut q_y = 8;
1062 let mut q_u = 8;
1063 let mut q_v = 8;
1064 let mut q_y_p = 8;
1065 let mut q_u_p = 8;
1066 let mut q_v_p = 8;
1067 let rflags = (row_flags[by >> 1] >> (if (by & 1) != 0 { 4 } else { 0 })) as u32;
1068 row_state = (row_state & 0x3FFFFFF) | ((row_state >> 4) & 0xC000000) | (rflags << 28);
1069 if by == 0 {
1070 row_state |= 0x80;
1071// } else {
1072// row_state |= 0x8;
1073 }
1074 if by + 2 >= bh {
1075 row_state |= 0x100;
1076 }
1077
1078 let mut btype_lru: [u8; 4] = [ 2, 3, 1, 0 ];
1079 let mut edge_state = 0;
1080 let is_top = by == 0;
1081 for bx in 0..bw {
1082 let mut blk_state = row_state | (edge_state & 0x3FC0000);
1083 if bx == 0 {
1084 blk_state |= 0x20;
1085 }
1086 if bx + 2 < bw {
1087 blk_state |= 0x40;
1088 }
1089 if (bx & 1) != 0 {
1090 blk_state |= 0x200;
1091 }
1092 let clflags = (col_flags[bx >> 1] >> (if (bx & 1) != 0 { 4 } else { 0 })) as u32;
1093 let edge_state_c = ((blk_state >> 4) & 0x3C0000) | (blk_state & 0xFC03FFFF) | ((clflags & 0xF) << 22);
1094 let edge_state_y = (frame_flags & 0x40000) | (blk_state & 0x3FFFF);
1095 edge_state = edge_state_c;
1096
1097 //let is_top = (edge_state & 0x88) != 0;
1098 let is_left = bx == 0; //(edge_state & 0x20) != 0;
1099
1100 let btype;
1101 if is_intra {
1102 btype = 0;
1103 } else {
1104 if (blk_state & 0x2000) != 0 {
1105 let val = br.read_code(UintCodeType::LimitedUnary(3, 1))?;
1106 match val {
1107 0 => {
1108 btype = btype_lru[0];
1109 },
1110 1 => {
1111 btype = btype_lru[1];
1112 btype_lru[1] = btype_lru[0];
1113 btype_lru[0] = btype;
1114 },
1115 2 => {
1116 btype = btype_lru[3];
1117 btype_lru[3] = btype_lru[2];
1118 btype_lru[2] = btype;
1119 },
1120 3 => {
1121 btype = btype_lru[2];
1122 btype_lru[2] = btype_lru[1];
1123 btype_lru[1] = btype;
1124 },
1125 _ => unreachable!(),
1126 };
1127 } else {
1128 btype = br.read(2)? as u8;
1129 }
1130 }
1131 if !is_intra {
1132 let q = self.qinfo.pred_quant(bx * 2, is_top);
1133 self.qinfo.set_quant(bx * 2, q);
1134 let q = self.qinfo.pred_quant(bx * 2 + 1, is_top);
1135 self.qinfo.set_quant(bx * 2 + 1, q);
1136 }
1137 match btype {
1138 0 => { // intra
1139 if (frame_flags & 0x2000) != 0 {
1140 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1141 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1142 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1143 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2, is_top))?;
1144 self.qinfo.set_quant(bx * 2, q);
1145 cbp_y = decode_luma_intra(br, &self.codes, cbp_y, q, &mut yblk, edge_state_y, &mut self.y_dcs, bx)?;
1146 cbp_v = decode_chroma_intra(br, &self.codes, cbp_v, q, &mut vblk, edge_state_c, &mut self.v_dcs, bx)?;
1147 cbp_u = decode_chroma_intra(br, &self.codes, cbp_u, q, &mut ublk, edge_state_c, &mut self.u_dcs, bx)?;
1148//if smth decode one more y
1149//if smth else decode one more y
1150 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1151 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1152 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1153 Bink2DSP::put_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1154 Bink2DSP::put_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1155 Bink2DSP::put_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1156 } else {
1157 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1158 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1159 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1160 cbp_y = decode_luma_intra_old(br, &self.codes, cbp_y, &mut yblk, edge_state_y, &mut self.y_dcs, bx, &mut q_y)?;
1161 cbp_v = decode_chroma_intra_old(br, &self.codes, cbp_v, &mut vblk, edge_state_c, &mut self.v_dcs, bx, &mut q_v)?;
1162 cbp_u = decode_chroma_intra_old(br, &self.codes, cbp_u, &mut ublk, edge_state_c, &mut self.u_dcs, bx, &mut q_u)?;
1163 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1164 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1165 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1166 Bink2DSP::put_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1167 Bink2DSP::put_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1168 Bink2DSP::put_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1169 }
1170 if !is_intra {
1171 self.mvs.predict_mvs(bx, is_top, is_left, (frame_flags & 0x2000) != 0);
1172 }
1173 },
1174 1 => { // skip
1175 if let Some(ref ref_pic) = self.ips.get_ref() {
1176 for blk_no in 0..4 {
1177 let xoff = bx * 32 + (blk_no & 1) * 16;
1178 let yoff = slice_no * bh * 32 + by * 32 + (blk_no & 2) * 8;
1179 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, ZERO_MV, 0)?;
1180 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 1)?;
1181 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, ZERO_MV, 2)?;
1182 }
1183 } else {
1184 return Err(DecoderError::MissingReference);
1185 }
1186 self.mvs.zero(bx);
1187 },
1188 2 => { // motion
1189 if (frame_flags & 0x2000) != 0 {
1190 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1191 } else {
1192 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1193 }
1194 if let Some(ref ref_pic) = self.ips.get_ref() {
1195 for blk_no in 0..4 {
1196 let xoff = bx * 32 + (blk_no & 1) * 16;
1197 let yoff = slice_no * bh * 32 + by * 32 + (blk_no & 2) * 8;
1198 let mv = self.mvs.get_mv(bx, blk_no);
1199 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1200 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1201 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1202 }
1203 } else {
1204 return Err(DecoderError::MissingReference);
1205 }
1206 },
1207 3 => { // inter
1208 if (frame_flags & 0x2000) != 0 {
1209 self.mvs.decode_mv_new(br, &self.codes.mv_cb, bx, is_top, is_left)?;
1210 } else {
1211 self.mvs.decode_mv_old(br, bx, is_top, is_left)?;
1212 }
1213 if let Some(ref ref_pic) = self.ips.get_ref() {
1214 for blk_no in 0..4 {
1215 let xoff = bx * 32 + (blk_no & 1) * 16;
1216 let yoff = slice_no * bh * 32 + by * 32 + (blk_no & 2) * 8;
1217 let mv = self.mvs.get_mv(bx, blk_no);
1218 Bink2DSP::mc_luma(&mut dst[off_y..], stride_y, ref_pic, xoff, yoff, mv, 0)?;
1219 Bink2DSP::mc_chroma(&mut dst[off_u..], stride_u, ref_pic, xoff >> 1, yoff >> 1, mv, 1)?;
1220 Bink2DSP::mc_chroma(&mut dst[off_v..], stride_v, ref_pic, xoff >> 1, yoff >> 1, mv, 2)?;
1221 }
1222 } else {
1223 return Err(DecoderError::MissingReference);
1224 }
1225 if (frame_flags & 0x2000) != 0 {
1226 let mut yblk: [[[i32; 64]; 4]; 4] = [[[0; 64]; 4]; 4];
1227 let mut ublk: [[i32; 64]; 4] = [[0; 64]; 4];
1228 let mut vblk: [[i32; 64]; 4] = [[0; 64]; 4];
1229 let q = get_new_quant(br, self.qinfo.pred_quant(bx * 2 + 1, is_top))?;
1230 self.qinfo.set_quant(bx * 2 + 1, q);
1231 cbp_y_p = decode_luma_inter(br, &self.codes, cbp_y_p, q, &mut yblk, edge_state_y, &mut self.y_dcs)?;
1232 if br.read_bool()? {
1233 cbp_v_p = decode_chroma_inter(br, &self.codes, cbp_v_p, q, &mut vblk, edge_state_y, &mut self.v_dcs)?;
1234 cbp_u_p = decode_chroma_inter(br, &self.codes, cbp_u_p, q, &mut ublk, edge_state_y, &mut self.u_dcs)?;
1235 } else {
1236 cbp_v_p = 0;
1237 cbp_u_p = 0;
1238 }
1239 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1240 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1241 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1242 Bink2DSP::add_mb4(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1243 Bink2DSP::add_mb4(dst, off_u + bx * 16, stride_u, &mut ublk);
1244 Bink2DSP::add_mb4(dst, off_v + bx * 16, stride_v, &mut vblk);
1245 } else {
1246 let mut yblk: [[[f32; 64]; 4]; 4] = [[[0.0; 64]; 4]; 4];
1247 let mut ublk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1248 let mut vblk: [[f32; 64]; 4] = [[0.0; 64]; 4];
1249 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)?;
1250 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)?;
1251 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)?;
1252 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 0 * stride_y, stride_y, &mut yblk[0]);
1253 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 0 * stride_y, stride_y, &mut yblk[1]);
1254 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 0 + 16 * stride_y, stride_y, &mut yblk[2]);
1255 Bink2DSP::add_mb4_old(dst, off_y + bx * 32 + 16 + 16 * stride_y, stride_y, &mut yblk[3]);
1256 Bink2DSP::add_mb4_old(dst, off_u + bx * 16, stride_u, &mut ublk);
1257 Bink2DSP::add_mb4_old(dst, off_v + bx * 16, stride_v, &mut vblk);
1258 }
1259 },
1260 _ => unreachable!(),
1261 };
1262 if btype != 0 {
1263 let src = &dst[off_y + bx * 32..];
1264 let dc5 = Bink2DSP::calc_dc(&src[24..], stride_y);
1265 let dc7 = Bink2DSP::calc_dc(&src[24 + stride_y * 8..], stride_y);
1266 let dc13 = Bink2DSP::calc_dc(&src[24 + stride_y * 16..], stride_y);
1267 let dc10 = Bink2DSP::calc_dc(&src[ 0 + stride_y * 24..], stride_y);
1268 let dc11 = Bink2DSP::calc_dc(&src[ 8 + stride_y * 24..], stride_y);
1269 let dc14 = Bink2DSP::calc_dc(&src[16 + stride_y * 24..], stride_y);
1270 let dc15 = Bink2DSP::calc_dc(&src[24 + stride_y * 24..], stride_y);
1271 self.y_dcs.set_dcs(bx, dc5, dc7, dc13, dc10, dc11, dc14, dc15);
1272 let src = &dst[off_u + bx * 16..];
1273 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_u);
1274 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_u * 8..], stride_u);
1275 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_u * 8..], stride_u);
1276 self.u_dcs.set_dcs(bx, dc1, dc2, dc3);
1277 let src = &dst[off_v + bx * 16..];
1278 let dc1 = Bink2DSP::calc_dc(&src[8..], stride_v);
1279 let dc2 = Bink2DSP::calc_dc(&src[0 + stride_v * 8..], stride_v);
1280 let dc3 = Bink2DSP::calc_dc(&src[8 + stride_v * 8..], stride_v);
1281 self.v_dcs.set_dcs(bx, dc1, dc2, dc3);
1282 }
1283 }
1284 self.qinfo.update_line();
1285 self.y_dcs.update_line();
1286 self.u_dcs.update_line();
1287 self.v_dcs.update_line();
1288 self.mvs.update_line();
1289 off_y += stride_y * 32;
1290 off_u += stride_u * 16;
1291 off_v += stride_v * 16;
1292 row_state = (row_state & !0x190) | ((row_state & 4) << 2);
1293 }
1294 }
1295 Ok(())
1296 }
1297}
1298
1299fn decode_flags(_br: &mut BitReader, _dst: &mut Vec<u8>, _start: usize, _nbits: usize) -> DecoderResult<u32> {
1300unimplemented!();
1301/* if !br.read_bool()? { // read bits into byte array?
1302 if nbits == 0 { return Ok(()); }
1303 if nbits < 9 {
1304 shift = in_shift;
1305 pfx = 0;
1306 } else {
1307 shift = in_shift;
1308 loop {
1309 pfx |= br.read(8)? << shift;
1310 dst.push((pfx & 0xFF) as u8);
1311 pfx >>= 8;
1312 shift -= 8;
1313 }
1314 }
1315 let val = br.read(cur_nbits)?;
1316 dst.push(pfx | (val << shift))
1317 } else {
1318 let mut cur_bits = nbits;
1319 let mut mode = 0;
1320 let mut lastbit = 0;
1321 while cur_bits > 0 {
1322 if !br.read_bool()? {
1323 lastbit = if mode == 3 { lastbit ^ 1 } else { br.read(1)? };
1324 let val1 = lastval | (lastbit << shift);
1325 let val2 = br.read(if cur_bits > 4 { 4 } else { cur_bits });
1326 let val = lastval | (lastbit << shift) | (val2 << (shift + 1));
1327 mode = 2;
1328 if oshift >= 8 {
1329 dst.push((val & 0xFF) as u8);
1330 oshift -= 8;
1331 val >>= 8;
1332 }
1333 lastval = val;
1334 } else {
1335 let bread;
1336 if cur_bits < 4 {
1337 bread = 2;
1338 } else if cur_bits < 16 {
1339 bread = 4;
1340 } else {
1341 bread = 4 | 1;
1342 }
1343 lastbit = if mode == 3 { lastbit ^ 1 } else { br.read(1)? };
1344 run = (if mode == 3 { bread + 1 } else { bread + 2 }).min(cur_bits);
1345 if run == cur_bits {
1346 output lastbit x run
1347 } else {
1348 let add_run = br.read(bread)? as usize;
1349 run += add_run;
1350 output lastbit x run
1351 mode = if add_run == (1 << bread) - 1 { 3 } else { 1 };
1352 }
1353 }
1354 }
1355 }
1356 Ok(())*/
1357}
1358
1359fn get_new_quant(br: &mut BitReader, prev_q: u8) -> DecoderResult<u8> {
1360 let mut code = br.read_code(UintCodeType::LimitedUnary(4, 1))? as u8;
1361 if code == 0 {
1362 Ok(prev_q)
1363 } else {
1364 if code == 3 {
1365 code += br.read(1)? as u8;
1366 } else if code == 4 {
1367 code = (br.read(5)? as u8) + 5;
1368 }
1369 let ret;
1370 if !br.read_bool()? {
1371 ret = prev_q.checked_add(code);
1372 } else {
1373 ret = prev_q.checked_sub(code);
1374 }
1375 validate!(ret.is_some());
1376 let val = ret.unwrap();
1377 validate!(val < (BINK2_QUANT_DC.len() as u8));
1378 Ok(val)
1379 }
1380}
1381
1382fn 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> {
1383 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1384 let _coded = dcinfo.decode_dcs(br, q)?;
1385 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1386 let dcs = &dcinfo.dcs;
1387 for i in 0..4 {
1388 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTRA_LUMA, q, cbp >> (i * 4))?;
1389 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j] * 8 + 32; }
1390 }
1391 Ok(cbp)
1392}
1393
1394fn 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> {
1395 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1396 let _coded = dcinfo.decode_dcs(br, q)?;
1397 dcinfo.predict(bx, (edge_state & 0x88) != 0, (edge_state & 0x20) != 0, 0, 0x7FF);
1398 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTRA_CHROMA, q, cbp)?;
1399 let dcs = &dcinfo.dcs;
1400 for i in 0..4 { dst[i][0] = dcs[i] * 8 + 32; }
1401 Ok(cbp)
1402}
1403
1404fn 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> {
1405 let cbp = decode_cbp_luma(br, prev_cbp, edge_state)?;
1406 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1407 let _coded = dcinfo.decode_dcs(br, q)?;
1408 dcinfo.predict_inter(min_dc, max_dc);
1409 let dcs = &dcinfo.dcs;
1410 for i in 0..4 {
1411 decode_acs_4blocks(br, codes, &mut dst[i], BINK2_QUANT_INTER, q, cbp >> (i * 4))?;
1412 for j in 0..4 { dst[i][j][0] = dcs[i * 4 + j]; }
1413 }
1414 Ok(cbp)
1415}
1416
1417fn 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> {
1418 let cbp = decode_cbp_chroma(br, prev_cbp)?;
1419 let (min_dc, max_dc) = if (edge_state & 0x40000) != 0 { (-0x7FF, 0x7FF) } else { (-0x3FF, 0x3FF) };
1420 let _coded = dcinfo.decode_dcs(br, q)?;
1421 dcinfo.predict_inter(min_dc, max_dc);
1422 let dcs = &dcinfo.dcs;
1423 decode_acs_4blocks(br, codes, dst, BINK2_QUANT_INTER, q, cbp)?;
1424 for i in 0..4 { dst[i][0] = dcs[i]; }
1425 Ok(cbp)
1426}
1427
1428fn decode_cbp_luma(br: &mut BitReader, prev_cbp: u32, edge_state: u32) -> DecoderResult<u32> {
1429 let cnt = (prev_cbp as u16).count_ones() as usize;
1430 let (min_count, mask) = if cnt < 8 { (cnt, 0x0000) } else { (16 - cnt, 0xFFFF) };
1431
1432 let mut cbp;
1433 if br.read_bool()? {
1434 cbp = 0;
1435 } else if min_count >= 4 {
1436 cbp = br.read(16)?;
1437 } else {
1438 cbp = 0;
1439 for i in 0..4 {
1440 if !br.read_bool()? {
1441 let cbp4 = br.read(4)?;
1442 cbp |= cbp4 << (i * 4);
1443 }
1444 }
1445 }
1446 cbp ^= mask;
1447 if ((edge_state & 0x40000) == 0) || (cbp != 0) {
1448 if br.read_bool()? {
1449 cbp |= cbp << 16;
1450 }
1451 }
1452 Ok(cbp)
1453}
1454fn decode_cbp_chroma(br: &mut BitReader, last_cbp: u32) -> DecoderResult<u32> {
1455 if br.read_bool()? {
1456 Ok((last_cbp & 0xF0000) | BINK2_CHROMA_CBPS[(last_cbp & 0xF) as usize])
1457 } else {
1458 let ncbp = br.read(4)?;
1459 if br.read_bool()? {
1460 Ok(ncbp | (ncbp << 16))
1461 } else {
1462 Ok(ncbp)
1463 }
1464 }
1465}
1466
1467trait ReadBink2Code {
1468 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32>;
1469 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32>;
1470}
1471
1472impl<'a> ReadBink2Code for BitReader<'a> {
1473 fn read_bink2_code_zero(&mut self) -> DecoderResult<i32> {
1474 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? as i32;
1475 if pfx > 0 {
1476 let val: i32;
1477 if pfx >= 4 {
1478 let add_bits = self.read((pfx as u8) - 3)? as i32;
1479 val = (1 << (pfx - 3)) + add_bits + 2;
1480 } else {
1481 val = pfx;
1482 }
1483 Ok(val)
1484 } else {
1485 Ok(0)
1486 }
1487 }
1488 fn read_bink2_code_nz(&mut self) -> DecoderResult<i32> {
1489 let pfx = self.read_code(UintCodeType::LimitedUnary(12, 0))? + 1;
1490 let val: i32;
1491 if pfx >= 4 {
1492 let add_bits = self.read((pfx as u8) - 3)? as i32;
1493 val = (1 << (pfx - 3)) + add_bits + 2;
1494 } else {
1495 val = pfx as i32;
1496 }
1497 if self.read_bool()? {
1498 Ok(-val)
1499 } else {
1500 Ok(val)
1501 }
1502 }
1503}
1504
1505fn decode_acs_4blocks(br: &mut BitReader, codes: &Bink2Codes, dst: &mut [[i32; 64]; 4], quant_mat: &[[i32; 64]; 4], q: u8, cbp: u32) -> DecoderResult<()> {
1506 let cb = if (cbp >> 16) != 0 { &codes.ac_cb1 } else { &codes.ac_cb2 };
1507 let qmat = &quant_mat[(q & 3) as usize];
1508 let shift = q >> 2;
1509 for blk_no in 0..4 {
1510 if ((cbp >> blk_no) & 1) == 0 { continue; }
1511 let mut esc_len = 0;
1512 let mut idx = 1;
1513 while idx < 64 {
1514 if esc_len >= 1 {
1515 esc_len -= 1;
1516 } else {
1517 let sym = br.read_cb(cb)?;
1518 let skip;
1519 if sym == 11 {
1520 skip = br.read(6)? as usize;
1521 } else {
1522 skip = BINK2_AC_RUNS[sym as usize];
1523 }
1524 idx += skip;
1525 if idx > 63 { break; }
1526 esc_len = if sym == 13 { 6 } else { 0 };
1527 }
1528 let level = br.read_bink2_code_nz()?;
1529 let pos = BINK2_ZIGZAG[idx];
1530 dst[blk_no][pos] = (((level * qmat[pos]) << shift) + 0x40) >> 7;
1531 idx += 1;
1532 }
1533// set blk info to (dc & 0x1FFF) | (intra ? 0x8000 : 0) | (((ncoded == 0) + (ncoded < 4) + (ncoded < 8)) << 13)
1534 }
1535 Ok(())
1536}
1537
1538fn 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> {
1539 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1540 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1541 *old_q = q;
1542 let is_top = (edge_state & 0x88) != 0;
1543 let is_left = (edge_state & 0x20) != 0;
1544 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1545 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1546 let dcs = &dcinfo.dcs;
1547 for i in 0..4 {
1548 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTRA_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1549 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1550 }
1551 Ok(cbp)
1552}
1553
1554fn 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> {
1555 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1556 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1557 *old_q = q;
1558 let is_top = (edge_state & 0x88) != 0;
1559 let is_left = (edge_state & 0x20) != 0;
1560 decode_dcs_old(br, &mut dcinfo.dc_buf, q, is_top && is_left)?;
1561 dcinfo.predict(bx, is_top, is_left, 0, 0x7FF);
1562 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1563 let dcs = &dcinfo.dcs;
1564 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1565 Ok(cbp)
1566}
1567
1568
1569fn 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> {
1570 let cbp = decode_cbp_luma_old(br, prev_cbp)?;
1571 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1572 *old_q = q;
1573 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1574 dcinfo.predict_inter(-1023, 1023);
1575 let dcs = &dcinfo.dcs;
1576 for i in 0..4 {
1577 decode_acs_4blocks_old(br, codes, &mut dst[i], BINK2_QMAT_INTER_LUMA_OLD, q, cbp >> (i * 4), BINK2_LUMA_SCAN_OLD)?;
1578 for j in 0..4 { dst[i][j][0] = (dcs[i * 4 + j] as f32) * 0.125; }
1579 }
1580 Ok(cbp)
1581}
1582
1583fn 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> {
1584 let cbp = decode_cbp_chroma_old(br, prev_cbp)?;
1585 let q = decode_quant_old(br, &codes.quant_cb, *old_q)?;
1586 *old_q = q;
1587 decode_dcs_old(br, &mut dcinfo.dc_buf, q, false)?;
1588 dcinfo.predict_inter(-1023, 1023);
1589 let dcs = &dcinfo.dcs;
1590 decode_acs_4blocks_old(br, codes, dst, BINK2_QMAT_CHROMA_OLD, q, cbp, BINK2_CHROMA_SCAN_OLD)?;
1591 for i in 0..4 { dst[i][0] = (dcs[i] as f32) * 0.125; }
1592 Ok(cbp)
1593}
1594
1595fn decode_quant_old(br: &mut BitReader, quant_cb: &Codebook<u8>, prev_quant: u8) -> DecoderResult<u8> {
1596 let diff = br.read_cb(quant_cb)?;
1597 if diff == 0 {
1598 Ok(prev_quant)
1599 } else {
1600 let res;
1601 if br.read_bool()? {
1602 res = prev_quant.checked_sub(diff);
1603 } else {
1604 res = prev_quant.checked_add(diff);
1605 }
1606 validate!(res.is_some());
1607 let q = res.unwrap();
1608 validate!(q < 16);
1609 Ok(q)
1610 }
1611}
1612
1613fn decode_cbp_luma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1614 let low;
1615 if br.read_bool()? {
1616 if br.read_bool()? {
1617 return Ok(prev_cbp);
1618 }
1619 low = prev_cbp & 0xFFFF;
1620 } else {
1621 let mut nib1 = (prev_cbp >> 4) & 0xF;
1622 if !br.read_bool()? {
1623 nib1 = br.read(4)?;
1624 }
1625 let mut new_cbp = nib1;
1626 if !br.read_bool()? {
1627 nib1 = br.read(4)?;
1628 }
1629 new_cbp = new_cbp | (nib1 << 4);
1630 if !br.read_bool()? {
1631 nib1 = br.read(4)?;
1632 }
1633 new_cbp = new_cbp | (nib1 << 8);
1634 if !br.read_bool()? {
1635 nib1 = br.read(4)?;
1636 }
1637 low = new_cbp | (nib1 << 12);
1638 }
1639 let mut nib_hi = (prev_cbp >> 20) & 0xF;
1640 let mut high = 0;
1641 for i in 0..4 {
1642 let nib = (low >> (4 * i)) & 0xF;
1643 if nib.count_ones() == 0 {
1644 nib_hi = 0;
1645 } else if (nib.count_ones() == 1) || !br.read_bool()? {
1646 nib_hi = 0;
1647 for bit in 0..4 {
1648 if (((nib >> bit) & 1) != 0) && br.read_bool()? {
1649 nib_hi |= 1 << bit;
1650 }
1651 }
1652 }
1653 nib_hi &= nib;
1654 high = (high >> 4) | (nib_hi << 28);
1655 }
1656 Ok(low | high)
1657}
1658
1659fn decode_cbp_chroma_old(br: &mut BitReader, prev_cbp: u32) -> DecoderResult<u32> {
1660 let low;
1661 if !br.read_bool()? {
1662 low = br.read(4)?;
1663 } else {
1664 if br.read_bool()? {
1665 return Ok(prev_cbp);
1666 }
1667 low = prev_cbp & 0xF;
1668 }
1669 let mut high;
1670 if low.count_ones() == 0 {
1671 return Ok(low);
1672 }
1673 if low.count_ones() != 1 {
1674 high = (prev_cbp >> 16) & low;
1675 if br.read_bool()? {
1676 return Ok((high << 16) | low);
1677 }
1678 }
1679 high = 0;
1680 for bit in 0..4 {
1681 if (((low >> bit) & 1) != 0) && br.read_bool()? {
1682 high |= 1 << bit;
1683 }
1684 }
1685 Ok((high << 16) | low)
1686}
1687
1688fn decode_dcs_old(br: &mut BitReader, dcs: &mut [i32], q: u8, read_bias: bool) -> DecoderResult<()> {
1689 let mut bits = br.read(3)? as u8;
1690 if bits == 7 {
1691 bits += br.read(2)? as u8;
1692 }
1693 let scale = BINK2_OLD_DC_QUANTS[q as usize];
1694 if bits == 0 {
1695 for el in dcs.iter_mut() { *el = 0; }
1696 } else {
1697 for dcb in dcs.chunks_mut(4) {
1698 for dc in dcb.iter_mut() {
1699 *dc = br.read(bits)? as i32;
1700 }
1701 for dc in dcb.iter_mut() {
1702 if *dc == 0 { continue; }
1703 *dc *= scale;
1704 if br.read_bool()? {
1705 *dc = -*dc;
1706 }
1707 }
1708 }
1709 }
1710 if read_bias {
1711 let add_bits = BINK2_DC_EXTRA_BITS[q as usize] + bits;
1712 if add_bits < 10 {
1713 let pfx = br.read(10 - add_bits)? as i32;
1714 let base_dc;
1715 if pfx > 0 {
1716 if br.read_bool()? {
1717 base_dc = -(pfx << bits);
1718 } else {
1719 base_dc = pfx << bits;
1720 }
1721 } else {
1722 base_dc = 0;
1723 }
1724 dcs[0] += base_dc * scale;
1725 }
1726 }
1727 Ok(())
1728}
1729
1730fn 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<()> {
1731 let quant = BINK2_OLD_QUANTS[q as usize];
1732 for blk_no in 0..4 {
1733 if ((cbp >> blk_no) & 1) == 0 { continue; }
1734 let val_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.val_cb2 } else { &codes.val_cb1 };
1735 let skip_cb = if ((cbp >> (16 + blk_no)) & 1) != 0 { &codes.skip_cb2 } else { &codes.skip_cb1 };
1736 let mut esc_len = 0;
1737 let mut idx = 1;
1738 while idx < 64 {
1739 let val = br.read_cb(val_cb)?;
1740 if val != 0 {
1741 let mut level;
1742 if val >= 4 {
1743 let add_bits = br.read(val - 3)? as i32;
1744 level = (1 << (val - 3)) + add_bits + 2;
1745 } else {
1746 level = val as i32;
1747 }
1748 if br.read_bool()? {
1749 level = -level;
1750 }
1751 let pos = scan[idx];
1752 dst[blk_no][pos] = (level as f32) * quant_mat[idx] * quant;
1753 }
1754 idx += 1;
1755 if idx >= 64 { break; }
1756 if esc_len >= 1 {
1757 esc_len -= 1;
1758 } else {
1759 let sym = br.read_cb(skip_cb)?;
1760 let skip;
1761 if sym == 11 {
1762 skip = br.read(6)? as usize;
1763 } else {
1764 skip = BINK2_AC_RUNS[sym as usize];
1765 }
1766 idx += skip;
1767 if idx > 63 { break; }
1768 esc_len = if sym == 13 { 6 } else { 0 };
1769 }
1770 }
1771 }
1772 Ok(())
1773}
1774
1775impl NADecoder for Bink2Decoder {
1776 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
1777 if let NACodecTypeInfo::Video(vinfo) = info.get_properties() {
1778 let w = vinfo.get_width();
1779 let h = vinfo.get_height();
1780
1781 let edata = info.get_extradata().unwrap();
1782 validate!(edata.len() >= 8);
1783
1784 let mut mr = MemoryReader::new_read(&edata);
1785 let mut br = ByteReader::new(&mut mr);
1786 let magic = br.read_u32be()?;
1787 let _flags = br.read_u32le()?;
1788
1789 self.version = magic;
1790
1791 let fmt;
1792 fmt = NAPixelFormaton::new(ColorModel::YUV(YUVSubmodel::YUVJ),
1793 Some(NAPixelChromaton::new(0, 0, false, 8, 0, 0, 1)),
1794 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 1, 1)),
1795 Some(NAPixelChromaton::new(1, 1, false, 8, 0, 2, 1)),
1796 None, None,
1797 0, 3);
1798 let myinfo = NACodecTypeInfo::Video(NAVideoInfo::new(w, h, false, fmt));
1799 self.info = Rc::new(NACodecInfo::new_ref(info.get_name(), myinfo, info.get_extradata()));
1800
1801 Ok(())
1802 } else {
1803 Err(DecoderError::InvalidData)
1804 }
1805 }
1806 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1807 let src = pkt.get_buffer();
1808
1809 let mut br = BitReader::new(&src, src.len(), BitReaderMode::LE);
1810
1811 let mut buf;
1812 self.key_frame = pkt.is_keyframe();
1813
1814 let bufret = alloc_video_buffer(self.info.get_properties().get_video_info().unwrap(), 4);
1815 if let Err(_) = bufret { return Err(DecoderError::InvalidData); }
1816 let bufinfo = bufret.unwrap();
1817 buf = bufinfo.get_vbuf().unwrap();
1818
1819 self.decode_frame_new(&mut br, &mut buf, pkt.is_keyframe())?;
1820 let bufinfo = NABufferType::Video(buf);
1821 self.ips.add_frame(bufinfo.get_vbuf().unwrap());
1822
1823 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), bufinfo);
1824 frm.set_frame_type(if self.key_frame { FrameType::I } else { FrameType::P });
1825 Ok(Rc::new(RefCell::new(frm)))
1826 }
1827}
606c448e
KS		 1828
1829pub fn get_decoder() -> Box<NADecoder> {
232deab9
KS		 1830 Box::new(Bink2Decoder::new())
1831}
1832
1833#[cfg(test)]
1834mod test {
1835 use nihav_core::codecs::RegisteredDecoders;
1836 use nihav_core::demuxers::RegisteredDemuxers;
1837 use nihav_core::test::dec_video::*;
1838 use crate::codecs::rad_register_all_codecs;
1839 use crate::demuxers::rad_register_all_demuxers;
1840 #[test]
1841 fn test_bink2() {
1842 let mut dmx_reg = RegisteredDemuxers::new();
1843 rad_register_all_demuxers(&mut dmx_reg);
1844 let mut dec_reg = RegisteredDecoders::new();
1845 rad_register_all_codecs(&mut dec_reg);
1846
1847 //let file = "assets/RAD/Open_Logos_partial.bik";
1848 //let file = "assets/RAD/sc13_01_partial.bk2";
1849 let file = "assets/RAD/ge_video_86l.bk2";
1850 //let file = "assets/RAD/eg_club_0.bk2";
68331a50 1851 test_file_decoding("bink", file, Some(8), true, false, None/*Some("bink2")*/, &dmx_reg, &dec_reg);
232deab9 1852 }
606c448e
KS		 1853}
1854
232deab9
KS		 1855const BINK2_ZIGZAG: [usize; 64] = [
1856 0, 8, 1, 2, 9, 16, 24, 17,
1857 10, 3, 4, 11, 18, 25, 32, 40,
1858 33, 26, 19, 12, 5, 6, 13, 20,
1859 27, 34, 41, 48, 56, 49, 42, 35,
1860 28, 21, 14, 7, 15, 22, 29, 36,
1861 43, 50, 57, 58, 51, 44, 37, 30,
1862 23, 31, 38, 45, 52, 59, 60, 53,
1863 46, 39, 47, 54, 61, 62, 55, 63
1864];
1865const BINK2_LUMA_SCAN_OLD: &[usize; 64] = &[
1866 0, 2, 1, 8, 9, 17, 10, 16,
1867 24, 3, 18, 25, 32, 11, 33, 26,
1868 4, 40, 19, 12, 27, 41, 34, 5,
1869 20, 48, 6, 28, 15, 42, 23, 35,
1870 21, 13, 14, 7, 31, 43, 49, 36,
1871 22, 56, 39, 50, 30, 44, 29, 51,
1872 57, 47, 58, 59, 63, 61, 55, 38,
1873 52, 62, 45, 37, 60, 46, 54, 53
1874];
1875const BINK2_CHROMA_SCAN_OLD: &[usize; 64] = &[
1876 0, 1, 8, 2, 9, 16, 10, 17,
1877 3, 24, 11, 18, 25, 13, 14, 4,
1878 15, 5, 6, 7, 12, 19, 20, 21,
1879 22, 23, 26, 27, 28, 29, 30, 31,
1880 32, 33, 34, 35, 36, 37, 38, 39,
1881 40, 41, 42, 43, 44, 45, 46, 47,
1882 48, 49, 50, 51, 52, 53, 54, 55,
1883 56, 57, 58, 59, 60, 61, 62, 63
1884];
1885
1886const BINK2_CHROMA_CBPS: [u32; 16] = [
1887 0x0, 0x0, 0x0, 0xF,
1888 0x0, 0xF, 0xF, 0xF,
1889 0x0, 0xF, 0xF, 0xF,
1890 0xF, 0xF, 0xF, 0xF
1891];
1892
1893const BINK2_QUANT_DC: [i32; 37] = [
1894 0x400, 0x4C2, 0x5A8, 0x6BA, 0x800, 0x983, 0xB50, 0xD74,
1895 0x1000, 0x1307, 0x16A1, 0x1AE9, 0x2000, 0x260E, 0x2D41, 0x35D1,
1896 0x4000, 0x4C1C, 0x5A82, 0x6BA3, 0x8000, 0x9838, 0xB505, 0xD745,
1897 0x10000, 0x13070, 0x16A0A, 0x1AE8A, 0x20000, 0x260E0, 0x2D414, 0x35D14,
1898 0x40000, 0x4C1C0, 0x5A828, 0x6BA28, 0x80000
1899];
1900
1901const BINK2_QUANT_INTRA_LUMA: &[[i32; 64]; 4] = &[
1902 [
1903 0x400, 0x598, 0x5E2, 0x49D, 0x733, 0x7E9, 0x1497, 0x2190,
1904 0x521, 0x685, 0x65E, 0x688, 0xA41, 0xD72, 0x1F57, 0x31FA,
1905 0x434, 0x6DB, 0x710, 0x79E, 0xF8C, 0x130B, 0x226D, 0x2E85,
1906 0x546, 0x74C, 0x84F, 0x7E0, 0x1275, 0x1162, 0x1E20, 0x25A5,
1907 0x99A, 0xC1F, 0x10CF, 0x10CF, 0x1B33, 0x1AB3, 0x2B47, 0x3435,
1908 0xD2F, 0x1648, 0x13BC, 0x17A1, 0x23EE, 0x1C40, 0x29E5, 0x266A,
1909 0x156E, 0x1D61, 0x1E75, 0x1BB3, 0x2B47, 0x2720, 0x34F7, 0x3270,
1910 0x1C6F, 0x1DE1, 0x1B6C, 0x17D1, 0x23E5, 0x2357, 0x3175, 0x35C8
1911 ], [
1912 0x4C2, 0x6A7, 0x6FF, 0x57D, 0x890, 0x968, 0x187C, 0x27EA,
1913 0x619, 0x7C1, 0x792, 0x7C4, 0xC32, 0xFFD, 0x2545, 0x3B6F,
1914 0x4FF, 0x827, 0x866, 0x90F, 0x127D, 0x16A6, 0x28F1, 0x3752,
1915 0x646, 0x8AE, 0x9E2, 0x95E, 0x15F3, 0x14AC, 0x23D3, 0x2CC4,
1916 0xB6B, 0xE6A, 0x13FD, 0x13FE, 0x2059, 0x1FC0, 0x3378, 0x3E16,
1917 0xFAE, 0x1A7F, 0x1778, 0x1C1A, 0x2ABA, 0x2198, 0x31D3, 0x2DAE,
1918 0x197C, 0x22F0, 0x2438, 0x20F1, 0x3378, 0x2E87, 0x3EFD, 0x3BFA,
1919 0x21D1, 0x2388, 0x209C, 0x1C52, 0x2AAF, 0x2A07, 0x3AD0, 0x3FF5
1920 ], [
1921 0x5A8, 0x7E9, 0x852, 0x687, 0xA2F, 0xB30, 0x1D1E, 0x2F77,
1922 0x740, 0x938, 0x901, 0x93C, 0xE81, 0x1303, 0x2C52, 0x46AE,
1923 0x5F1, 0x9B2, 0x9FD, 0xAC6, 0x15FC, 0x1AEE, 0x30B0, 0x41C9,
1924 0x775, 0xA52, 0xBC0, 0xB24, 0x1A1B, 0x1895, 0x2A9A, 0x353D,
1925 0xD94, 0x1124, 0x17C5, 0x17C6, 0x2677, 0x25C2, 0x3D34, 0x49D5,
1926 0x12A5, 0x1F82, 0x1BE9, 0x216B, 0x32CF, 0x27F3, 0x3B40, 0x3653,
1927 0x1E4E, 0x298D, 0x2B12, 0x272C, 0x3D34, 0x3755, 0x4AE7, 0x4753,
1928 0x2836, 0x2A41, 0x26C7, 0x21AE, 0x32C3, 0x31FA, 0x45F1, 0x4C0E
1929 ], [
1930 0x6BA, 0x968, 0x9E5, 0x7C3, 0xC1C, 0xD4E, 0x22A0, 0x3872,
1931 0x8A0, 0xAF7, 0xAB5, 0xAFB, 0x113F, 0x169C, 0x34B5, 0x540D,
1932 0x711, 0xB87, 0xBE1, 0xCD0, 0x1A25, 0x2007, 0x39E6, 0x4E3C,
1933 0x8DF, 0xC46, 0xDFA, 0xD3F, 0x1F0B, 0x1D3C, 0x32A9, 0x3F4F,
1934 0x1025, 0x1462, 0x1C44, 0x1C46, 0x2DBF, 0x2CE7, 0x48C9, 0x57CE,
1935 0x162D, 0x2578, 0x2131, 0x27BE, 0x3C6D, 0x2F82, 0x4676, 0x409A,
1936 0x240A, 0x3169, 0x3338, 0x2E96, 0x48C9, 0x41CD, 0x5914, 0x54D3,
1937 0x2FD2, 0x3240, 0x2E1E, 0x280E, 0x3C5E, 0x3B6F, 0x532D, 0x5A73
1938 ]
1939];
1940
1941const BINK2_QUANT_INTRA_CHROMA: &[[i32; 64]; 4] = &[
1942 [
1943 0x400, 0x4A9, 0x59A, 0x89B, 0x1600, 0x1221, 0x171C, 0x19A3,
1944 0x4A9, 0x656, 0x713, 0xE16, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
1945 0x59A, 0x713, 0xDBB, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
1946 0x89B, 0xE16, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
1947 0x1600, 0x19A3, 0x171C, 0x1221, 0x1600, 0x1221, 0x171C, 0x19A3,
1948 0x1221, 0x1520, 0x130B, 0xEF0, 0x1221, 0xEF0, 0x130B, 0x1520,
1949 0x171C, 0x1AEE, 0x1847, 0x130B, 0x171C, 0x130B, 0x1847, 0x1AEE,
1950 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1
1951 ], [
1952 0x4C2, 0x58B, 0x6AA, 0xA3C, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
1953 0x58B, 0x789, 0x869, 0x10C0, 0x1E7D, 0x1920, 0x2007, 0x2388,
1954 0x6AA, 0x869, 0x1054, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
1955 0xA3C, 0x10C0, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
1956 0x1A2A, 0x1E7D, 0x1B7B, 0x158F, 0x1A2A, 0x158F, 0x1B7B, 0x1E7D,
1957 0x158F, 0x1920, 0x16A6, 0x11C4, 0x158F, 0x11C4, 0x16A6, 0x1920,
1958 0x1B7B, 0x2007, 0x1CDE, 0x16A6, 0x1B7B, 0x16A6, 0x1CDE, 0x2007,
1959 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388
1960 ], [
1961 0x5A8, 0x698, 0x7EC, 0xC2C, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
1962 0x698, 0x8F6, 0xA01, 0x13EB, 0x2442, 0x1DE1, 0x2616, 0x2A41,
1963 0x7EC, 0xA01, 0x136B, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
1964 0xC2C, 0x13EB, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
1965 0x1F1D, 0x2442, 0x20AF, 0x19A3, 0x1F1D, 0x19A3, 0x20AF, 0x2442,
1966 0x19A3, 0x1DE1, 0x1AEE, 0x1520, 0x19A3, 0x1520, 0x1AEE, 0x1DE1,
1967 0x20AF, 0x2616, 0x2255, 0x1AEE, 0x20AF, 0x1AEE, 0x2255, 0x2616,
1968 0x2442, 0x2A41, 0x2616, 0x1DE1, 0x2442, 0x1DE1, 0x2616, 0x2A41
1969 ], [
1970 0x6BA, 0x7D7, 0x96C, 0xE7A, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
1971 0x7D7, 0xAA9, 0xBE5, 0x17B0, 0x2B1E, 0x2388, 0x2D4B, 0x3240,
1972 0x96C, 0xBE5, 0x1718, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
1973 0xE7A, 0x17B0, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
1974 0x2500, 0x2B1E, 0x26DE, 0x1E7D, 0x2500, 0x1E7D, 0x26DE, 0x2B1E,
1975 0x1E7D, 0x2388, 0x2007, 0x1920, 0x1E7D, 0x1920, 0x2007, 0x2388,
1976 0x26DE, 0x2D4B, 0x28D4, 0x2007, 0x26DE, 0x2007, 0x28D4, 0x2D4B,
1977 0x2B1E, 0x3240, 0x2D4B, 0x2388, 0x2B1E, 0x2388, 0x2D4B, 0x3240
1978 ]
1979];
1980
1981const BINK2_QUANT_INTER: &[[i32; 64]; 4] = &[
1982 [
1983 0x400, 0x4A9, 0x434, 0x34C, 0x41C, 0x392, 0x4C9, 0x5D4,
1984 0x4A9, 0x56F, 0x4E6, 0x3D7, 0x4CB, 0x429, 0x5B7, 0x718,
1985 0x434, 0x4E6, 0x489, 0x3A8, 0x4AB, 0x40A, 0x5A4, 0x6CD,
1986 0x34C, 0x3D7, 0x3A8, 0x32B, 0x41F, 0x39F, 0x519, 0x630,
1987 0x41C, 0x4CB, 0x4AB, 0x41F, 0x5AB, 0x538, 0x778, 0x932,
1988 0x392, 0x429, 0x40A, 0x39F, 0x538, 0x521, 0x799, 0x9B6,
1989 0x4C9, 0x5B7, 0x5A4, 0x519, 0x778, 0x799, 0xBE4, 0xFC7,
1990 0x5D4, 0x718, 0x6CD, 0x630, 0x932, 0x9B6, 0xFC7, 0x162F
1991 ], [
1992 0x4C2, 0x58B, 0x4FF, 0x3EB, 0x4E4, 0x43F, 0x5B1, 0x6EE,
1993 0x58B, 0x676, 0x5D3, 0x491, 0x5B3, 0x4F3, 0x6CB, 0x86F,
1994 0x4FF, 0x5D3, 0x565, 0x459, 0x58D, 0x4CE, 0x6B5, 0x816,
1995 0x3EB, 0x491, 0x459, 0x3C5, 0x4E6, 0x44F, 0x610, 0x75C,
1996 0x4E4, 0x5B3, 0x58D, 0x4E6, 0x6BD, 0x635, 0x8E2, 0xAEF,
1997 0x43F, 0x4F3, 0x4CE, 0x44F, 0x635, 0x61A, 0x909, 0xB8C,
1998 0x5B1, 0x6CB, 0x6B5, 0x610, 0x8E2, 0x909, 0xE24, 0x12C3,
1999 0x6EE, 0x86F, 0x816, 0x75C, 0xAEF, 0xB8C, 0x12C3, 0x1A61
2000 ], [
2001 0x5A8, 0x698, 0x5F1, 0x4A9, 0x5D0, 0x50D, 0x6C4, 0x83E,
2002 0x698, 0x7AF, 0x6ED, 0x56F, 0x6C7, 0x5E3, 0x814, 0xA08,
2003 0x5F1, 0x6ED, 0x66A, 0x52B, 0x69A, 0x5B6, 0x7FA, 0x99E,
2004 0x4A9, 0x56F, 0x52B, 0x47B, 0x5D4, 0x51F, 0x735, 0x8C1,
2005 0x5D0, 0x6C7, 0x69A, 0x5D4, 0x804, 0x761, 0xA90, 0xD00,
2006 0x50D, 0x5E3, 0x5B6, 0x51F, 0x761, 0x741, 0xABF, 0xDBB,
2007 0x6C4, 0x814, 0x7FA, 0x735, 0xA90, 0xABF, 0x10D2, 0x1650,
2008 0x83E, 0xA08, 0x99E, 0x8C1, 0xD00, 0xDBB, 0x1650, 0x1F5F
2009 ], [
2010 0x6BA, 0x7D7, 0x711, 0x58B, 0x6EA, 0x601, 0x80C, 0x9CD,
2011 0x7D7, 0x923, 0x83C, 0x676, 0x80F, 0x700, 0x99C, 0xBEE,
2012 0x711, 0x83C, 0x7A1, 0x626, 0x7DA, 0x6CB, 0x97C, 0xB70,
2013 0x58B, 0x676, 0x626, 0x554, 0x6EE, 0x617, 0x893, 0xA68,
2014 0x6EA, 0x80F, 0x7DA, 0x6EE, 0x988, 0x8C7, 0xC90, 0xF76,
2015 0x601, 0x700, 0x6CB, 0x617, 0x8C7, 0x8A1, 0xCC7, 0x1055,
2016 0x80C, 0x99C, 0x97C, 0x893, 0xC90, 0xCC7, 0x1400, 0x1A89,
2017 0x9CD, 0xBEE, 0xB70, 0xA68, 0xF76, 0x1055, 0x1A89, 0x254E
2018 ]
2019];
2020
2021const BINK2_AC_CODES1: &[u8] = &[
2022 0x01, 0x04, 0x00, 0x08, 0x02, 0x32, 0x0A, 0x12,
2023 0x3A, 0x7A, 0xFA, 0x72, 0x06, 0x1A
2024];
2025const BINK2_AC_BITS1: &[u8] = &[ 1, 3, 4, 4, 5, 7, 5, 6, 7, 8, 8, 7, 3, 6 ];
2026const BINK2_AC_CODES2: &[u16] = &[
2027 0x01, 0x00, 0x04, 0x2C, 0x6C, 0x0C, 0x4C, 0xAC,
2028 0xEC, 0x12C, 0x16C, 0x1AC, 0x02, 0x1C
2029];
2030const BINK2_AC_BITS2: &[u8] = &[ 1, 3, 4, 9, 9, 7, 7, 9, 8, 9, 9, 9, 2, 5 ];
2031
2032const BINK2_AC_RUNS: [usize; 14] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 64, 0 ];
2033
2034const BINK2_MV_CODES: &[u8] = &[
2035 0x01, 0x06, 0x0C, 0x1C, 0x18, 0x38, 0x58, 0x78,
2036 0x68, 0x48, 0x28, 0x08, 0x14, 0x04, 0x02, 0x00
2037];
2038const BINK2_MV_BITS: &[u8] = &[
2039 1, 3, 5, 5, 7, 7, 7, 7,
2040 7, 7, 7, 7, 5, 5, 3, 4
2041];
2042const BINK2_MV_ESC: i8 = 42;
2043const BINK2_MV_SYMS: &[i8] = &[
2044 0, 1, 2, 3, 4, 5, 6, 7,
2045 -7, -6, -5, -4, -3, -2, -1, BINK2_MV_ESC
2046];
2047
2048const BINK2_AC_VAL_CODES1: &[u16] = &[
2049 0x004, 0x01, 0x002, 0x00, 0x08, 0x18, 0xF8, 0x178,
2050 0x138, 0x38, 0x1B8, 0x78, 0xB8
2051];
2052const BINK2_AC_VAL_BITS1: &[u8] = &[ 3, 1, 2, 4, 5, 6, 8, 9, 9, 9, 9, 9, 9 ];
2053const BINK2_AC_VAL_CODES2: &[u16] = &[
2054 0x0A, 0x001, 0x004, 0x08, 0x06, 0x00, 0x02, 0x1A,
2055 0x2A, 0x16A, 0x1EA, 0x6A, 0xEA
2056];
2057const BINK2_AC_VAL_BITS2: &[u8] = &[ 6, 1, 3, 4, 3, 4, 4, 5, 7, 9, 9, 9, 9 ];
2058const BINK2_AC_SKIP_CODES1: &[u16] = &[
2059 0x00, 0x001, 0x0D, 0x15, 0x45, 0x85, 0xA5, 0x165,
2060 0x65, 0x1E5, 0xE5, 0x25, 0x03, 0x05
2061];
2062const BINK2_AC_SKIP_BITS1: &[u8] = &[ 1, 3, 4, 5, 7, 8, 8, 9, 9, 9, 9, 8, 2, 8 ];
2063const BINK2_AC_SKIP_CODES2: &[u16] = &[
2064 0x00, 0x01, 0x003, 0x07, 0x1F, 0x1B, 0x0F, 0x2F,
2065 0x5B, 0xDB, 0x1DB, 0x3B, 0x05, 0x0B
2066];
2067const BINK2_AC_SKIP_BITS2: &[u8] = &[ 1, 3, 4, 4, 5, 7, 6, 6, 8, 9, 9, 6, 3, 5 ];
2068const BINK2_QUANT_CODES: &[u8] = &[
2069 0x01, 0x02, 0x04, 0x08, 0x10, 0x30, 0x50, 0x70,
2070 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0
2071];
2072const BINK2_QUANT_BITS: &[u8] = &[ 1, 2, 3, 4, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8 ];
2073
2074const BINK2_OLD_QUANTS: [f32; 16] = [
2075 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
2076];
2077const BINK2_OLD_DC_QUANTS: [i32; 16] = [
2078 4, 4, 4, 4, 4, 6, 7, 8, 10, 12, 16, 24, 32, 48, 64, 128
2079];
2080const BINK2_DC_EXTRA_BITS: [u8; 16] = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 6 ];
2081const BINK2_QMAT_INTRA_LUMA_OLD: &[f32; 64] = &[
2082 0.125, 0.208056, 0.22864901, 0.205778, 0.22499999, 0.235708, 0.33148301, 0.248309,
2083 0.190718, 0.288582, 0.29449099, 0.34658501, 0.38143599, 0.47678301, 0.600528, 0.44008601,
2084 0.16332, 0.31714499, 0.34142101, 0.42249799, 0.604285, 0.70576, 0.68942899, 0.42807001,
2085 0.235175, 0.38735899, 0.46090701, 0.50122303, 0.82311302, 0.73910397, 0.69206202, 0.39741901,
2086 0.30000001, 0.45078799, 0.65328097, 0.74962097, 0.85000002, 0.79551601, 0.69678998, 0.38625899,
2087 0.392847, 0.79009801, 0.73142397, 1.004719, 1.070509, 0.80251199, 0.64313799, 0.27096599,
2088 0.34501299, 0.56299502, 0.60987997, 0.636379, 0.69678998, 0.60061598, 0.43934, 0.19224399,
2089 0.210373, 0.26309499, 0.252336, 0.25142801, 0.265553, 0.24928901, 0.188511, 0.094199002
2090];
2091const BINK2_QMAT_CHROMA_OLD: &[f32; 64] = &[
2092 0.125, 0.17338, 0.217761, 0.383793, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2093 0.17338, 0.28056601, 0.32721299, 0.74753499, 0.95358998, 0.74923098, 0.51607901, 0.26309499,
2094 0.217761, 0.32721299, 0.66387498, 1.056244, 0.89826202, 0.70576, 0.48613599, 0.24783,
2095 0.383793, 0.74753499, 1.056244, 0.95059502, 0.80841398, 0.635167, 0.437511, 0.223041,
2096 0.6875, 0.95358998, 0.89826202, 0.80841398, 0.6875, 0.54016501, 0.37207201, 0.18968099,
2097 0.54016501, 0.74923098, 0.70576, 0.635167, 0.54016501, 0.42440501, 0.292335, 0.149031,
2098 0.37207201, 0.51607901, 0.48613599, 0.437511, 0.37207201, 0.292335, 0.201364, 0.102655,
2099 0.18968099, 0.26309499, 0.24783, 0.223041, 0.18968099, 0.149031, 0.102655, 0.052333001
2100];
2101const BINK2_QMAT_INTER_LUMA_OLD: &[f32; 64] = &[
2102 0.125, 0.17338, 0.16332, 0.146984, 0.128475, 0.106393, 0.077045999, 0.043109,
2103 0.17338, 0.240485, 0.226532, 0.20387299, 0.17820001, 0.147571, 0.109474, 0.062454,
2104 0.16332, 0.226532, 0.219321, 0.202722, 0.181465, 0.149711, 0.112943, 0.062583998,
2105 0.146984, 0.20387299, 0.202722, 0.201647, 0.183731, 0.15397599, 0.11711, 0.065334998,
2106 0.128475, 0.17820001, 0.181465, 0.183731, 0.17708801, 0.155499, 0.120267, 0.068016,
2107 0.106393, 0.147571, 0.149711, 0.15397599, 0.155499, 0.14575601, 0.116636, 0.068494998,
2108 0.077045999, 0.109474, 0.112943, 0.11711, 0.120267, 0.116636, 0.098646, 0.060141001,
2109 0.043109, 0.062454, 0.062583998, 0.065334998, 0.068016, 0.068494998, 0.060141001, 0.038853001
2110];
NihAV is a research multimedia framework