1 use frame::NAVideoBuffer;
2 use super::{BlockDSP, CBPInfo, MV};
3 use super::super::blockdsp;
4 //use super::h263data::*;
6 /*const W1: i32 = 22725;
10 const W5: i32 = 12873;
14 const ROW_SHIFT: u8 = 11;
15 const COL_SHIFT: u8 = 20;
17 fn idct_row(row: &mut [i16]) {
18 let in0 = row[0] as i32;
19 let in1 = row[1] as i32;
20 let in2 = row[2] as i32;
21 let in3 = row[3] as i32;
22 let in4 = row[4] as i32;
23 let in5 = row[5] as i32;
24 let in6 = row[6] as i32;
25 let in7 = row[7] as i32;
27 let mut a0 = in0 * W1 + (1 << (ROW_SHIFT - 1));
37 let mut b0 = W1 * in1 + W3 * in3;
38 let mut b1 = W3 * in1 - W7 * in3;
39 let mut b2 = W5 * in1 - W1 * in3;
40 let mut b3 = W7 * in1 - W5 * in3;
42 a0 += W4 * in4 + W6 * in6;
43 a1 -= W4 * in4 + W2 * in6;
44 a2 -= W4 * in4 - W2 * in6;
45 a3 += W4 * in4 - W6 * in6;
47 b0 += W5 * in5 + W7 * in7;
48 b1 -= W1 * in5 + W5 * in7;
49 b2 += W7 * in5 + W3 * in7;
50 b3 += W3 * in5 - W1 * in7;
52 row[0] = ((a0 + b0) >> ROW_SHIFT) as i16;
53 row[7] = ((a0 - b0) >> ROW_SHIFT) as i16;
54 row[1] = ((a1 + b1) >> ROW_SHIFT) as i16;
55 row[6] = ((a1 - b1) >> ROW_SHIFT) as i16;
56 row[2] = ((a2 + b2) >> ROW_SHIFT) as i16;
57 row[5] = ((a2 - b2) >> ROW_SHIFT) as i16;
58 row[3] = ((a3 + b3) >> ROW_SHIFT) as i16;
59 row[4] = ((a3 - b3) >> ROW_SHIFT) as i16;
62 fn idct_col(blk: &mut [i16; 64], off: usize) {
63 let in0 = blk[off + 0*8] as i32;
64 let in1 = blk[off + 1*8] as i32;
65 let in2 = blk[off + 2*8] as i32;
66 let in3 = blk[off + 3*8] as i32;
67 let in4 = blk[off + 4*8] as i32;
68 let in5 = blk[off + 5*8] as i32;
69 let in6 = blk[off + 6*8] as i32;
70 let in7 = blk[off + 7*8] as i32;
72 let mut a0 = in0 * W1 + (1 << (COL_SHIFT - 1));
82 let mut b0 = W1 * in1 + W3 * in3;
83 let mut b1 = W3 * in1 - W7 * in3;
84 let mut b2 = W5 * in1 - W1 * in3;
85 let mut b3 = W7 * in1 - W5 * in3;
87 a0 += W4 * in4 + W6 * in6;
88 a1 -= W4 * in4 + W2 * in6;
89 a2 -= W4 * in4 - W2 * in6;
90 a3 += W4 * in4 - W6 * in6;
92 b0 += W5 * in5 + W7 * in7;
93 b1 -= W1 * in5 + W5 * in7;
94 b2 += W7 * in5 + W3 * in7;
95 b3 += W3 * in5 - W1 * in7;
97 blk[off + 0*8] = ((a0 + b0) >> COL_SHIFT) as i16;
98 blk[off + 7*8] = ((a0 - b0) >> COL_SHIFT) as i16;
99 blk[off + 1*8] = ((a1 + b1) >> COL_SHIFT) as i16;
100 blk[off + 6*8] = ((a1 - b1) >> COL_SHIFT) as i16;
101 blk[off + 2*8] = ((a2 + b2) >> COL_SHIFT) as i16;
102 blk[off + 5*8] = ((a2 - b2) >> COL_SHIFT) as i16;
103 blk[off + 3*8] = ((a3 + b3) >> COL_SHIFT) as i16;
104 blk[off + 4*8] = ((a3 - b3) >> COL_SHIFT) as i16;
108 pub fn h263_idct(blk: &mut [i16; 64]) {
109 for i in 0..8 { idct_row(&mut blk[i*8..(i+1)*8]); }
110 for i in 0..8 { idct_col(blk, i); }
113 const W1: i32 = 2841;
114 const W2: i32 = 2676;
115 const W3: i32 = 2408;
116 const W5: i32 = 1609;
117 const W6: i32 = 1108;
121 const ROW_SHIFT: u8 = 8;
122 const COL_SHIFT: u8 = 14;
124 fn idct_row(row: &mut [i16]) {
125 let in0 = ((row[0] as i32) << 11) + (1 << (ROW_SHIFT - 1));
126 let in1 = (row[4] as i32) << 11;
127 let in2 = row[6] as i32;
128 let in3 = row[2] as i32;
129 let in4 = row[1] as i32;
130 let in5 = row[7] as i32;
131 let in6 = row[5] as i32;
132 let in7 = row[3] as i32;
134 let tmp = W7 * (in4 + in5);
135 let a4 = tmp + (W1 - W7) * in4;
136 let a5 = tmp - (W1 + W7) * in5;
138 let tmp = W3 * (in6 + in7);
139 let a6 = tmp - (W3 - W5) * in6;
140 let a7 = tmp - (W3 + W5) * in7;
145 let t1 = W6 * (in2 + in3);
146 let a2 = t1 - (W2 + W6) * in2;
147 let a3 = t1 + (W2 - W6) * in3;
157 let b2 = (W8 * (b4 + t2) + 128) >> 8;
158 let b4 = (W8 * (b4 - t2) + 128) >> 8;
160 row[0] = ((b7 + b1) >> ROW_SHIFT) as i16;
161 row[7] = ((b7 - b1) >> ROW_SHIFT) as i16;
162 row[1] = ((b3 + b2) >> ROW_SHIFT) as i16;
163 row[6] = ((b3 - b2) >> ROW_SHIFT) as i16;
164 row[2] = ((b0 + b4) >> ROW_SHIFT) as i16;
165 row[5] = ((b0 - b4) >> ROW_SHIFT) as i16;
166 row[3] = ((b5 + b6) >> ROW_SHIFT) as i16;
167 row[4] = ((b5 - b6) >> ROW_SHIFT) as i16;
170 fn idct_col(blk: &mut [i16; 64], off: usize) {
171 let in0 = ((blk[off + 0*8] as i32) << 8) + (1 << (COL_SHIFT - 1));
172 let in1 = (blk[off + 4*8] as i32) << 8;
173 let in2 = blk[off + 6*8] as i32;
174 let in3 = blk[off + 2*8] as i32;
175 let in4 = blk[off + 1*8] as i32;
176 let in5 = blk[off + 7*8] as i32;
177 let in6 = blk[off + 5*8] as i32;
178 let in7 = blk[off + 3*8] as i32;
180 let tmp = W7 * (in4 + in5);
181 let a4 = (tmp + (W1 - W7) * in4) >> 3;
182 let a5 = (tmp - (W1 + W7) * in5) >> 3;
184 let tmp = W3 * (in6 + in7);
185 let a6 = (tmp - (W3 - W5) * in6) >> 3;
186 let a7 = (tmp - (W3 + W5) * in7) >> 3;
191 let t1 = W6 * (in2 + in3);
192 let a2 = (t1 - (W2 + W6) * in2) >> 3;
193 let a3 = (t1 + (W2 - W6) * in3) >> 3;
203 let b2 = (W8 * (b4 + t2) + 128) >> 8;
204 let b4 = (W8 * (b4 - t2) + 128) >> 8;
206 blk[off + 0*8] = ((b7 + b1) >> COL_SHIFT) as i16;
207 blk[off + 7*8] = ((b7 - b1) >> COL_SHIFT) as i16;
208 blk[off + 1*8] = ((b3 + b2) >> COL_SHIFT) as i16;
209 blk[off + 6*8] = ((b3 - b2) >> COL_SHIFT) as i16;
210 blk[off + 2*8] = ((b0 + b4) >> COL_SHIFT) as i16;
211 blk[off + 5*8] = ((b0 - b4) >> COL_SHIFT) as i16;
212 blk[off + 3*8] = ((b5 + b6) >> COL_SHIFT) as i16;
213 blk[off + 4*8] = ((b5 - b6) >> COL_SHIFT) as i16;
217 pub fn h263_idct(blk: &mut [i16; 64]) {
218 for i in 0..8 { idct_row(&mut blk[i*8..(i+1)*8]); }
219 for i in 0..8 { idct_col(blk, i); }
222 fn h263_interp00(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
227 for x in 0..bw { dst[didx + x] = src[sidx + x]; }
233 fn h263_interp01(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
238 for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + 1] as u16) + 1) >> 1) as u8; }
244 fn h263_interp10(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
249 for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + sstride] as u16) + 1) >> 1) as u8; }
255 fn h263_interp11(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
261 dst[didx + x] = (((src[sidx + x] as u16) +
262 (src[sidx + x + 1] as u16) +
263 (src[sidx + x + sstride] as u16) +
264 (src[sidx + x + sstride + 1] as u16) + 2) >> 2) as u8;
271 pub const H263_INTERP_FUNCS: &[fn(&mut [u8], usize, &[u8], usize, usize, usize)] = &[
272 h263_interp00, h263_interp01, h263_interp10, h263_interp11 ];
274 fn h263_interp00_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
280 let a = dst[didx + x] as u16;
281 let b = src[sidx + x] as u16;
282 dst[didx + x] = ((a + b + 1) >> 1) as u8;
289 fn h263_interp01_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
295 let a = dst[didx + x] as u16;
296 let b = ((src[sidx + x] as u16) + (src[sidx + x + 1] as u16) + 1) >> 1;
297 dst[didx + x] = ((a + b + 1) >> 1) as u8;
304 fn h263_interp10_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
310 let a = dst[didx + x] as u16;
311 let b = ((src[sidx + x] as u16) + (src[sidx + x + sstride] as u16) + 1) >> 1;
312 dst[didx + x] = ((a + b + 1) >> 1) as u8;
319 fn h263_interp11_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize)
325 let a = dst[didx + x] as u16;
326 let b = ((src[sidx + x] as u16) +
327 (src[sidx + x + 1] as u16) +
328 (src[sidx + x + sstride] as u16) +
329 (src[sidx + x + sstride + 1] as u16) + 2) >> 2;
330 dst[didx + x] = ((a + b + 1) >> 1) as u8;
337 pub const H263_INTERP_AVG_FUNCS: &[fn(&mut [u8], usize, &[u8], usize, usize, usize)] = &[
338 h263_interp00_avg, h263_interp01_avg, h263_interp10_avg, h263_interp11_avg ];
340 pub struct H263BlockDSP { }
343 pub fn new() -> Self {
348 fn deblock_hor(buf: &mut NAVideoBuffer<u8>, comp: usize, q: u8, off: usize) {
349 let stride = buf.get_stride(comp);
350 let mut dptr = buf.get_data_mut();
351 let mut buf = dptr.as_mut_slice();
353 let a = buf[off - 2 * stride + x] as i16;
354 let b = buf[off - 1 * stride + x] as i16;
355 let c = buf[off + 0 * stride + x] as i16;
356 let d = buf[off + 1 * stride + x] as i16;
357 let diff = ((a - d) * 3 + (c - b) * 8) >> 4;
358 if (diff != 0) && (diff >= -32) && (diff < 32) {
359 let d0 = diff.abs() * 2 - (q as i16);
360 let d1 = if d0 < 0 { 0 } else { d0 };
361 let d2 = diff.abs() - d1;
362 let d3 = if d2 < 0 { 0 } else { d2 };
364 let delta = if diff < 0 { -d3 } else { d3 };
367 if b1 < 0 { buf[off - 1 * stride + x] = 0; }
368 else if b1 > 255 { buf[off - 1 * stride + x] = 0xFF; }
369 else { buf[off - 1 * stride + x] = b1 as u8; }
371 if c1 < 0 { buf[off + x] = 0; }
372 else if c1 > 255 { buf[off + x] = 0xFF; }
373 else { buf[off + x] = c1 as u8; }
378 fn deblock_ver(buf: &mut NAVideoBuffer<u8>, comp: usize, q: u8, off: usize) {
379 let stride = buf.get_stride(comp);
380 let mut dptr = buf.get_data_mut();
381 let mut buf = dptr.as_mut_slice();
383 let a = buf[off - 2 + y * stride] as i16;
384 let b = buf[off - 1 + y * stride] as i16;
385 let c = buf[off + 0 + y * stride] as i16;
386 let d = buf[off + 1 + y * stride] as i16;
387 let diff = ((a - d) * 3 + (c - b) * 8) >> 4;
388 if (diff != 0) && (diff >= -32) && (diff < 32) {
389 let d0 = diff.abs() * 2 - (q as i16);
390 let d1 = if d0 < 0 { 0 } else { d0 };
391 let d2 = diff.abs() - d1;
392 let d3 = if d2 < 0 { 0 } else { d2 };
394 let delta = if diff < 0 { -d3 } else { d3 };
397 if b1 < 0 { buf[off - 1 + y * stride] = 0; }
398 else if b1 > 255 { buf[off - 1 + y * stride] = 0xFF; }
399 else { buf[off - 1 + y * stride] = b1 as u8; }
401 if c1 < 0 { buf[off + y * stride] = 0; }
402 else if c1 > 255 { buf[off + y * stride] = 0xFF; }
403 else { buf[off + y * stride] = c1 as u8; }
408 pub fn h263_filter_row(buf: &mut NAVideoBuffer<u8>, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) {
409 let stride = buf.get_stride(0);
410 let mut off = buf.get_offset(0) + mb_y * 16 * stride;
411 for mb_x in 0..mb_w {
413 let coded0 = cbpi.is_coded(mb_x, 0);
414 let coded1 = cbpi.is_coded(mb_x, 1);
415 let q = cbpi.get_q(mb_w + mb_x);
417 if coded0 && cbpi.is_coded_top(mb_x, 0) { deblock_hor(buf, 0, q, coff); }
418 if coded1 && cbpi.is_coded_top(mb_x, 1) { deblock_hor(buf, 0, q, coff + 8); }
420 let coff = off + 8 * stride;
421 if cbpi.is_coded(mb_x, 2) && coded0 { deblock_hor(buf, 0, q, coff); }
422 if cbpi.is_coded(mb_x, 3) && coded1 { deblock_hor(buf, 0, q, coff + 8); }
425 let mut leftt = false;
426 let mut leftc = false;
427 let mut off = buf.get_offset(0) + mb_y * 16 * stride;
428 for mb_x in 0..mb_w {
429 let ctop0 = cbpi.is_coded_top(mb_x, 0);
430 let ctop1 = cbpi.is_coded_top(mb_x, 0);
431 let ccur0 = cbpi.is_coded(mb_x, 0);
432 let ccur1 = cbpi.is_coded(mb_x, 1);
433 let q = cbpi.get_q(mb_w + mb_x);
435 let coff = off - 8 * stride;
436 let qtop = cbpi.get_q(mb_x);
437 if leftt && ctop0 { deblock_ver(buf, 0, qtop, coff); }
438 if ctop0 && ctop1 { deblock_ver(buf, 0, qtop, coff + 8); }
440 if leftc && ccur0 { deblock_ver(buf, 0, q, off); }
441 if ccur0 && ccur1 { deblock_ver(buf, 0, q, off + 8); }
446 let strideu = buf.get_stride(1);
447 let stridev = buf.get_stride(2);
448 let offu = buf.get_offset(1) + mb_y * 8 * strideu;
449 let offv = buf.get_offset(2) + mb_y * 8 * stridev;
451 for mb_x in 0..mb_w {
452 let ctu = cbpi.is_coded_top(mb_x, 4);
453 let ccu = cbpi.is_coded(mb_x, 4);
454 let ctv = cbpi.is_coded_top(mb_x, 5);
455 let ccv = cbpi.is_coded(mb_x, 5);
456 let q = cbpi.get_q(mb_w + mb_x);
457 if ctu && ccu { deblock_hor(buf, 1, q, offu + mb_x * 8); }
458 if ctv && ccv { deblock_hor(buf, 2, q, offv + mb_x * 8); }
460 let mut leftu = false;
461 let mut leftv = false;
462 let offu = buf.get_offset(1) + (mb_y - 1) * 8 * strideu;
463 let offv = buf.get_offset(2) + (mb_y - 1) * 8 * stridev;
464 for mb_x in 0..mb_w {
465 let ctu = cbpi.is_coded_top(mb_x, 4);
466 let ctv = cbpi.is_coded_top(mb_x, 5);
467 let qt = cbpi.get_q(mb_x);
468 if leftu && ctu { deblock_ver(buf, 1, qt, offu + mb_x * 8); }
469 if leftv && ctv { deblock_ver(buf, 2, qt, offv + mb_x * 8); }
476 impl BlockDSP for H263BlockDSP {
477 fn idct(&self, blk: &mut [i16; 64]) {
480 fn copy_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: &NAVideoBuffer<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
481 let srcx = ((mv.x >> 1) as isize) + (xpos as isize);
482 let srcy = ((mv.y >> 1) as isize) + (ypos as isize);
483 let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
485 blockdsp::copy_blocks(dst, src, xpos, ypos, srcx, srcy, w, h, 0, 1, mode, H263_INTERP_FUNCS);
487 fn avg_blocks(&self, dst: &mut NAVideoBuffer<u8>, src: &NAVideoBuffer<u8>, xpos: usize, ypos: usize, w: usize, h: usize, mv: MV) {
488 let srcx = ((mv.x >> 1) as isize) + (xpos as isize);
489 let srcy = ((mv.y >> 1) as isize) + (ypos as isize);
490 let mode = ((mv.x & 1) + (mv.y & 1) * 2) as usize;
492 blockdsp::copy_blocks(dst, src, xpos, ypos, srcx, srcy, w, h, 0, 1, mode, H263_INTERP_AVG_FUNCS);
494 fn filter_row(&self, buf: &mut NAVideoBuffer<u8>, mb_y: usize, mb_w: usize, cbpi: &CBPInfo) {
495 h263_filter_row(buf, mb_y, mb_w, cbpi)