]>
Commit | Line | Data |
---|---|---|
cf64af13 KS |
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 ]; | |
21c16d5f KS |
270 | |
271 | fn h263_interp00_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) | |
272 | { | |
273 | let mut didx = 0; | |
274 | let mut sidx = 0; | |
275 | for _ in 0..bh { | |
276 | for x in 0..bw { | |
277 | let a = dst[didx + x] as u16; | |
278 | let b = src[sidx + x] as u16; | |
279 | dst[didx + x] = ((a + b + 1) >> 1) as u8; | |
280 | } | |
281 | didx += dstride; | |
282 | sidx += sstride; | |
283 | } | |
284 | } | |
285 | ||
286 | fn h263_interp01_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) | |
287 | { | |
288 | let mut didx = 0; | |
289 | let mut sidx = 0; | |
290 | for _ in 0..bh { | |
291 | for x in 0..bw { | |
292 | let a = dst[didx + x] as u16; | |
293 | let b = ((src[sidx + x] as u16) + (src[sidx + x + 1] as u16) + 1) >> 1; | |
294 | dst[didx + x] = ((a + b + 1) >> 1) as u8; | |
295 | } | |
296 | didx += dstride; | |
297 | sidx += sstride; | |
298 | } | |
299 | } | |
300 | ||
301 | fn h263_interp10_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) | |
302 | { | |
303 | let mut didx = 0; | |
304 | let mut sidx = 0; | |
305 | for _ in 0..bh { | |
306 | for x in 0..bw { | |
307 | let a = dst[didx + x] as u16; | |
308 | let b = ((src[sidx + x] as u16) + (src[sidx + x + sstride] as u16) + 1) >> 1; | |
309 | dst[didx + x] = ((a + b + 1) >> 1) as u8; | |
310 | } | |
311 | didx += dstride; | |
312 | sidx += sstride; | |
313 | } | |
314 | } | |
315 | ||
316 | fn h263_interp11_avg(dst: &mut [u8], dstride: usize, src: &[u8], sstride: usize, bw: usize, bh: usize) | |
317 | { | |
318 | let mut didx = 0; | |
319 | let mut sidx = 0; | |
320 | for _ in 0..bh { | |
321 | for x in 0..bw { | |
322 | let a = dst[didx + x] as u16; | |
323 | let b = ((src[sidx + x] as u16) + | |
324 | (src[sidx + x + 1] as u16) + | |
325 | (src[sidx + x + sstride] as u16) + | |
326 | (src[sidx + x + sstride + 1] as u16) + 2) >> 2; | |
327 | dst[didx + x] = ((a + b + 1) >> 1) as u8; | |
328 | } | |
329 | didx += dstride; | |
330 | sidx += sstride; | |
331 | } | |
332 | } | |
333 | ||
334 | pub const H263_INTERP_AVG_FUNCS: &[fn(&mut [u8], usize, &[u8], usize, usize, usize)] = &[ | |
335 | h263_interp00_avg, h263_interp01_avg, h263_interp10_avg, h263_interp11_avg ]; |