]> git.nihav.org Git - nihav.git/blame - nihav-duck/src/codecs/vp78dsp.rs
projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
avimux: do not record palette change chunks in OpenDML index
[nihav.git] / nihav-duck / src / codecs / vp78dsp.rs
CommitLineData
20b5a55f 1use std::cmp::Ordering;
0cc75664
KS		 2use nihav_core::frame::*;
3use nihav_codec_support::codecs::blockdsp::edge_emu;
4
5fn clip_u8(val: i16) -> u8 {
6 val.max(0).min(255) as u8
7}
8
9pub struct IPredContext {
10 pub left: [u8; 16],
11 pub has_left: bool,
12 pub top: [u8; 16],
13 pub has_top: bool,
14 pub tl: u8,
15}
16
17impl IPredContext {
18 pub fn fill(&mut self, src: &[u8], off: usize, stride: usize, tsize: usize, lsize: usize) {
19 if self.has_top {
20 for i in 0..tsize {
21 self.top[i] = src[off - stride + i];
22 }
23 for i in tsize..16 {
24 self.top[i] = 0x80;
25 }
26 } else {
27 self.top = [0x80; 16];
28 }
29 if self.has_left {
30 for i in 0..lsize {
31 self.left[i] = src[off - 1 + i * stride];
32 }
33 for i in lsize..16 {
34 self.left[i] = 0x80;
35 }
36 } else {
37 self.left = [0x80; 16];
38 }
39 if self.has_top && self.has_left {
40 self.tl = src[off - stride - 1];
41 } else {
42 self.tl = 0x80;
43 }
44 }
45}
46
47impl Default for IPredContext {
48 fn default() -> Self {
49 Self {
50 left: [0x80; 16],
51 top: [0x80; 16],
52 tl: 0x80,
53 has_left: false,
54 has_top: false,
55 }
56 }
57}
58
59pub fn add_coeffs4x4(dst: &mut [u8], off: usize, stride: usize, coeffs: &[i16; 16]) {
60 let dst = &mut dst[off..];
61 for (out, src) in dst.chunks_mut(stride).zip(coeffs.chunks(4)) {
62 for (oel, iel) in out.iter_mut().take(4).zip(src.iter()) {
63 *oel = clip_u8(i16::from(*oel) + *iel);
64 }
65 }
66}
67pub fn add_coeffs16x1(dst: &mut [u8], off: usize, coeffs: &[i16; 16]) {
68 let dst = &mut dst[off..];
69 for (oel, iel) in dst.iter_mut().take(16).zip(coeffs.iter()) {
70 *oel = clip_u8(i16::from(*oel) + *iel);
71 }
72}
73
74pub trait IntraPred {
75 const SIZE: usize;
20b5a55f 76 #[allow(clippy::needless_late_init)]
0cc75664
KS		 77 fn ipred_dc(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
78 let dc;
79 if !ipred.has_left && !ipred.has_top {
80 dc = 0x80;
81 } else {
82 let mut dcsum = 0;
83 let mut dcshift = match Self::SIZE {
84 16 => 3,
85 _ => 2,
86 };
87 if ipred.has_left {
88 for el in ipred.left.iter().take(Self::SIZE) {
89 dcsum += u16::from(*el);
90 }
91 dcshift += 1;
92 }
93 if ipred.has_top {
94 for el in ipred.top.iter().take(Self::SIZE) {
95 dcsum += u16::from(*el);
96 }
97 dcshift += 1;
98 }
99 dc = ((dcsum + (1 << (dcshift - 1))) >> dcshift) as u8;
100 }
101 for _ in 0..Self::SIZE {
102 let out = &mut dst[off..][..Self::SIZE];
103 for el in out.iter_mut() {
104 *el = dc;
105 }
106 off += stride;
107 }
108 }
109 fn ipred_v(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
110 for _ in 0..Self::SIZE {
111 let out = &mut dst[off..][..Self::SIZE];
112 out.copy_from_slice(&ipred.top[0..Self::SIZE]);
113 off += stride;
114 }
115 }
116 fn ipred_h(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
117 for leftel in ipred.left.iter().take(Self::SIZE) {
118 let out = &mut dst[off..][..Self::SIZE];
119 for el in out.iter_mut() {
120 *el = *leftel;
121 }
122 off += stride;
123 }
124 }
125 fn ipred_tm(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
126 let tl = i16::from(ipred.tl);
127 for m in 0..Self::SIZE {
128 for n in 0..Self::SIZE {
129 dst[off + n] = clip_u8(i16::from(ipred.left[m]) + i16::from(ipred.top[n]) - tl);
130 }
131 off += stride;
132 }
133 }
d0d21988
KS		 134 fn ipred_const(dst: &mut [u8], off: usize, stride: usize, dc: u8) {
135 for row in dst[off..].chunks_mut(stride).take(Self::SIZE) {
136 for el in row[..Self::SIZE].iter_mut() {
137 *el = dc;
138 }
139 }
140 }
0cc75664
KS		 141}
142
143pub struct IPred16x16 {}
144impl IntraPred for IPred16x16 { const SIZE: usize = 16; }
145
146pub struct IPred8x8 {}
147impl IntraPred for IPred8x8 { const SIZE: usize = 8; }
148
149macro_rules! load_pred4 {
150 (topleft; $ipred: expr) => {{
151 let tl = u16::from($ipred.tl);
152 let a0 = u16::from($ipred.top[0]);
153 let l0 = u16::from($ipred.left[0]);
154 ((l0 + tl * 2 + a0 + 2) >> 2) as u8
155 }};
156 (top; $ipred: expr) => {{
157 let tl = u16::from($ipred.tl);
158 let a0 = u16::from($ipred.top[0]);
159 let a1 = u16::from($ipred.top[1]);
160 let a2 = u16::from($ipred.top[2]);
161 let a3 = u16::from($ipred.top[3]);
162 let a4 = u16::from($ipred.top[4]);
163 let p0 = ((tl + a0 * 2 + a1 + 2) >> 2) as u8;
164 let p1 = ((a0 + a1 * 2 + a2 + 2) >> 2) as u8;
165 let p2 = ((a1 + a2 * 2 + a3 + 2) >> 2) as u8;
166 let p3 = ((a2 + a3 * 2 + a4 + 2) >> 2) as u8;
167 (p0, p1, p2, p3)
168 }};
169 (top8; $ipred: expr) => {{
170 let t3 = u16::from($ipred.top[3]);
171 let t4 = u16::from($ipred.top[4]);
172 let t5 = u16::from($ipred.top[5]);
173 let t6 = u16::from($ipred.top[6]);
174 let t7 = u16::from($ipred.top[7]);
175 let p4 = ((t3 + t4 * 2 + t5 + 2) >> 2) as u8;
176 let p5 = ((t4 + t5 * 2 + t6 + 2) >> 2) as u8;
177 let p6 = ((t5 + t6 * 2 + t7 + 2) >> 2) as u8;
178 let p7 = ((t6 + t7 * 2 + t7 + 2) >> 2) as u8;
179 (p4, p5, p6, p7)
180 }};
181 (topavg; $ipred: expr) => {{
182 let tl = u16::from($ipred.tl);
183 let a0 = u16::from($ipred.top[0]);
184 let a1 = u16::from($ipred.top[1]);
185 let a2 = u16::from($ipred.top[2]);
186 let a3 = u16::from($ipred.top[3]);
187 let p0 = ((tl + a0 + 1) >> 1) as u8;
188 let p1 = ((a0 + a1 + 1) >> 1) as u8;
189 let p2 = ((a1 + a2 + 1) >> 1) as u8;
190 let p3 = ((a2 + a3 + 1) >> 1) as u8;
191 (p0, p1, p2, p3)
192 }};
193 (left; $ipred: expr) => {{
194 let tl = u16::from($ipred.tl);
195 let l0 = u16::from($ipred.left[0]);
196 let l1 = u16::from($ipred.left[1]);
197 let l2 = u16::from($ipred.left[2]);
198 let l3 = u16::from($ipred.left[3]);
199 let l4 = u16::from($ipred.left[4]);
200 let p0 = ((tl + l0 * 2 + l1 + 2) >> 2) as u8;
201 let p1 = ((l0 + l1 * 2 + l2 + 2) >> 2) as u8;
202 let p2 = ((l1 + l2 * 2 + l3 + 2) >> 2) as u8;
203 let p3 = ((l2 + l3 * 2 + l4 + 2) >> 2) as u8;
204 (p0, p1, p2, p3)
205 }};
206 (left8; $ipred: expr) => {{
207 let l3 = u16::from($ipred.left[3]);
208 let l4 = u16::from($ipred.left[4]);
209 let l5 = u16::from($ipred.left[5]);
210 let l6 = u16::from($ipred.left[6]);
211 let l7 = u16::from($ipred.left[7]);
212 let p4 = ((l3 + l4 * 2 + l5 + 2) >> 2) as u8;
213 let p5 = ((l4 + l5 * 2 + l6 + 2) >> 2) as u8;
214 let p6 = ((l5 + l6 * 2 + l7 + 2) >> 2) as u8;
215 let p7 = ((l6 + l7 * 2 + l7 + 2) >> 2) as u8;
216 (p4, p5, p6, p7)
217 }};
218 (leftavg; $ipred: expr) => {{
219 let tl = u16::from($ipred.tl);
220 let l0 = u16::from($ipred.left[0]);
221 let l1 = u16::from($ipred.left[1]);
222 let l2 = u16::from($ipred.left[2]);
223 let l3 = u16::from($ipred.left[3]);
224 let p0 = ((tl + l0 + 1) >> 1) as u8;
225 let p1 = ((l0 + l1 + 1) >> 1) as u8;
226 let p2 = ((l1 + l2 + 1) >> 1) as u8;
227 let p3 = ((l2 + l3 + 1) >> 1) as u8;
228 (p0, p1, p2, p3)
229 }};
230}
231
232pub struct IPred4x4 {}
233impl IPred4x4 {
234 pub fn ipred_dc(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
0cc75664
KS		 235 let mut dcsum = 0;
236 for el in ipred.left.iter().take(4) {
237 dcsum += u16::from(*el);
238 }
239 for el in ipred.top.iter().take(4) {
240 dcsum += u16::from(*el);
241 }
6f263099 242 let dc = ((dcsum + (1 << 2)) >> 3) as u8;
0cc75664
KS		 243 for _ in 0..4 {
244 let out = &mut dst[off..][..4];
245 for el in out.iter_mut() {
246 *el = dc;
247 }
248 off += stride;
249 }
250 }
251 pub fn ipred_tm(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
252 let tl = i16::from(ipred.tl);
253 for m in 0..4 {
254 for n in 0..4 {
255 dst[off + n] = clip_u8(i16::from(ipred.left[m]) + i16::from(ipred.top[n]) - tl);
256 }
257 off += stride;
258 }
259 }
260 pub fn ipred_ve(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
261 let (v0, v1, v2, v3) = load_pred4!(top; ipred);
262 let vert_pred = [v0, v1, v2, v3];
263 for _ in 0..4 {
264 let out = &mut dst[off..][..4];
265 out.copy_from_slice(&vert_pred);
266 off += stride;
267 }
268 }
20b5a55f 269 pub fn ipred_he(dst: &mut [u8], off: usize, stride: usize, ipred: &IPredContext) {
0cc75664
KS		 270 let (p0, p1, p2, _) = load_pred4!(left; ipred);
271 let p3 = ((u16::from(ipred.left[2]) + u16::from(ipred.left[3]) * 3 + 2) >> 2) as u8;
272 let hor_pred = [p0, p1, p2, p3];
20b5a55f
KS		 273 for (dline, &pred) in dst[off..].chunks_mut(stride).zip(hor_pred.iter()) {
274 for el in dline[..4].iter_mut() {
275 *el = pred;
0cc75664 276 }
0cc75664
KS		 277 }
278 }
279 pub fn ipred_ld(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
280 let (_, p0, p1, p2) = load_pred4!(top; ipred);
281 let (p3, p4, p5, p6) = load_pred4!(top8; ipred);
282
283 dst[off + 0] = p0; dst[off + 1] = p1; dst[off + 2] = p2; dst[off + 3] = p3;
284 off += stride;
285 dst[off + 0] = p1; dst[off + 1] = p2; dst[off + 2] = p3; dst[off + 3] = p4;
286 off += stride;
287 dst[off + 0] = p2; dst[off + 1] = p3; dst[off + 2] = p4; dst[off + 3] = p5;
288 off += stride;
289 dst[off + 0] = p3; dst[off + 1] = p4; dst[off + 2] = p5; dst[off + 3] = p6;
290 }
291 pub fn ipred_rd(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
292 let tl = load_pred4!(topleft; ipred);
293 let (l0, l1, l2, _) = load_pred4!(left; ipred);
294 let (t0, t1, t2, _) = load_pred4!(top; ipred);
295
296 dst[off + 0] = tl; dst[off + 1] = t0; dst[off + 2] = t1; dst[off + 3] = t2;
297 off += stride;
298 dst[off + 0] = l0; dst[off + 1] = tl; dst[off + 2] = t0; dst[off + 3] = t1;
299 off += stride;
300 dst[off + 0] = l1; dst[off + 1] = l0; dst[off + 2] = tl; dst[off + 3] = t0;
301 off += stride;
302 dst[off + 0] = l2; dst[off + 1] = l1; dst[off + 2] = l0; dst[off + 3] = tl;
303 }
304 pub fn ipred_vr(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
305 let tl = load_pred4!(topleft; ipred);
306 let (l0, l1, _, _) = load_pred4!(left; ipred);
307 let (t0, t1, t2, _) = load_pred4!(top; ipred);
308 let (m0, m1, m2, m3) = load_pred4!(topavg; ipred);
309
310 dst[off + 0] = m0; dst[off + 1] = m1; dst[off + 2] = m2; dst[off + 3] = m3;
311 off += stride;
312 dst[off + 0] = tl; dst[off + 1] = t0; dst[off + 2] = t1; dst[off + 3] = t2;
313 off += stride;
314 dst[off + 0] = l0; dst[off + 1] = m0; dst[off + 2] = m1; dst[off + 3] = m2;
315 off += stride;
316 dst[off + 0] = l1; dst[off + 1] = tl; dst[off + 2] = t0; dst[off + 3] = t1;
317 }
318 pub fn ipred_vl(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
319 let (_, t1, t2, t3) = load_pred4!(top; ipred);
320 let (t4, t5, t6, _) = load_pred4!(top8; ipred);
321 let (_, m1, m2, m3) = load_pred4!(topavg; ipred);
322 let m4 = ((u16::from(ipred.top[3]) + u16::from(ipred.top[4]) + 1) >> 1) as u8;
323
324 dst[off + 0] = m1; dst[off + 1] = m2; dst[off + 2] = m3; dst[off + 3] = m4;
325 off += stride;
326 dst[off + 0] = t1; dst[off + 1] = t2; dst[off + 2] = t3; dst[off + 3] = t4;
327 off += stride;
328 dst[off + 0] = m2; dst[off + 1] = m3; dst[off + 2] = m4; dst[off + 3] = t5;
329 off += stride;
330 dst[off + 0] = t2; dst[off + 1] = t3; dst[off + 2] = t4; dst[off + 3] = t6;
331 }
332 pub fn ipred_hd(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
333 let tl = load_pred4!(topleft; ipred);
334 let (l0, l1, l2, _) = load_pred4!(left; ipred);
335 let (m0, m1, m2, m3) = load_pred4!(leftavg; ipred);
336 let (t0, t1, _, _) = load_pred4!(top; ipred);
337
338 dst[off + 0] = m0; dst[off + 1] = tl; dst[off + 2] = t0; dst[off + 3] = t1;
339 off += stride;
340 dst[off + 0] = m1; dst[off + 1] = l0; dst[off + 2] = m0; dst[off + 3] = tl;
341 off += stride;
342 dst[off + 0] = m2; dst[off + 1] = l1; dst[off + 2] = m1; dst[off + 3] = l0;
343 off += stride;
344 dst[off + 0] = m3; dst[off + 1] = l2; dst[off + 2] = m2; dst[off + 3] = l1;
345 }
346 pub fn ipred_hu(dst: &mut [u8], mut off: usize, stride: usize, ipred: &IPredContext) {
347 let (_, m1, m2, m3) = load_pred4!(leftavg; ipred);
348 let (_, l1, l2, _) = load_pred4!(left; ipred);
349 let l3 = ((u16::from(ipred.left[2]) + u16::from(ipred.left[3]) * 3 + 2) >> 2) as u8;
350 let p3 = ipred.left[3];
351
352 dst[off + 0] = m1; dst[off + 1] = l1; dst[off + 2] = m2; dst[off + 3] = l2;
353 off += stride;
354 dst[off + 0] = m2; dst[off + 1] = l2; dst[off + 2] = m3; dst[off + 3] = l3;
355 off += stride;
356 dst[off + 0] = m3; dst[off + 1] = l3; dst[off + 2] = p3; dst[off + 3] = p3;
357 off += stride;
358 dst[off + 0] = p3; dst[off + 1] = p3; dst[off + 2] = p3; dst[off + 3] = p3;
359 }
360}
361
362const VP7_BICUBIC_FILTERS: [[i16; 6]; 8] = [
363 [ 0, 0, 128, 0, 0, 0 ],
364 [ 0, -6, 123, 12, -1, 0 ],
365 [ 2, -11, 108, 36, -8, 1 ],
366 [ 0, -9, 93, 50, -6, 0 ],
367 [ 3, -16, 77, 77, -16, 3 ],
368 [ 0, -6, 50, 93, -9, 0 ],
369 [ 1, -8, 36, 108, -11, 2 ],
370 [ 0, -1, 12, 123, -6, 0 ]
371];
372
373macro_rules! interpolate {
374 ($src: expr, $off: expr, $step: expr, $mode: expr) => {{
375 let s0 = i32::from($src[$off + 0 * $step]);
376 let s1 = i32::from($src[$off + 1 * $step]);
377 let s2 = i32::from($src[$off + 2 * $step]);
378 let s3 = i32::from($src[$off + 3 * $step]);
379 let s4 = i32::from($src[$off + 4 * $step]);
380 let s5 = i32::from($src[$off + 5 * $step]);
381 let filt = &VP7_BICUBIC_FILTERS[$mode];
382 let src = [s0, s1, s2, s3, s4, s5];
383 let mut val = 64;
384 for (s, c) in src.iter().zip(filt.iter()) {
385 val += s * i32::from(*c);
386 }
387 clip_u8((val >> 7) as i16)
388 }}
389}
390
391const EDGE_PRE: usize = 2;
392const EDGE_POST: usize = 4;
393const TMP_STRIDE: usize = 16;
394
395fn mc_block_common(dst: &mut [u8], mut doff: usize, dstride: usize, src: &[u8], sstride: usize, size: usize, mx: usize, my: usize) {
396 if (mx == 0) && (my == 0) {
397 let dst = &mut dst[doff..];
398 let src = &src[EDGE_PRE + EDGE_PRE * sstride..];
399 for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
e6aaad5c 400 out[..size].copy_from_slice(&src[..size]);
0cc75664
KS		 401 }
402 } else if my == 0 {
403 let src = &src[EDGE_PRE * sstride..];
404 for src in src.chunks(sstride).take(size) {
405 for x in 0..size {
406 dst[doff + x] = interpolate!(src, x, 1, mx);
407 }
408 doff += dstride;
409 }
410 } else if mx == 0 {
411 let src = &src[EDGE_PRE..];
412 for y in 0..size {
413 for x in 0..size {
414 dst[doff + x] = interpolate!(src, x + y * sstride, sstride, my);
415 }
416 doff += dstride;
417 }
418 } else {
419 let mut tmp = [0u8; TMP_STRIDE * (16 + EDGE_PRE + EDGE_POST)];
420 for (y, dst) in tmp.chunks_mut(TMP_STRIDE).take(size + EDGE_PRE + EDGE_POST).enumerate() {
421 for x in 0..size {
422 dst[x] = interpolate!(src, x + y * sstride, 1, mx);
423 }
424 }
425 for y in 0..size {
426 for x in 0..size {
427 dst[doff + x] = interpolate!(tmp, x + y * TMP_STRIDE, TMP_STRIDE, my);
428 }
429 doff += dstride;
430 }
431 }
432}
433fn mc_block(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
434 mvx: i16, mvy: i16, reffrm: NAVideoBufferRef<u8>, plane: usize,
435 mc_buf: &mut [u8], size: usize) {
436 if (mvx == 0) && (mvy == 0) {
437 let dst = &mut dst[doff..];
438 let sstride = reffrm.get_stride(plane);
439 let srcoff = reffrm.get_offset(plane) + xpos + ypos * sstride;
440 let src = &reffrm.get_data();
441 let src = &src[srcoff..];
442 for (out, src) in dst.chunks_mut(dstride).take(size).zip(src.chunks(sstride)) {
e6aaad5c 443 out[..size].copy_from_slice(&src[..size]);
0cc75664
KS		 444 }
445 return;
446 }
447 let (w, h) = reffrm.get_dimensions(plane);
448 let wa = if plane == 0 { (w + 15) & !15 } else { (w + 7) & !7 } as isize;
449 let ha = if plane == 0 { (h + 15) & !15 } else { (h + 7) & !7 } as isize;
450 let bsize = (size as isize) + (EDGE_PRE as isize) + (EDGE_POST as isize);
451 let ref_x = (xpos as isize) + ((mvx >> 3) as isize) - (EDGE_PRE as isize);
452 let ref_y = (ypos as isize) + ((mvy >> 3) as isize) - (EDGE_PRE as isize);
453
454 let (src, sstride) = if (ref_x < 0) || (ref_x + bsize > wa) || (ref_y < 0) || (ref_y + bsize > ha) {
455 edge_emu(&reffrm, ref_x, ref_y, bsize as usize, bsize as usize, mc_buf, 32, plane, 4);
456 (mc_buf as &[u8], 32)
457 } else {
458 let off = reffrm.get_offset(plane);
459 let stride = reffrm.get_stride(plane);
460 let data = reffrm.get_data();
461 (&data[off + (ref_x as usize) + (ref_y as usize) * stride..], stride)
462 };
463 let mx = (mvx & 7) as usize;
464 let my = (mvy & 7) as usize;
465 mc_block_common(dst, doff, dstride, src, sstride, size, mx, my);
466}
467pub fn mc_block16x16(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
468 mvx: i16, mvy: i16, src: NAVideoBufferRef<u8>, plane: usize, mc_buf: &mut [u8]) {
469 mc_block(dst, doff, dstride, xpos, ypos, mvx, mvy, src, plane, mc_buf, 16);
470}
471pub fn mc_block8x8(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
472 mvx: i16, mvy: i16, src: NAVideoBufferRef<u8>, plane: usize, mc_buf: &mut [u8]) {
473 mc_block(dst, doff, dstride, xpos, ypos, mvx, mvy, src, plane, mc_buf, 8);
474}
475pub fn mc_block4x4(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
476 mvx: i16, mvy: i16, src: NAVideoBufferRef<u8>, plane: usize, mc_buf: &mut [u8]) {
477 mc_block(dst, doff, dstride, xpos, ypos, mvx, mvy, src, plane, mc_buf, 4);
478}
479pub fn mc_block_special(dst: &mut [u8], doff: usize, dstride: usize, xpos: usize, ypos: usize,
480 mvx: i16, mvy: i16, reffrm: NAVideoBufferRef<u8>, plane: usize,
481 mc_buf: &mut [u8], size: usize, pitch_mode: u8) {
482 const Y_MUL: [isize; 8] = [ 1, 0, 2, 4, 1, 1, 2, 2 ];
483 const Y_OFF: [isize; 8] = [ 0, 4, 0, 0, 1, -1, 1, -1 ];
484 const ILACE_CHROMA: [bool; 8] = [ false, false, true, true, false, false, true, true ]; // mode&2 != 0
485
486 let pitch_mode = (pitch_mode & 7) as usize;
487 let (xstep, ymul) = if plane == 0 {
488 (Y_OFF[pitch_mode], Y_MUL[pitch_mode])
489 } else {
490 (0, if ILACE_CHROMA[pitch_mode] { 2 } else { 1 })
491 };
492
493 let (w, h) = reffrm.get_dimensions(plane);
494 let wa = if plane == 0 { (w + 15) & !15 } else { (w + 7) & !7 } as isize;
495 let ha = if plane == 0 { (h + 15) & !15 } else { (h + 7) & !7 } as isize;
496 let mut start_x = (xpos as isize) + ((mvx >> 3) as isize) - (EDGE_PRE as isize);
497 let mut end_x = (xpos as isize) + ((mvx >> 3) as isize) + ((size + EDGE_POST) as isize);
20b5a55f
KS		 498 match xstep.cmp(&0) {
499 Ordering::Less => start_x -= (size + EDGE_POST) as isize,
500 Ordering::Greater => end_x += (size as isize) * xstep,
501 Ordering::Equal => {},
0cc75664
KS		 502 }
503 let mut start_y = (ypos as isize) + ((mvy >> 3) as isize) - (EDGE_PRE as isize) * ymul;
504 let mut end_y = (ypos as isize) + ((mvy >> 3) as isize) + ((size + EDGE_POST) as isize) * ymul;
505 if ymul == 0 {
506 start_y -= EDGE_PRE as isize;
507 end_y += (EDGE_POST + 1) as isize;
508 }
509 let off = reffrm.get_offset(plane);
510 let stride = reffrm.get_stride(plane);
511 let (src, sstride) = if (start_x >= 0) && (end_x <= wa) && (start_y >= 0) && (end_y <= ha) {
512 let data = reffrm.get_data();
513 (&data[off + (start_x as usize) + (start_y as usize) * stride..],
514 ((stride as isize) + xstep) as usize)
515 } else {
e6aaad5c 516 let add = (size + EDGE_PRE + EDGE_POST) * xstep.unsigned_abs();
0cc75664
KS		 517 let bw = size + EDGE_PRE + EDGE_POST + add;
518 let bh = (end_y - start_y) as usize;
519 let bo = if xstep >= 0 { 0 } else { add };
520 edge_emu(&reffrm, start_x + (bo as isize), start_y, bw, bh, mc_buf, 128, plane, 0);
521 (&mc_buf[bo..], (128 + xstep) as usize)
522 };
523 let mx = (mvx & 7) as usize;
524 let my = (mvy & 7) as usize;
525 match ymul {
526 0 => unimplemented!(),
527 1 => mc_block_common(dst, doff, dstride, src, sstride, size, mx, my),
528 2 => {
529 let hsize = size / 2;
530 for y in 0..2 {
531 for x in 0..2 {
532 mc_block_common(dst, doff + x * hsize + y * hsize * dstride, dstride,
533 &src[x * hsize + y * sstride..], sstride * 2, hsize, mx, my);
534 }
535 }
536 },
537 4 => {
538 let qsize = size / 4;
539 for y in 0..4 {
540 for x in 0..4 {
541 mc_block_common(dst, doff + x * qsize + y * qsize * dstride, dstride,
542 &src[x * qsize + y * sstride..], sstride * 4, qsize, mx, my);
543 }
544 }
545 },
546 _ => unreachable!(),
547 };
548}
NihAV is a research multimedia framework