| 1 | //use super::h263data::*; |
| 2 | |
| 3 | /*const W1: i32 = 22725; |
| 4 | const W2: i32 = 21407; |
| 5 | const W3: i32 = 19266; |
| 6 | const W4: i32 = 16383; |
| 7 | const W5: i32 = 12873; |
| 8 | const W6: i32 = 8867; |
| 9 | const W7: i32 = 4520; |
| 10 | |
| 11 | const ROW_SHIFT: u8 = 11; |
| 12 | const COL_SHIFT: u8 = 20; |
| 13 | |
| 14 | fn idct_row(row: &mut [i16]) { |
| 15 | let in0 = row[0] as i32; |
| 16 | let in1 = row[1] as i32; |
| 17 | let in2 = row[2] as i32; |
| 18 | let in3 = row[3] as i32; |
| 19 | let in4 = row[4] as i32; |
| 20 | let in5 = row[5] as i32; |
| 21 | let in6 = row[6] as i32; |
| 22 | let in7 = row[7] as i32; |
| 23 | |
| 24 | let mut a0 = in0 * W1 + (1 << (ROW_SHIFT - 1)); |
| 25 | let mut a1 = a0; |
| 26 | let mut a2 = a0; |
| 27 | let mut a3 = a0; |
| 28 | |
| 29 | a0 += W2 * in2; |
| 30 | a1 += W6 * in2; |
| 31 | a2 -= W6 * in2; |
| 32 | a3 -= W2 * in2; |
| 33 | |
| 34 | let mut b0 = W1 * in1 + W3 * in3; |
| 35 | let mut b1 = W3 * in1 - W7 * in3; |
| 36 | let mut b2 = W5 * in1 - W1 * in3; |
| 37 | let mut b3 = W7 * in1 - W5 * in3; |
| 38 | |
| 39 | a0 += W4 * in4 + W6 * in6; |
| 40 | a1 -= W4 * in4 + W2 * in6; |
| 41 | a2 -= W4 * in4 - W2 * in6; |
| 42 | a3 += W4 * in4 - W6 * in6; |
| 43 | |
| 44 | b0 += W5 * in5 + W7 * in7; |
| 45 | b1 -= W1 * in5 + W5 * in7; |
| 46 | b2 += W7 * in5 + W3 * in7; |
| 47 | b3 += W3 * in5 - W1 * in7; |
| 48 | |
| 49 | row[0] = ((a0 + b0) >> ROW_SHIFT) as i16; |
| 50 | row[7] = ((a0 - b0) >> ROW_SHIFT) as i16; |
| 51 | row[1] = ((a1 + b1) >> ROW_SHIFT) as i16; |
| 52 | row[6] = ((a1 - b1) >> ROW_SHIFT) as i16; |
| 53 | row[2] = ((a2 + b2) >> ROW_SHIFT) as i16; |
| 54 | row[5] = ((a2 - b2) >> ROW_SHIFT) as i16; |
| 55 | row[3] = ((a3 + b3) >> ROW_SHIFT) as i16; |
| 56 | row[4] = ((a3 - b3) >> ROW_SHIFT) as i16; |
| 57 | } |
| 58 | |
| 59 | fn idct_col(blk: &mut [i16; 64], off: usize) { |
| 60 | let in0 = blk[off + 0*8] as i32; |
| 61 | let in1 = blk[off + 1*8] as i32; |
| 62 | let in2 = blk[off + 2*8] as i32; |
| 63 | let in3 = blk[off + 3*8] as i32; |
| 64 | let in4 = blk[off + 4*8] as i32; |
| 65 | let in5 = blk[off + 5*8] as i32; |
| 66 | let in6 = blk[off + 6*8] as i32; |
| 67 | let in7 = blk[off + 7*8] as i32; |
| 68 | |
| 69 | let mut a0 = in0 * W1 + (1 << (COL_SHIFT - 1)); |
| 70 | let mut a1 = a0; |
| 71 | let mut a2 = a0; |
| 72 | let mut a3 = a0; |
| 73 | |
| 74 | a0 += W2 * in2; |
| 75 | a1 += W6 * in2; |
| 76 | a2 -= W6 * in2; |
| 77 | a3 -= W2 * in2; |
| 78 | |
| 79 | let mut b0 = W1 * in1 + W3 * in3; |
| 80 | let mut b1 = W3 * in1 - W7 * in3; |
| 81 | let mut b2 = W5 * in1 - W1 * in3; |
| 82 | let mut b3 = W7 * in1 - W5 * in3; |
| 83 | |
| 84 | a0 += W4 * in4 + W6 * in6; |
| 85 | a1 -= W4 * in4 + W2 * in6; |
| 86 | a2 -= W4 * in4 - W2 * in6; |
| 87 | a3 += W4 * in4 - W6 * in6; |
| 88 | |
| 89 | b0 += W5 * in5 + W7 * in7; |
| 90 | b1 -= W1 * in5 + W5 * in7; |
| 91 | b2 += W7 * in5 + W3 * in7; |
| 92 | b3 += W3 * in5 - W1 * in7; |
| 93 | |
| 94 | blk[off + 0*8] = ((a0 + b0) >> COL_SHIFT) as i16; |
| 95 | blk[off + 7*8] = ((a0 - b0) >> COL_SHIFT) as i16; |
| 96 | blk[off + 1*8] = ((a1 + b1) >> COL_SHIFT) as i16; |
| 97 | blk[off + 6*8] = ((a1 - b1) >> COL_SHIFT) as i16; |
| 98 | blk[off + 2*8] = ((a2 + b2) >> COL_SHIFT) as i16; |
| 99 | blk[off + 5*8] = ((a2 - b2) >> COL_SHIFT) as i16; |
| 100 | blk[off + 3*8] = ((a3 + b3) >> COL_SHIFT) as i16; |
| 101 | blk[off + 4*8] = ((a3 - b3) >> COL_SHIFT) as i16; |
| 102 | } |
| 103 | |
| 104 | #[allow(dead_code)] |
| 105 | pub fn h263_idct(blk: &mut [i16; 64]) { |
| 106 | for i in 0..8 { idct_row(&mut blk[i*8..(i+1)*8]); } |
| 107 | for i in 0..8 { idct_col(blk, i); } |
| 108 | }*/ |
| 109 | |
| 110 | const W1: i32 = 2841; |
| 111 | const W2: i32 = 2676; |
| 112 | const W3: i32 = 2408; |
| 113 | const W5: i32 = 1609; |
| 114 | const W6: i32 = 1108; |
| 115 | const W7: i32 = 565; |
| 116 | const W8: i32 = 181; |
| 117 | |
| 118 | const ROW_SHIFT: u8 = 8; |
| 119 | const COL_SHIFT: u8 = 14; |
| 120 | |
| 121 | fn idct_row(row: &mut [i16]) { |
| 122 | let in0 = ((row[0] as i32) << 11) + (1 << (ROW_SHIFT - 1)); |
| 123 | let in1 = (row[4] as i32) << 11; |
| 124 | let in2 = row[6] as i32; |
| 125 | let in3 = row[2] as i32; |
| 126 | let in4 = row[1] as i32; |
| 127 | let in5 = row[7] as i32; |
| 128 | let in6 = row[5] as i32; |
| 129 | let in7 = row[3] as i32; |
| 130 | |
| 131 | let tmp = W7 * (in4 + in5); |
| 132 | let a4 = tmp + (W1 - W7) * in4; |
| 133 | let a5 = tmp - (W1 + W7) * in5; |
| 134 | |
| 135 | let tmp = W3 * (in6 + in7); |
| 136 | let a6 = tmp - (W3 - W5) * in6; |
| 137 | let a7 = tmp - (W3 + W5) * in7; |
| 138 | |
| 139 | let tmp = in0 + in1; |
| 140 | |
| 141 | let a0 = in0 - in1; |
| 142 | let t1 = W6 * (in2 + in3); |
| 143 | let a2 = t1 - (W2 + W6) * in2; |
| 144 | let a3 = t1 + (W2 - W6) * in3; |
| 145 | let b1 = a4 + a6; |
| 146 | |
| 147 | let b4 = a4 - a6; |
| 148 | let t2 = a5 - a7; |
| 149 | let b6 = a5 + a7; |
| 150 | let b7 = tmp + a3; |
| 151 | let b5 = tmp - a3; |
| 152 | let b3 = a0 + a2; |
| 153 | let b0 = a0 - a2; |
| 154 | let b2 = (W8 * (b4 + t2) + 128) >> 8; |
| 155 | let b4 = (W8 * (b4 - t2) + 128) >> 8; |
| 156 | |
| 157 | row[0] = ((b7 + b1) >> ROW_SHIFT) as i16; |
| 158 | row[7] = ((b7 - b1) >> ROW_SHIFT) as i16; |
| 159 | row[1] = ((b3 + b2) >> ROW_SHIFT) as i16; |
| 160 | row[6] = ((b3 - b2) >> ROW_SHIFT) as i16; |
| 161 | row[2] = ((b0 + b4) >> ROW_SHIFT) as i16; |
| 162 | row[5] = ((b0 - b4) >> ROW_SHIFT) as i16; |
| 163 | row[3] = ((b5 + b6) >> ROW_SHIFT) as i16; |
| 164 | row[4] = ((b5 - b6) >> ROW_SHIFT) as i16; |
| 165 | } |
| 166 | |
| 167 | fn idct_col(blk: &mut [i16; 64], off: usize) { |
| 168 | let in0 = ((blk[off + 0*8] as i32) << 8) + (1 << (COL_SHIFT - 1)); |
| 169 | let in1 = (blk[off + 4*8] as i32) << 8; |
| 170 | let in2 = blk[off + 6*8] as i32; |
| 171 | let in3 = blk[off + 2*8] as i32; |
| 172 | let in4 = blk[off + 1*8] as i32; |
| 173 | let in5 = blk[off + 7*8] as i32; |
| 174 | let in6 = blk[off + 5*8] as i32; |
| 175 | let in7 = blk[off + 3*8] as i32; |
| 176 | |
| 177 | let tmp = W7 * (in4 + in5); |
| 178 | let a4 = (tmp + (W1 - W7) * in4) >> 3; |
| 179 | let a5 = (tmp - (W1 + W7) * in5) >> 3; |
| 180 | |
| 181 | let tmp = W3 * (in6 + in7); |
| 182 | let a6 = (tmp - (W3 - W5) * in6) >> 3; |
| 183 | let a7 = (tmp - (W3 + W5) * in7) >> 3; |
| 184 | |
| 185 | let tmp = in0 + in1; |
| 186 | |
| 187 | let a0 = in0 - in1; |
| 188 | let t1 = W6 * (in2 + in3); |
| 189 | let a2 = (t1 - (W2 + W6) * in2) >> 3; |
| 190 | let a3 = (t1 + (W2 - W6) * in3) >> 3; |
| 191 | let b1 = a4 + a6; |
| 192 | |
| 193 | let b4 = a4 - a6; |
| 194 | let t2 = a5 - a7; |
| 195 | let b6 = a5 + a7; |
| 196 | let b7 = tmp + a3; |
| 197 | let b5 = tmp - a3; |
| 198 | let b3 = a0 + a2; |
| 199 | let b0 = a0 - a2; |
| 200 | let b2 = (W8 * (b4 + t2) + 128) >> 8; |
| 201 | let b4 = (W8 * (b4 - t2) + 128) >> 8; |
| 202 | |
| 203 | blk[off + 0*8] = ((b7 + b1) >> COL_SHIFT) as i16; |
| 204 | blk[off + 7*8] = ((b7 - b1) >> COL_SHIFT) as i16; |
| 205 | blk[off + 1*8] = ((b3 + b2) >> COL_SHIFT) as i16; |
| 206 | blk[off + 6*8] = ((b3 - b2) >> COL_SHIFT) as i16; |
| 207 | blk[off + 2*8] = ((b0 + b4) >> COL_SHIFT) as i16; |
| 208 | blk[off + 5*8] = ((b0 - b4) >> COL_SHIFT) as i16; |
| 209 | blk[off + 3*8] = ((b5 + b6) >> COL_SHIFT) as i16; |
| 210 | blk[off + 4*8] = ((b5 - b6) >> COL_SHIFT) as i16; |
| 211 | } |
| 212 | |
| 213 | #[allow(dead_code)] |
| 214 | pub fn h263_idct(blk: &mut [i16; 64]) { |
| 215 | for i in 0..8 { idct_row(&mut blk[i*8..(i+1)*8]); } |
| 216 | for i in 0..8 { idct_col(blk, i); } |
| 217 | } |
| 218 | |
| 219 | fn h263_interp00(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) |
| 220 | { |
| 221 | let mut didx = 0; |
| 222 | let mut sidx = 0; |
| 223 | for _ in 0..bh { |
| 224 | for x in 0..bw { dst[didx + x] = src[sidx + x]; } |
| 225 | didx += dstride; |
| 226 | sidx += sstride; |
| 227 | } |
| 228 | } |
| 229 | |
| 230 | fn h263_interp01(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) |
| 231 | { |
| 232 | let mut didx = 0; |
| 233 | let mut sidx = 0; |
| 234 | for _ in 0..bh { |
| 235 | for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + 1] as u16) + 1) >> 1) as u8; } |
| 236 | didx += dstride; |
| 237 | sidx += sstride; |
| 238 | } |
| 239 | } |
| 240 | |
| 241 | fn h263_interp10(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) |
| 242 | { |
| 243 | let mut didx = 0; |
| 244 | let mut sidx = 0; |
| 245 | for _ in 0..bh { |
| 246 | for x in 0..bw { dst[didx + x] = (((src[sidx + x] as u16) + (src[sidx + x + sstride] as u16) + 1) >> 1) as u8; } |
| 247 | didx += dstride; |
| 248 | sidx += sstride; |
| 249 | } |
| 250 | } |
| 251 | |
| 252 | fn h263_interp11(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) |
| 253 | { |
| 254 | let mut didx = 0; |
| 255 | let mut sidx = 0; |
| 256 | for _ in 0..bh { |
| 257 | for x in 0..bw { |
| 258 | dst[didx + x] = (((src[sidx + x] as u16) + |
| 259 | (src[sidx + x + 1] as u16) + |
| 260 | (src[sidx + x + sstride] as u16) + |
| 261 | (src[sidx + x + sstride + 1] as u16) + 2) >> 2) as u8; |
| 262 | } |
| 263 | didx += dstride; |
| 264 | sidx += sstride; |
| 265 | } |
| 266 | } |
| 267 | |
| 268 | pub const H263_INTERP_FUNCS: &[fn(&mut [u8], usize, &[u8], usize, usize, usize)] = &[ |
| 269 | h263_interp00, h263_interp01, h263_interp10, h263_interp11 ]; |