projects / libav.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add more missing includes after removing the implicit common.h
[libav.git] / libavcodec / sparc / dsputil_vis.c
1 /*
2 * Copyright (C) 2003 David S. Miller <davem@redhat.com>
3 *
4 * This file is part of Libav.
5 *
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * Libav is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /* The *no_round* functions have been added by James A. Morrison, 2003,2004.
22 The vis code from libmpeg2 was adapted for libavcodec by James A. Morrison.
23 */
24
25 #include "config.h"
26
27 #include <inttypes.h>
28
29 #include "libavcodec/dsputil.h"
30 #include "libavutil/mem.h"
31 #include "dsputil_vis.h"
32
33 #include "vis.h"
34
35 /* The trick used in some of this file is the formula from the MMX
36 * motion comp code, which is:
37 *
38 * (x+y+1)>>1 == (x|y)-((x^y)>>1)
39 *
40 * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
41 * We avoid overflows by masking before we do the shift, and we
42 * implement the shift by multiplying by 1/2 using mul8x16. So in
43 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
44 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
45 * the value 0x80808080 is in f8):
46 *
47 * fxor f0, f2, f10
48 * fand f10, f4, f10
49 * fmul8x16 f8, f10, f10
50 * fand f10, f6, f10
51 * for f0, f2, f12
52 * fpsub16 f12, f10, f10
53 */
54
55 #define DUP4(x) {x, x, x, x}
56 #define DUP8(x) {x, x, x, x, x, x, x, x}
57 DECLARE_ALIGNED(8, static const int16_t, constants1)[] = DUP4 (1);
58 DECLARE_ALIGNED(8, static const int16_t, constants2)[] = DUP4 (2);
59 DECLARE_ALIGNED(8, static const int16_t, constants3)[] = DUP4 (3);
60 DECLARE_ALIGNED(8, static const int16_t, constants6)[] = DUP4 (6);
61 DECLARE_ALIGNED(8, static const int8_t, constants_fe)[] = DUP8 (0xfe);
62 DECLARE_ALIGNED(8, static const int8_t, constants_7f)[] = DUP8 (0x7f);
63 DECLARE_ALIGNED(8, static const int8_t, constants128)[] = DUP8 (128);
64 DECLARE_ALIGNED(8, static const int16_t, constants256_512)[] =
65 {256, 512, 256, 512};
66 DECLARE_ALIGNED(8, static const int16_t, constants256_1024)[] =
67 {256, 1024, 256, 1024};
68
69 #define REF_0 0
70 #define REF_0_1 1
71 #define REF_2 2
72 #define REF_2_1 3
73 #define REF_4 4
74 #define REF_4_1 5
75 #define REF_6 6
76 #define REF_6_1 7
77 #define REF_S0 8
78 #define REF_S0_1 9
79 #define REF_S2 10
80 #define REF_S2_1 11
81 #define REF_S4 12
82 #define REF_S4_1 13
83 #define REF_S6 14
84 #define REF_S6_1 15
85 #define DST_0 16
86 #define DST_1 17
87 #define DST_2 18
88 #define DST_3 19
89 #define CONST_1 20
90 #define CONST_2 20
91 #define CONST_3 20
92 #define CONST_6 20
93 #define MASK_fe 20
94 #define CONST_128 22
95 #define CONST_256 22
96 #define CONST_512 22
97 #define CONST_1024 22
98 #define TMP0 24
99 #define TMP1 25
100 #define TMP2 26
101 #define TMP3 27
102 #define TMP4 28
103 #define TMP5 29
104 #define ZERO 30
105 #define MASK_7f 30
106
107 #define TMP6 32
108 #define TMP8 34
109 #define TMP10 36
110 #define TMP12 38
111 #define TMP14 40
112 #define TMP16 42
113 #define TMP18 44
114 #define TMP20 46
115 #define TMP22 48
116 #define TMP24 50
117 #define TMP26 52
118 #define TMP28 54
119 #define TMP30 56
120 #define TMP32 58
121
122 static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * ref,
123 const int stride, int height)
124 {
125 ref = vis_alignaddr(ref);
126 do { /* 5 cycles */
127 vis_ld64(ref[0], TMP0);
128
129 vis_ld64_2(ref, 8, TMP2);
130
131 vis_ld64_2(ref, 16, TMP4);
132 ref += stride;
133
134 vis_faligndata(TMP0, TMP2, REF_0);
135 vis_st64(REF_0, dest[0]);
136
137 vis_faligndata(TMP2, TMP4, REF_2);
138 vis_st64_2(REF_2, dest, 8);
139 dest += stride;
140 } while (--height);
141 }
142
143 static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * ref,
144 const int stride, int height)
145 {
146 ref = vis_alignaddr(ref);
147 do { /* 4 cycles */
148 vis_ld64(ref[0], TMP0);
149
150 vis_ld64(ref[8], TMP2);
151 ref += stride;
152
153 /* stall */
154
155 vis_faligndata(TMP0, TMP2, REF_0);
156 vis_st64(REF_0, dest[0]);
157 dest += stride;
158 } while (--height);
159 }
160
161
162 static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * ref,
163 const int stride, int height)
164 {
165 int stride_8 = stride + 8;
166
167 ref = vis_alignaddr(ref);
168
169 vis_ld64(ref[0], TMP0);
170
171 vis_ld64(ref[8], TMP2);
172
173 vis_ld64(ref[16], TMP4);
174
175 vis_ld64(dest[0], DST_0);
176
177 vis_ld64(dest[8], DST_2);
178
179 vis_ld64(constants_fe[0], MASK_fe);
180 vis_faligndata(TMP0, TMP2, REF_0);
181
182 vis_ld64(constants_7f[0], MASK_7f);
183 vis_faligndata(TMP2, TMP4, REF_2);
184
185 vis_ld64(constants128[0], CONST_128);
186
187 ref += stride;
188 height = (height >> 1) - 1;
189
190 do { /* 24 cycles */
191 vis_ld64(ref[0], TMP0);
192 vis_xor(DST_0, REF_0, TMP6);
193
194 vis_ld64_2(ref, 8, TMP2);
195 vis_and(TMP6, MASK_fe, TMP6);
196
197 vis_ld64_2(ref, 16, TMP4);
198 ref += stride;
199 vis_mul8x16(CONST_128, TMP6, TMP6);
200 vis_xor(DST_2, REF_2, TMP8);
201
202 vis_and(TMP8, MASK_fe, TMP8);
203
204 vis_or(DST_0, REF_0, TMP10);
205 vis_ld64_2(dest, stride, DST_0);
206 vis_mul8x16(CONST_128, TMP8, TMP8);
207
208 vis_or(DST_2, REF_2, TMP12);
209 vis_ld64_2(dest, stride_8, DST_2);
210
211 vis_ld64(ref[0], TMP14);
212 vis_and(TMP6, MASK_7f, TMP6);
213
214 vis_and(TMP8, MASK_7f, TMP8);
215
216 vis_psub16(TMP10, TMP6, TMP6);
217 vis_st64(TMP6, dest[0]);
218
219 vis_psub16(TMP12, TMP8, TMP8);
220 vis_st64_2(TMP8, dest, 8);
221
222 dest += stride;
223 vis_ld64_2(ref, 8, TMP16);
224 vis_faligndata(TMP0, TMP2, REF_0);
225
226 vis_ld64_2(ref, 16, TMP18);
227 vis_faligndata(TMP2, TMP4, REF_2);
228 ref += stride;
229
230 vis_xor(DST_0, REF_0, TMP20);
231
232 vis_and(TMP20, MASK_fe, TMP20);
233
234 vis_xor(DST_2, REF_2, TMP22);
235 vis_mul8x16(CONST_128, TMP20, TMP20);
236
237 vis_and(TMP22, MASK_fe, TMP22);
238
239 vis_or(DST_0, REF_0, TMP24);
240 vis_mul8x16(CONST_128, TMP22, TMP22);
241
242 vis_or(DST_2, REF_2, TMP26);
243
244 vis_ld64_2(dest, stride, DST_0);
245 vis_faligndata(TMP14, TMP16, REF_0);
246
247 vis_ld64_2(dest, stride_8, DST_2);
248 vis_faligndata(TMP16, TMP18, REF_2);
249
250 vis_and(TMP20, MASK_7f, TMP20);
251
252 vis_and(TMP22, MASK_7f, TMP22);
253
254 vis_psub16(TMP24, TMP20, TMP20);
255 vis_st64(TMP20, dest[0]);
256
257 vis_psub16(TMP26, TMP22, TMP22);
258 vis_st64_2(TMP22, dest, 8);
259 dest += stride;
260 } while (--height);
261
262 vis_ld64(ref[0], TMP0);
263 vis_xor(DST_0, REF_0, TMP6);
264
265 vis_ld64_2(ref, 8, TMP2);
266 vis_and(TMP6, MASK_fe, TMP6);
267
268 vis_ld64_2(ref, 16, TMP4);
269 vis_mul8x16(CONST_128, TMP6, TMP6);
270 vis_xor(DST_2, REF_2, TMP8);
271
272 vis_and(TMP8, MASK_fe, TMP8);
273
274 vis_or(DST_0, REF_0, TMP10);
275 vis_ld64_2(dest, stride, DST_0);
276 vis_mul8x16(CONST_128, TMP8, TMP8);
277
278 vis_or(DST_2, REF_2, TMP12);
279 vis_ld64_2(dest, stride_8, DST_2);
280
281 vis_ld64(ref[0], TMP14);
282 vis_and(TMP6, MASK_7f, TMP6);
283
284 vis_and(TMP8, MASK_7f, TMP8);
285
286 vis_psub16(TMP10, TMP6, TMP6);
287 vis_st64(TMP6, dest[0]);
288
289 vis_psub16(TMP12, TMP8, TMP8);
290 vis_st64_2(TMP8, dest, 8);
291
292 dest += stride;
293 vis_faligndata(TMP0, TMP2, REF_0);
294
295 vis_faligndata(TMP2, TMP4, REF_2);
296
297 vis_xor(DST_0, REF_0, TMP20);
298
299 vis_and(TMP20, MASK_fe, TMP20);
300
301 vis_xor(DST_2, REF_2, TMP22);
302 vis_mul8x16(CONST_128, TMP20, TMP20);
303
304 vis_and(TMP22, MASK_fe, TMP22);
305
306 vis_or(DST_0, REF_0, TMP24);
307 vis_mul8x16(CONST_128, TMP22, TMP22);
308
309 vis_or(DST_2, REF_2, TMP26);
310
311 vis_and(TMP20, MASK_7f, TMP20);
312
313 vis_and(TMP22, MASK_7f, TMP22);
314
315 vis_psub16(TMP24, TMP20, TMP20);
316 vis_st64(TMP20, dest[0]);
317
318 vis_psub16(TMP26, TMP22, TMP22);
319 vis_st64_2(TMP22, dest, 8);
320 }
321
322 static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * ref,
323 const int stride, int height)
324 {
325 ref = vis_alignaddr(ref);
326
327 vis_ld64(ref[0], TMP0);
328
329 vis_ld64(ref[8], TMP2);
330
331 vis_ld64(dest[0], DST_0);
332
333 vis_ld64(constants_fe[0], MASK_fe);
334
335 vis_ld64(constants_7f[0], MASK_7f);
336 vis_faligndata(TMP0, TMP2, REF_0);
337
338 vis_ld64(constants128[0], CONST_128);
339
340 ref += stride;
341 height = (height >> 1) - 1;
342
343 do { /* 12 cycles */
344 vis_ld64(ref[0], TMP0);
345 vis_xor(DST_0, REF_0, TMP4);
346
347 vis_ld64(ref[8], TMP2);
348 vis_and(TMP4, MASK_fe, TMP4);
349
350 vis_or(DST_0, REF_0, TMP6);
351 vis_ld64_2(dest, stride, DST_0);
352 ref += stride;
353 vis_mul8x16(CONST_128, TMP4, TMP4);
354
355 vis_ld64(ref[0], TMP12);
356 vis_faligndata(TMP0, TMP2, REF_0);
357
358 vis_ld64(ref[8], TMP2);
359 vis_xor(DST_0, REF_0, TMP0);
360 ref += stride;
361
362 vis_and(TMP0, MASK_fe, TMP0);
363
364 vis_and(TMP4, MASK_7f, TMP4);
365
366 vis_psub16(TMP6, TMP4, TMP4);
367 vis_st64(TMP4, dest[0]);
368 dest += stride;
369 vis_mul8x16(CONST_128, TMP0, TMP0);
370
371 vis_or(DST_0, REF_0, TMP6);
372 vis_ld64_2(dest, stride, DST_0);
373
374 vis_faligndata(TMP12, TMP2, REF_0);
375
376 vis_and(TMP0, MASK_7f, TMP0);
377
378 vis_psub16(TMP6, TMP0, TMP4);
379 vis_st64(TMP4, dest[0]);
380 dest += stride;
381 } while (--height);
382
383 vis_ld64(ref[0], TMP0);
384 vis_xor(DST_0, REF_0, TMP4);
385
386 vis_ld64(ref[8], TMP2);
387 vis_and(TMP4, MASK_fe, TMP4);
388
389 vis_or(DST_0, REF_0, TMP6);
390 vis_ld64_2(dest, stride, DST_0);
391 vis_mul8x16(CONST_128, TMP4, TMP4);
392
393 vis_faligndata(TMP0, TMP2, REF_0);
394
395 vis_xor(DST_0, REF_0, TMP0);
396
397 vis_and(TMP0, MASK_fe, TMP0);
398
399 vis_and(TMP4, MASK_7f, TMP4);
400
401 vis_psub16(TMP6, TMP4, TMP4);
402 vis_st64(TMP4, dest[0]);
403 dest += stride;
404 vis_mul8x16(CONST_128, TMP0, TMP0);
405
406 vis_or(DST_0, REF_0, TMP6);
407
408 vis_and(TMP0, MASK_7f, TMP0);
409
410 vis_psub16(TMP6, TMP0, TMP4);
411 vis_st64(TMP4, dest[0]);
412 }
413
414 static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * ref,
415 const int stride, int height)
416 {
417 unsigned long off = (unsigned long) ref & 0x7;
418 unsigned long off_plus_1 = off + 1;
419
420 ref = vis_alignaddr(ref);
421
422 vis_ld64(ref[0], TMP0);
423
424 vis_ld64_2(ref, 8, TMP2);
425
426 vis_ld64_2(ref, 16, TMP4);
427
428 vis_ld64(constants_fe[0], MASK_fe);
429
430 vis_ld64(constants_7f[0], MASK_7f);
431 vis_faligndata(TMP0, TMP2, REF_0);
432
433 vis_ld64(constants128[0], CONST_128);
434 vis_faligndata(TMP2, TMP4, REF_4);
435
436 if (off != 0x7) {
437 vis_alignaddr_g0((void *)off_plus_1);
438 vis_faligndata(TMP0, TMP2, REF_2);
439 vis_faligndata(TMP2, TMP4, REF_6);
440 } else {
441 vis_src1(TMP2, REF_2);
442 vis_src1(TMP4, REF_6);
443 }
444
445 ref += stride;
446 height = (height >> 1) - 1;
447
448 do { /* 34 cycles */
449 vis_ld64(ref[0], TMP0);
450 vis_xor(REF_0, REF_2, TMP6);
451
452 vis_ld64_2(ref, 8, TMP2);
453 vis_xor(REF_4, REF_6, TMP8);
454
455 vis_ld64_2(ref, 16, TMP4);
456 vis_and(TMP6, MASK_fe, TMP6);
457 ref += stride;
458
459 vis_ld64(ref[0], TMP14);
460 vis_mul8x16(CONST_128, TMP6, TMP6);
461 vis_and(TMP8, MASK_fe, TMP8);
462
463 vis_ld64_2(ref, 8, TMP16);
464 vis_mul8x16(CONST_128, TMP8, TMP8);
465 vis_or(REF_0, REF_2, TMP10);
466
467 vis_ld64_2(ref, 16, TMP18);
468 ref += stride;
469 vis_or(REF_4, REF_6, TMP12);
470
471 vis_alignaddr_g0((void *)off);
472
473 vis_faligndata(TMP0, TMP2, REF_0);
474
475 vis_faligndata(TMP2, TMP4, REF_4);
476
477 if (off != 0x7) {
478 vis_alignaddr_g0((void *)off_plus_1);
479 vis_faligndata(TMP0, TMP2, REF_2);
480 vis_faligndata(TMP2, TMP4, REF_6);
481 } else {
482 vis_src1(TMP2, REF_2);
483 vis_src1(TMP4, REF_6);
484 }
485
486 vis_and(TMP6, MASK_7f, TMP6);
487
488 vis_and(TMP8, MASK_7f, TMP8);
489
490 vis_psub16(TMP10, TMP6, TMP6);
491 vis_st64(TMP6, dest[0]);
492
493 vis_psub16(TMP12, TMP8, TMP8);
494 vis_st64_2(TMP8, dest, 8);
495 dest += stride;
496
497 vis_xor(REF_0, REF_2, TMP6);
498
499 vis_xor(REF_4, REF_6, TMP8);
500
501 vis_and(TMP6, MASK_fe, TMP6);
502
503 vis_mul8x16(CONST_128, TMP6, TMP6);
504 vis_and(TMP8, MASK_fe, TMP8);
505
506 vis_mul8x16(CONST_128, TMP8, TMP8);
507 vis_or(REF_0, REF_2, TMP10);
508
509 vis_or(REF_4, REF_6, TMP12);
510
511 vis_alignaddr_g0((void *)off);
512
513 vis_faligndata(TMP14, TMP16, REF_0);
514
515 vis_faligndata(TMP16, TMP18, REF_4);
516
517 if (off != 0x7) {
518 vis_alignaddr_g0((void *)off_plus_1);
519 vis_faligndata(TMP14, TMP16, REF_2);
520 vis_faligndata(TMP16, TMP18, REF_6);
521 } else {
522 vis_src1(TMP16, REF_2);
523 vis_src1(TMP18, REF_6);
524 }
525
526 vis_and(TMP6, MASK_7f, TMP6);
527
528 vis_and(TMP8, MASK_7f, TMP8);
529
530 vis_psub16(TMP10, TMP6, TMP6);
531 vis_st64(TMP6, dest[0]);
532
533 vis_psub16(TMP12, TMP8, TMP8);
534 vis_st64_2(TMP8, dest, 8);
535 dest += stride;
536 } while (--height);
537
538 vis_ld64(ref[0], TMP0);
539 vis_xor(REF_0, REF_2, TMP6);
540
541 vis_ld64_2(ref, 8, TMP2);
542 vis_xor(REF_4, REF_6, TMP8);
543
544 vis_ld64_2(ref, 16, TMP4);
545 vis_and(TMP6, MASK_fe, TMP6);
546
547 vis_mul8x16(CONST_128, TMP6, TMP6);
548 vis_and(TMP8, MASK_fe, TMP8);
549
550 vis_mul8x16(CONST_128, TMP8, TMP8);
551 vis_or(REF_0, REF_2, TMP10);
552
553 vis_or(REF_4, REF_6, TMP12);
554
555 vis_alignaddr_g0((void *)off);
556
557 vis_faligndata(TMP0, TMP2, REF_0);
558
559 vis_faligndata(TMP2, TMP4, REF_4);
560
561 if (off != 0x7) {
562 vis_alignaddr_g0((void *)off_plus_1);
563 vis_faligndata(TMP0, TMP2, REF_2);
564 vis_faligndata(TMP2, TMP4, REF_6);
565 } else {
566 vis_src1(TMP2, REF_2);
567 vis_src1(TMP4, REF_6);
568 }
569
570 vis_and(TMP6, MASK_7f, TMP6);
571
572 vis_and(TMP8, MASK_7f, TMP8);
573
574 vis_psub16(TMP10, TMP6, TMP6);
575 vis_st64(TMP6, dest[0]);
576
577 vis_psub16(TMP12, TMP8, TMP8);
578 vis_st64_2(TMP8, dest, 8);
579 dest += stride;
580
581 vis_xor(REF_0, REF_2, TMP6);
582
583 vis_xor(REF_4, REF_6, TMP8);
584
585 vis_and(TMP6, MASK_fe, TMP6);
586
587 vis_mul8x16(CONST_128, TMP6, TMP6);
588 vis_and(TMP8, MASK_fe, TMP8);
589
590 vis_mul8x16(CONST_128, TMP8, TMP8);
591 vis_or(REF_0, REF_2, TMP10);
592
593 vis_or(REF_4, REF_6, TMP12);
594
595 vis_and(TMP6, MASK_7f, TMP6);
596
597 vis_and(TMP8, MASK_7f, TMP8);
598
599 vis_psub16(TMP10, TMP6, TMP6);
600 vis_st64(TMP6, dest[0]);
601
602 vis_psub16(TMP12, TMP8, TMP8);
603 vis_st64_2(TMP8, dest, 8);
604 }
605
606 static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * ref,
607 const int stride, int height)
608 {
609 unsigned long off = (unsigned long) ref & 0x7;
610 unsigned long off_plus_1 = off + 1;
611
612 ref = vis_alignaddr(ref);
613
614 vis_ld64(ref[0], TMP0);
615
616 vis_ld64(ref[8], TMP2);
617
618 vis_ld64(constants_fe[0], MASK_fe);
619
620 vis_ld64(constants_7f[0], MASK_7f);
621
622 vis_ld64(constants128[0], CONST_128);
623 vis_faligndata(TMP0, TMP2, REF_0);
624
625 if (off != 0x7) {
626 vis_alignaddr_g0((void *)off_plus_1);
627 vis_faligndata(TMP0, TMP2, REF_2);
628 } else {
629 vis_src1(TMP2, REF_2);
630 }
631
632 ref += stride;
633 height = (height >> 1) - 1;
634
635 do { /* 20 cycles */
636 vis_ld64(ref[0], TMP0);
637 vis_xor(REF_0, REF_2, TMP4);
638
639 vis_ld64_2(ref, 8, TMP2);
640 vis_and(TMP4, MASK_fe, TMP4);
641 ref += stride;
642
643 vis_ld64(ref[0], TMP8);
644 vis_or(REF_0, REF_2, TMP6);
645 vis_mul8x16(CONST_128, TMP4, TMP4);
646
647 vis_alignaddr_g0((void *)off);
648
649 vis_ld64_2(ref, 8, TMP10);
650 ref += stride;
651 vis_faligndata(TMP0, TMP2, REF_0);
652
653 if (off != 0x7) {
654 vis_alignaddr_g0((void *)off_plus_1);
655 vis_faligndata(TMP0, TMP2, REF_2);
656 } else {
657 vis_src1(TMP2, REF_2);
658 }
659
660 vis_and(TMP4, MASK_7f, TMP4);
661
662 vis_psub16(TMP6, TMP4, DST_0);
663 vis_st64(DST_0, dest[0]);
664 dest += stride;
665
666 vis_xor(REF_0, REF_2, TMP12);
667
668 vis_and(TMP12, MASK_fe, TMP12);
669
670 vis_or(REF_0, REF_2, TMP14);
671 vis_mul8x16(CONST_128, TMP12, TMP12);
672
673 vis_alignaddr_g0((void *)off);
674 vis_faligndata(TMP8, TMP10, REF_0);
675 if (off != 0x7) {
676 vis_alignaddr_g0((void *)off_plus_1);
677 vis_faligndata(TMP8, TMP10, REF_2);
678 } else {
679 vis_src1(TMP10, REF_2);
680 }
681
682 vis_and(TMP12, MASK_7f, TMP12);
683
684 vis_psub16(TMP14, TMP12, DST_0);
685 vis_st64(DST_0, dest[0]);
686 dest += stride;
687 } while (--height);
688
689 vis_ld64(ref[0], TMP0);
690 vis_xor(REF_0, REF_2, TMP4);
691
692 vis_ld64_2(ref, 8, TMP2);
693 vis_and(TMP4, MASK_fe, TMP4);
694
695 vis_or(REF_0, REF_2, TMP6);
696 vis_mul8x16(CONST_128, TMP4, TMP4);
697
698 vis_alignaddr_g0((void *)off);
699
700 vis_faligndata(TMP0, TMP2, REF_0);
701
702 if (off != 0x7) {
703 vis_alignaddr_g0((void *)off_plus_1);
704 vis_faligndata(TMP0, TMP2, REF_2);
705 } else {
706 vis_src1(TMP2, REF_2);
707 }
708
709 vis_and(TMP4, MASK_7f, TMP4);
710
711 vis_psub16(TMP6, TMP4, DST_0);
712 vis_st64(DST_0, dest[0]);
713 dest += stride;
714
715 vis_xor(REF_0, REF_2, TMP12);
716
717 vis_and(TMP12, MASK_fe, TMP12);
718
719 vis_or(REF_0, REF_2, TMP14);
720 vis_mul8x16(CONST_128, TMP12, TMP12);
721
722 vis_and(TMP12, MASK_7f, TMP12);
723
724 vis_psub16(TMP14, TMP12, DST_0);
725 vis_st64(DST_0, dest[0]);
726 dest += stride;
727 }
728
729 static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * ref,
730 const int stride, int height)
731 {
732 unsigned long off = (unsigned long) ref & 0x7;
733 unsigned long off_plus_1 = off + 1;
734
735 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
736
737 vis_ld64(constants3[0], CONST_3);
738 vis_fzero(ZERO);
739 vis_ld64(constants256_512[0], CONST_256);
740
741 ref = vis_alignaddr(ref);
742 do { /* 26 cycles */
743 vis_ld64(ref[0], TMP0);
744
745 vis_ld64(ref[8], TMP2);
746
747 vis_alignaddr_g0((void *)off);
748
749 vis_ld64(ref[16], TMP4);
750
751 vis_ld64(dest[0], DST_0);
752 vis_faligndata(TMP0, TMP2, REF_0);
753
754 vis_ld64(dest[8], DST_2);
755 vis_faligndata(TMP2, TMP4, REF_4);
756
757 if (off != 0x7) {
758 vis_alignaddr_g0((void *)off_plus_1);
759 vis_faligndata(TMP0, TMP2, REF_2);
760 vis_faligndata(TMP2, TMP4, REF_6);
761 } else {
762 vis_src1(TMP2, REF_2);
763 vis_src1(TMP4, REF_6);
764 }
765
766 vis_mul8x16au(REF_0, CONST_256, TMP0);
767
768 vis_pmerge(ZERO, REF_2, TMP4);
769 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
770
771 vis_pmerge(ZERO, REF_2_1, TMP6);
772
773 vis_padd16(TMP0, TMP4, TMP0);
774
775 vis_mul8x16al(DST_0, CONST_512, TMP4);
776 vis_padd16(TMP2, TMP6, TMP2);
777
778 vis_mul8x16al(DST_1, CONST_512, TMP6);
779
780 vis_mul8x16au(REF_6, CONST_256, TMP12);
781
782 vis_padd16(TMP0, TMP4, TMP0);
783 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
784
785 vis_padd16(TMP2, TMP6, TMP2);
786 vis_mul8x16au(REF_4, CONST_256, TMP16);
787
788 vis_padd16(TMP0, CONST_3, TMP8);
789 vis_mul8x16au(REF_4_1, CONST_256, TMP18);
790
791 vis_padd16(TMP2, CONST_3, TMP10);
792 vis_pack16(TMP8, DST_0);
793
794 vis_pack16(TMP10, DST_1);
795 vis_padd16(TMP16, TMP12, TMP0);
796
797 vis_st64(DST_0, dest[0]);
798 vis_mul8x16al(DST_2, CONST_512, TMP4);
799 vis_padd16(TMP18, TMP14, TMP2);
800
801 vis_mul8x16al(DST_3, CONST_512, TMP6);
802 vis_padd16(TMP0, CONST_3, TMP0);
803
804 vis_padd16(TMP2, CONST_3, TMP2);
805
806 vis_padd16(TMP0, TMP4, TMP0);
807
808 vis_padd16(TMP2, TMP6, TMP2);
809 vis_pack16(TMP0, DST_2);
810
811 vis_pack16(TMP2, DST_3);
812 vis_st64(DST_2, dest[8]);
813
814 ref += stride;
815 dest += stride;
816 } while (--height);
817 }
818
819 static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * ref,
820 const int stride, int height)
821 {
822 unsigned long off = (unsigned long) ref & 0x7;
823 unsigned long off_plus_1 = off + 1;
824 int stride_times_2 = stride << 1;
825
826 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
827
828 vis_ld64(constants3[0], CONST_3);
829 vis_fzero(ZERO);
830 vis_ld64(constants256_512[0], CONST_256);
831
832 ref = vis_alignaddr(ref);
833 height >>= 2;
834 do { /* 47 cycles */
835 vis_ld64(ref[0], TMP0);
836
837 vis_ld64_2(ref, 8, TMP2);
838 ref += stride;
839
840 vis_alignaddr_g0((void *)off);
841
842 vis_ld64(ref[0], TMP4);
843 vis_faligndata(TMP0, TMP2, REF_0);
844
845 vis_ld64_2(ref, 8, TMP6);
846 ref += stride;
847
848 vis_ld64(ref[0], TMP8);
849
850 vis_ld64_2(ref, 8, TMP10);
851 ref += stride;
852 vis_faligndata(TMP4, TMP6, REF_4);
853
854 vis_ld64(ref[0], TMP12);
855
856 vis_ld64_2(ref, 8, TMP14);
857 ref += stride;
858 vis_faligndata(TMP8, TMP10, REF_S0);
859
860 vis_faligndata(TMP12, TMP14, REF_S4);
861
862 if (off != 0x7) {
863 vis_alignaddr_g0((void *)off_plus_1);
864
865 vis_ld64(dest[0], DST_0);
866 vis_faligndata(TMP0, TMP2, REF_2);
867
868 vis_ld64_2(dest, stride, DST_2);
869 vis_faligndata(TMP4, TMP6, REF_6);
870
871 vis_faligndata(TMP8, TMP10, REF_S2);
872
873 vis_faligndata(TMP12, TMP14, REF_S6);
874 } else {
875 vis_ld64(dest[0], DST_0);
876 vis_src1(TMP2, REF_2);
877
878 vis_ld64_2(dest, stride, DST_2);
879 vis_src1(TMP6, REF_6);
880
881 vis_src1(TMP10, REF_S2);
882
883 vis_src1(TMP14, REF_S6);
884 }
885
886 vis_pmerge(ZERO, REF_0, TMP0);
887 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
888
889 vis_pmerge(ZERO, REF_2, TMP4);
890 vis_mul8x16au(REF_2_1, CONST_256, TMP6);
891
892 vis_padd16(TMP0, CONST_3, TMP0);
893 vis_mul8x16al(DST_0, CONST_512, TMP16);
894
895 vis_padd16(TMP2, CONST_3, TMP2);
896 vis_mul8x16al(DST_1, CONST_512, TMP18);
897
898 vis_padd16(TMP0, TMP4, TMP0);
899 vis_mul8x16au(REF_4, CONST_256, TMP8);
900
901 vis_padd16(TMP2, TMP6, TMP2);
902 vis_mul8x16au(REF_4_1, CONST_256, TMP10);
903
904 vis_padd16(TMP0, TMP16, TMP0);
905 vis_mul8x16au(REF_6, CONST_256, TMP12);
906
907 vis_padd16(TMP2, TMP18, TMP2);
908 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
909
910 vis_padd16(TMP8, CONST_3, TMP8);
911 vis_mul8x16al(DST_2, CONST_512, TMP16);
912
913 vis_padd16(TMP8, TMP12, TMP8);
914 vis_mul8x16al(DST_3, CONST_512, TMP18);
915
916 vis_padd16(TMP10, TMP14, TMP10);
917 vis_pack16(TMP0, DST_0);
918
919 vis_pack16(TMP2, DST_1);
920 vis_st64(DST_0, dest[0]);
921 dest += stride;
922 vis_padd16(TMP10, CONST_3, TMP10);
923
924 vis_ld64_2(dest, stride, DST_0);
925 vis_padd16(TMP8, TMP16, TMP8);
926
927 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
928 vis_padd16(TMP10, TMP18, TMP10);
929 vis_pack16(TMP8, DST_2);
930
931 vis_pack16(TMP10, DST_3);
932 vis_st64(DST_2, dest[0]);
933 dest += stride;
934
935 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
936 vis_pmerge(ZERO, REF_S0, TMP0);
937
938 vis_pmerge(ZERO, REF_S2, TMP24);
939 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
940
941 vis_padd16(TMP0, CONST_3, TMP0);
942 vis_mul8x16au(REF_S4, CONST_256, TMP8);
943
944 vis_padd16(TMP2, CONST_3, TMP2);
945 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
946
947 vis_padd16(TMP0, TMP24, TMP0);
948 vis_mul8x16au(REF_S6, CONST_256, TMP12);
949
950 vis_padd16(TMP2, TMP6, TMP2);
951 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
952
953 vis_padd16(TMP8, CONST_3, TMP8);
954 vis_mul8x16al(DST_0, CONST_512, TMP16);
955
956 vis_padd16(TMP10, CONST_3, TMP10);
957 vis_mul8x16al(DST_1, CONST_512, TMP18);
958
959 vis_padd16(TMP8, TMP12, TMP8);
960 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
961
962 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
963 vis_padd16(TMP0, TMP16, TMP0);
964
965 vis_padd16(TMP2, TMP18, TMP2);
966 vis_pack16(TMP0, DST_0);
967
968 vis_padd16(TMP10, TMP14, TMP10);
969 vis_pack16(TMP2, DST_1);
970 vis_st64(DST_0, dest[0]);
971 dest += stride;
972
973 vis_padd16(TMP8, TMP20, TMP8);
974
975 vis_padd16(TMP10, TMP22, TMP10);
976 vis_pack16(TMP8, DST_2);
977
978 vis_pack16(TMP10, DST_3);
979 vis_st64(DST_2, dest[0]);
980 dest += stride;
981 } while (--height);
982 }
983
984 static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * ref,
985 const int stride, int height)
986 {
987 ref = vis_alignaddr(ref);
988 vis_ld64(ref[0], TMP0);
989
990 vis_ld64_2(ref, 8, TMP2);
991
992 vis_ld64_2(ref, 16, TMP4);
993 ref += stride;
994
995 vis_ld64(ref[0], TMP6);
996 vis_faligndata(TMP0, TMP2, REF_0);
997
998 vis_ld64_2(ref, 8, TMP8);
999 vis_faligndata(TMP2, TMP4, REF_4);
1000
1001 vis_ld64_2(ref, 16, TMP10);
1002 ref += stride;
1003
1004 vis_ld64(constants_fe[0], MASK_fe);
1005 vis_faligndata(TMP6, TMP8, REF_2);
1006
1007 vis_ld64(constants_7f[0], MASK_7f);
1008 vis_faligndata(TMP8, TMP10, REF_6);
1009
1010 vis_ld64(constants128[0], CONST_128);
1011 height = (height >> 1) - 1;
1012 do { /* 24 cycles */
1013 vis_ld64(ref[0], TMP0);
1014 vis_xor(REF_0, REF_2, TMP12);
1015
1016 vis_ld64_2(ref, 8, TMP2);
1017 vis_xor(REF_4, REF_6, TMP16);
1018
1019 vis_ld64_2(ref, 16, TMP4);
1020 ref += stride;
1021 vis_or(REF_0, REF_2, TMP14);
1022
1023 vis_ld64(ref[0], TMP6);
1024 vis_or(REF_4, REF_6, TMP18);
1025
1026 vis_ld64_2(ref, 8, TMP8);
1027 vis_faligndata(TMP0, TMP2, REF_0);
1028
1029 vis_ld64_2(ref, 16, TMP10);
1030 ref += stride;
1031 vis_faligndata(TMP2, TMP4, REF_4);
1032
1033 vis_and(TMP12, MASK_fe, TMP12);
1034
1035 vis_and(TMP16, MASK_fe, TMP16);
1036 vis_mul8x16(CONST_128, TMP12, TMP12);
1037
1038 vis_mul8x16(CONST_128, TMP16, TMP16);
1039 vis_xor(REF_0, REF_2, TMP0);
1040
1041 vis_xor(REF_4, REF_6, TMP2);
1042
1043 vis_or(REF_0, REF_2, TMP20);
1044
1045 vis_and(TMP12, MASK_7f, TMP12);
1046
1047 vis_and(TMP16, MASK_7f, TMP16);
1048
1049 vis_psub16(TMP14, TMP12, TMP12);
1050 vis_st64(TMP12, dest[0]);
1051
1052 vis_psub16(TMP18, TMP16, TMP16);
1053 vis_st64_2(TMP16, dest, 8);
1054 dest += stride;
1055
1056 vis_or(REF_4, REF_6, TMP18);
1057
1058 vis_and(TMP0, MASK_fe, TMP0);
1059
1060 vis_and(TMP2, MASK_fe, TMP2);
1061 vis_mul8x16(CONST_128, TMP0, TMP0);
1062
1063 vis_faligndata(TMP6, TMP8, REF_2);
1064 vis_mul8x16(CONST_128, TMP2, TMP2);
1065
1066 vis_faligndata(TMP8, TMP10, REF_6);
1067
1068 vis_and(TMP0, MASK_7f, TMP0);
1069
1070 vis_and(TMP2, MASK_7f, TMP2);
1071
1072 vis_psub16(TMP20, TMP0, TMP0);
1073 vis_st64(TMP0, dest[0]);
1074
1075 vis_psub16(TMP18, TMP2, TMP2);
1076 vis_st64_2(TMP2, dest, 8);
1077 dest += stride;
1078 } while (--height);
1079
1080 vis_ld64(ref[0], TMP0);
1081 vis_xor(REF_0, REF_2, TMP12);
1082
1083 vis_ld64_2(ref, 8, TMP2);
1084 vis_xor(REF_4, REF_6, TMP16);
1085
1086 vis_ld64_2(ref, 16, TMP4);
1087 vis_or(REF_0, REF_2, TMP14);
1088
1089 vis_or(REF_4, REF_6, TMP18);
1090
1091 vis_faligndata(TMP0, TMP2, REF_0);
1092
1093 vis_faligndata(TMP2, TMP4, REF_4);
1094
1095 vis_and(TMP12, MASK_fe, TMP12);
1096
1097 vis_and(TMP16, MASK_fe, TMP16);
1098 vis_mul8x16(CONST_128, TMP12, TMP12);
1099
1100 vis_mul8x16(CONST_128, TMP16, TMP16);
1101 vis_xor(REF_0, REF_2, TMP0);
1102
1103 vis_xor(REF_4, REF_6, TMP2);
1104
1105 vis_or(REF_0, REF_2, TMP20);
1106
1107 vis_and(TMP12, MASK_7f, TMP12);
1108
1109 vis_and(TMP16, MASK_7f, TMP16);
1110
1111 vis_psub16(TMP14, TMP12, TMP12);
1112 vis_st64(TMP12, dest[0]);
1113
1114 vis_psub16(TMP18, TMP16, TMP16);
1115 vis_st64_2(TMP16, dest, 8);
1116 dest += stride;
1117
1118 vis_or(REF_4, REF_6, TMP18);
1119
1120 vis_and(TMP0, MASK_fe, TMP0);
1121
1122 vis_and(TMP2, MASK_fe, TMP2);
1123 vis_mul8x16(CONST_128, TMP0, TMP0);
1124
1125 vis_mul8x16(CONST_128, TMP2, TMP2);
1126
1127 vis_and(TMP0, MASK_7f, TMP0);
1128
1129 vis_and(TMP2, MASK_7f, TMP2);
1130
1131 vis_psub16(TMP20, TMP0, TMP0);
1132 vis_st64(TMP0, dest[0]);
1133
1134 vis_psub16(TMP18, TMP2, TMP2);
1135 vis_st64_2(TMP2, dest, 8);
1136 }
1137
1138 static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * ref,
1139 const int stride, int height)
1140 {
1141 ref = vis_alignaddr(ref);
1142 vis_ld64(ref[0], TMP0);
1143
1144 vis_ld64_2(ref, 8, TMP2);
1145 ref += stride;
1146
1147 vis_ld64(ref[0], TMP4);
1148
1149 vis_ld64_2(ref, 8, TMP6);
1150 ref += stride;
1151
1152 vis_ld64(constants_fe[0], MASK_fe);
1153 vis_faligndata(TMP0, TMP2, REF_0);
1154
1155 vis_ld64(constants_7f[0], MASK_7f);
1156 vis_faligndata(TMP4, TMP6, REF_2);
1157
1158 vis_ld64(constants128[0], CONST_128);
1159 height = (height >> 1) - 1;
1160 do { /* 12 cycles */
1161 vis_ld64(ref[0], TMP0);
1162 vis_xor(REF_0, REF_2, TMP4);
1163
1164 vis_ld64_2(ref, 8, TMP2);
1165 ref += stride;
1166 vis_and(TMP4, MASK_fe, TMP4);
1167
1168 vis_or(REF_0, REF_2, TMP6);
1169 vis_mul8x16(CONST_128, TMP4, TMP4);
1170
1171 vis_faligndata(TMP0, TMP2, REF_0);
1172 vis_ld64(ref[0], TMP0);
1173
1174 vis_ld64_2(ref, 8, TMP2);
1175 ref += stride;
1176 vis_xor(REF_0, REF_2, TMP12);
1177
1178 vis_and(TMP4, MASK_7f, TMP4);
1179
1180 vis_and(TMP12, MASK_fe, TMP12);
1181
1182 vis_mul8x16(CONST_128, TMP12, TMP12);
1183 vis_or(REF_0, REF_2, TMP14);
1184
1185 vis_psub16(TMP6, TMP4, DST_0);
1186 vis_st64(DST_0, dest[0]);
1187 dest += stride;
1188
1189 vis_faligndata(TMP0, TMP2, REF_2);
1190
1191 vis_and(TMP12, MASK_7f, TMP12);
1192
1193 vis_psub16(TMP14, TMP12, DST_0);
1194 vis_st64(DST_0, dest[0]);
1195 dest += stride;
1196 } while (--height);
1197
1198 vis_ld64(ref[0], TMP0);
1199 vis_xor(REF_0, REF_2, TMP4);
1200
1201 vis_ld64_2(ref, 8, TMP2);
1202 vis_and(TMP4, MASK_fe, TMP4);
1203
1204 vis_or(REF_0, REF_2, TMP6);
1205 vis_mul8x16(CONST_128, TMP4, TMP4);
1206
1207 vis_faligndata(TMP0, TMP2, REF_0);
1208
1209 vis_xor(REF_0, REF_2, TMP12);
1210
1211 vis_and(TMP4, MASK_7f, TMP4);
1212
1213 vis_and(TMP12, MASK_fe, TMP12);
1214
1215 vis_mul8x16(CONST_128, TMP12, TMP12);
1216 vis_or(REF_0, REF_2, TMP14);
1217
1218 vis_psub16(TMP6, TMP4, DST_0);
1219 vis_st64(DST_0, dest[0]);
1220 dest += stride;
1221
1222 vis_and(TMP12, MASK_7f, TMP12);
1223
1224 vis_psub16(TMP14, TMP12, DST_0);
1225 vis_st64(DST_0, dest[0]);
1226 }
1227
1228 static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * ref,
1229 const int stride, int height)
1230 {
1231 int stride_8 = stride + 8;
1232 int stride_16 = stride + 16;
1233
1234 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1235
1236 ref = vis_alignaddr(ref);
1237
1238 vis_ld64(ref[ 0], TMP0);
1239 vis_fzero(ZERO);
1240
1241 vis_ld64(ref[ 8], TMP2);
1242
1243 vis_ld64(ref[16], TMP4);
1244
1245 vis_ld64(constants3[0], CONST_3);
1246 vis_faligndata(TMP0, TMP2, REF_2);
1247
1248 vis_ld64(constants256_512[0], CONST_256);
1249 vis_faligndata(TMP2, TMP4, REF_6);
1250 height >>= 1;
1251
1252 do { /* 31 cycles */
1253 vis_ld64_2(ref, stride, TMP0);
1254 vis_pmerge(ZERO, REF_2, TMP12);
1255 vis_mul8x16au(REF_2_1, CONST_256, TMP14);
1256
1257 vis_ld64_2(ref, stride_8, TMP2);
1258 vis_pmerge(ZERO, REF_6, TMP16);
1259 vis_mul8x16au(REF_6_1, CONST_256, TMP18);
1260
1261 vis_ld64_2(ref, stride_16, TMP4);
1262 ref += stride;
1263
1264 vis_ld64(dest[0], DST_0);
1265 vis_faligndata(TMP0, TMP2, REF_0);
1266
1267 vis_ld64_2(dest, 8, DST_2);
1268 vis_faligndata(TMP2, TMP4, REF_4);
1269
1270 vis_ld64_2(ref, stride, TMP6);
1271 vis_pmerge(ZERO, REF_0, TMP0);
1272 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
1273
1274 vis_ld64_2(ref, stride_8, TMP8);
1275 vis_pmerge(ZERO, REF_4, TMP4);
1276
1277 vis_ld64_2(ref, stride_16, TMP10);
1278 ref += stride;
1279
1280 vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
1281 vis_faligndata(TMP6, TMP8, REF_2);
1282 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
1283
1284 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
1285 vis_faligndata(TMP8, TMP10, REF_6);
1286 vis_mul8x16al(DST_0, CONST_512, TMP20);
1287
1288 vis_padd16(TMP0, CONST_3, TMP0);
1289 vis_mul8x16al(DST_1, CONST_512, TMP22);
1290
1291 vis_padd16(TMP2, CONST_3, TMP2);
1292 vis_mul8x16al(DST_2, CONST_512, TMP24);
1293
1294 vis_padd16(TMP4, CONST_3, TMP4);
1295 vis_mul8x16al(DST_3, CONST_512, TMP26);
1296
1297 vis_padd16(TMP6, CONST_3, TMP6);
1298
1299 vis_padd16(TMP12, TMP20, TMP12);
1300 vis_mul8x16al(REF_S0, CONST_512, TMP20);
1301
1302 vis_padd16(TMP14, TMP22, TMP14);
1303 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
1304
1305 vis_padd16(TMP16, TMP24, TMP16);
1306 vis_mul8x16al(REF_S2, CONST_512, TMP24);
1307
1308 vis_padd16(TMP18, TMP26, TMP18);
1309 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
1310
1311 vis_padd16(TMP12, TMP0, TMP12);
1312 vis_mul8x16au(REF_2, CONST_256, TMP28);
1313
1314 vis_padd16(TMP14, TMP2, TMP14);
1315 vis_mul8x16au(REF_2_1, CONST_256, TMP30);
1316
1317 vis_padd16(TMP16, TMP4, TMP16);
1318 vis_mul8x16au(REF_6, CONST_256, REF_S4);
1319
1320 vis_padd16(TMP18, TMP6, TMP18);
1321 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
1322
1323 vis_pack16(TMP12, DST_0);
1324 vis_padd16(TMP28, TMP0, TMP12);
1325
1326 vis_pack16(TMP14, DST_1);
1327 vis_st64(DST_0, dest[0]);
1328 vis_padd16(TMP30, TMP2, TMP14);
1329
1330 vis_pack16(TMP16, DST_2);
1331 vis_padd16(REF_S4, TMP4, TMP16);
1332
1333 vis_pack16(TMP18, DST_3);
1334 vis_st64_2(DST_2, dest, 8);
1335 dest += stride;
1336 vis_padd16(REF_S6, TMP6, TMP18);
1337
1338 vis_padd16(TMP12, TMP20, TMP12);
1339
1340 vis_padd16(TMP14, TMP22, TMP14);
1341 vis_pack16(TMP12, DST_0);
1342
1343 vis_padd16(TMP16, TMP24, TMP16);
1344 vis_pack16(TMP14, DST_1);
1345 vis_st64(DST_0, dest[0]);
1346
1347 vis_padd16(TMP18, TMP26, TMP18);
1348 vis_pack16(TMP16, DST_2);
1349
1350 vis_pack16(TMP18, DST_3);
1351 vis_st64_2(DST_2, dest, 8);
1352 dest += stride;
1353 } while (--height);
1354 }
1355
1356 static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * ref,
1357 const int stride, int height)
1358 {
1359 int stride_8 = stride + 8;
1360
1361 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1362
1363 ref = vis_alignaddr(ref);
1364
1365 vis_ld64(ref[ 0], TMP0);
1366 vis_fzero(ZERO);
1367
1368 vis_ld64(ref[ 8], TMP2);
1369
1370 vis_ld64(constants3[0], CONST_3);
1371 vis_faligndata(TMP0, TMP2, REF_2);
1372
1373 vis_ld64(constants256_512[0], CONST_256);
1374
1375 height >>= 1;
1376 do { /* 20 cycles */
1377 vis_ld64_2(ref, stride, TMP0);
1378 vis_pmerge(ZERO, REF_2, TMP8);
1379 vis_mul8x16au(REF_2_1, CONST_256, TMP10);
1380
1381 vis_ld64_2(ref, stride_8, TMP2);
1382 ref += stride;
1383
1384 vis_ld64(dest[0], DST_0);
1385
1386 vis_ld64_2(dest, stride, DST_2);
1387 vis_faligndata(TMP0, TMP2, REF_0);
1388
1389 vis_ld64_2(ref, stride, TMP4);
1390 vis_mul8x16al(DST_0, CONST_512, TMP16);
1391 vis_pmerge(ZERO, REF_0, TMP12);
1392
1393 vis_ld64_2(ref, stride_8, TMP6);
1394 ref += stride;
1395 vis_mul8x16al(DST_1, CONST_512, TMP18);
1396 vis_pmerge(ZERO, REF_0_1, TMP14);
1397
1398 vis_padd16(TMP12, CONST_3, TMP12);
1399 vis_mul8x16al(DST_2, CONST_512, TMP24);
1400
1401 vis_padd16(TMP14, CONST_3, TMP14);
1402 vis_mul8x16al(DST_3, CONST_512, TMP26);
1403
1404 vis_faligndata(TMP4, TMP6, REF_2);
1405
1406 vis_padd16(TMP8, TMP12, TMP8);
1407
1408 vis_padd16(TMP10, TMP14, TMP10);
1409 vis_mul8x16au(REF_2, CONST_256, TMP20);
1410
1411 vis_padd16(TMP8, TMP16, TMP0);
1412 vis_mul8x16au(REF_2_1, CONST_256, TMP22);
1413
1414 vis_padd16(TMP10, TMP18, TMP2);
1415 vis_pack16(TMP0, DST_0);
1416
1417 vis_pack16(TMP2, DST_1);
1418 vis_st64(DST_0, dest[0]);
1419 dest += stride;
1420 vis_padd16(TMP12, TMP20, TMP12);
1421
1422 vis_padd16(TMP14, TMP22, TMP14);
1423
1424 vis_padd16(TMP12, TMP24, TMP0);
1425
1426 vis_padd16(TMP14, TMP26, TMP2);
1427 vis_pack16(TMP0, DST_2);
1428
1429 vis_pack16(TMP2, DST_3);
1430 vis_st64(DST_2, dest[0]);
1431 dest += stride;
1432 } while (--height);
1433 }
1434
1435 static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * ref,
1436 const int stride, int height)
1437 {
1438 unsigned long off = (unsigned long) ref & 0x7;
1439 unsigned long off_plus_1 = off + 1;
1440 int stride_8 = stride + 8;
1441 int stride_16 = stride + 16;
1442
1443 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1444
1445 ref = vis_alignaddr(ref);
1446
1447 vis_ld64(ref[ 0], TMP0);
1448 vis_fzero(ZERO);
1449
1450 vis_ld64(ref[ 8], TMP2);
1451
1452 vis_ld64(ref[16], TMP4);
1453
1454 vis_ld64(constants2[0], CONST_2);
1455 vis_faligndata(TMP0, TMP2, REF_S0);
1456
1457 vis_ld64(constants256_512[0], CONST_256);
1458 vis_faligndata(TMP2, TMP4, REF_S4);
1459
1460 if (off != 0x7) {
1461 vis_alignaddr_g0((void *)off_plus_1);
1462 vis_faligndata(TMP0, TMP2, REF_S2);
1463 vis_faligndata(TMP2, TMP4, REF_S6);
1464 } else {
1465 vis_src1(TMP2, REF_S2);
1466 vis_src1(TMP4, REF_S6);
1467 }
1468
1469 height >>= 1;
1470 do {
1471 vis_ld64_2(ref, stride, TMP0);
1472 vis_mul8x16au(REF_S0, CONST_256, TMP12);
1473 vis_pmerge(ZERO, REF_S0_1, TMP14);
1474
1475 vis_alignaddr_g0((void *)off);
1476
1477 vis_ld64_2(ref, stride_8, TMP2);
1478 vis_mul8x16au(REF_S2, CONST_256, TMP16);
1479 vis_pmerge(ZERO, REF_S2_1, TMP18);
1480
1481 vis_ld64_2(ref, stride_16, TMP4);
1482 ref += stride;
1483 vis_mul8x16au(REF_S4, CONST_256, TMP20);
1484 vis_pmerge(ZERO, REF_S4_1, TMP22);
1485
1486 vis_ld64_2(ref, stride, TMP6);
1487 vis_mul8x16au(REF_S6, CONST_256, TMP24);
1488 vis_pmerge(ZERO, REF_S6_1, TMP26);
1489
1490 vis_ld64_2(ref, stride_8, TMP8);
1491 vis_faligndata(TMP0, TMP2, REF_0);
1492
1493 vis_ld64_2(ref, stride_16, TMP10);
1494 ref += stride;
1495 vis_faligndata(TMP2, TMP4, REF_4);
1496
1497 vis_faligndata(TMP6, TMP8, REF_S0);
1498
1499 vis_faligndata(TMP8, TMP10, REF_S4);
1500
1501 if (off != 0x7) {
1502 vis_alignaddr_g0((void *)off_plus_1);
1503 vis_faligndata(TMP0, TMP2, REF_2);
1504 vis_faligndata(TMP2, TMP4, REF_6);
1505 vis_faligndata(TMP6, TMP8, REF_S2);
1506 vis_faligndata(TMP8, TMP10, REF_S6);
1507 } else {
1508 vis_src1(TMP2, REF_2);
1509 vis_src1(TMP4, REF_6);
1510 vis_src1(TMP8, REF_S2);
1511 vis_src1(TMP10, REF_S6);
1512 }
1513
1514 vis_mul8x16au(REF_0, CONST_256, TMP0);
1515 vis_pmerge(ZERO, REF_0_1, TMP2);
1516
1517 vis_mul8x16au(REF_2, CONST_256, TMP4);
1518 vis_pmerge(ZERO, REF_2_1, TMP6);
1519
1520 vis_padd16(TMP0, CONST_2, TMP8);
1521 vis_mul8x16au(REF_4, CONST_256, TMP0);
1522
1523 vis_padd16(TMP2, CONST_2, TMP10);
1524 vis_mul8x16au(REF_4_1, CONST_256, TMP2);
1525
1526 vis_padd16(TMP8, TMP4, TMP8);
1527 vis_mul8x16au(REF_6, CONST_256, TMP4);
1528
1529 vis_padd16(TMP10, TMP6, TMP10);
1530 vis_mul8x16au(REF_6_1, CONST_256, TMP6);
1531
1532 vis_padd16(TMP12, TMP8, TMP12);
1533
1534 vis_padd16(TMP14, TMP10, TMP14);
1535
1536 vis_padd16(TMP12, TMP16, TMP12);
1537
1538 vis_padd16(TMP14, TMP18, TMP14);
1539 vis_pack16(TMP12, DST_0);
1540
1541 vis_pack16(TMP14, DST_1);
1542 vis_st64(DST_0, dest[0]);
1543 vis_padd16(TMP0, CONST_2, TMP12);
1544
1545 vis_mul8x16au(REF_S0, CONST_256, TMP0);
1546 vis_padd16(TMP2, CONST_2, TMP14);
1547
1548 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
1549 vis_padd16(TMP12, TMP4, TMP12);
1550
1551 vis_mul8x16au(REF_S2, CONST_256, TMP4);
1552 vis_padd16(TMP14, TMP6, TMP14);
1553
1554 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
1555 vis_padd16(TMP20, TMP12, TMP20);
1556
1557 vis_padd16(TMP22, TMP14, TMP22);
1558
1559 vis_padd16(TMP20, TMP24, TMP20);
1560
1561 vis_padd16(TMP22, TMP26, TMP22);
1562 vis_pack16(TMP20, DST_2);
1563
1564 vis_pack16(TMP22, DST_3);
1565 vis_st64_2(DST_2, dest, 8);
1566 dest += stride;
1567 vis_padd16(TMP0, TMP4, TMP24);
1568
1569 vis_mul8x16au(REF_S4, CONST_256, TMP0);
1570 vis_padd16(TMP2, TMP6, TMP26);
1571
1572 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
1573 vis_padd16(TMP24, TMP8, TMP24);
1574
1575 vis_padd16(TMP26, TMP10, TMP26);
1576 vis_pack16(TMP24, DST_0);
1577
1578 vis_pack16(TMP26, DST_1);
1579 vis_st64(DST_0, dest[0]);
1580 vis_pmerge(ZERO, REF_S6, TMP4);
1581
1582 vis_pmerge(ZERO, REF_S6_1, TMP6);
1583
1584 vis_padd16(TMP0, TMP4, TMP0);
1585
1586 vis_padd16(TMP2, TMP6, TMP2);
1587
1588 vis_padd16(TMP0, TMP12, TMP0);
1589
1590 vis_padd16(TMP2, TMP14, TMP2);
1591 vis_pack16(TMP0, DST_2);
1592
1593 vis_pack16(TMP2, DST_3);
1594 vis_st64_2(DST_2, dest, 8);
1595 dest += stride;
1596 } while (--height);
1597 }
1598
1599 static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * ref,
1600 const int stride, int height)
1601 {
1602 unsigned long off = (unsigned long) ref & 0x7;
1603 unsigned long off_plus_1 = off + 1;
1604 int stride_8 = stride + 8;
1605
1606 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1607
1608 ref = vis_alignaddr(ref);
1609
1610 vis_ld64(ref[ 0], TMP0);
1611 vis_fzero(ZERO);
1612
1613 vis_ld64(ref[ 8], TMP2);
1614
1615 vis_ld64(constants2[0], CONST_2);
1616
1617 vis_ld64(constants256_512[0], CONST_256);
1618 vis_faligndata(TMP0, TMP2, REF_S0);
1619
1620 if (off != 0x7) {
1621 vis_alignaddr_g0((void *)off_plus_1);
1622 vis_faligndata(TMP0, TMP2, REF_S2);
1623 } else {
1624 vis_src1(TMP2, REF_S2);
1625 }
1626
1627 height >>= 1;
1628 do { /* 26 cycles */
1629 vis_ld64_2(ref, stride, TMP0);
1630 vis_mul8x16au(REF_S0, CONST_256, TMP8);
1631 vis_pmerge(ZERO, REF_S2, TMP12);
1632
1633 vis_alignaddr_g0((void *)off);
1634
1635 vis_ld64_2(ref, stride_8, TMP2);
1636 ref += stride;
1637 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
1638 vis_pmerge(ZERO, REF_S2_1, TMP14);
1639
1640 vis_ld64_2(ref, stride, TMP4);
1641
1642 vis_ld64_2(ref, stride_8, TMP6);
1643 ref += stride;
1644 vis_faligndata(TMP0, TMP2, REF_S4);
1645
1646 vis_pmerge(ZERO, REF_S4, TMP18);
1647
1648 vis_pmerge(ZERO, REF_S4_1, TMP20);
1649
1650 vis_faligndata(TMP4, TMP6, REF_S0);
1651
1652 if (off != 0x7) {
1653 vis_alignaddr_g0((void *)off_plus_1);
1654 vis_faligndata(TMP0, TMP2, REF_S6);
1655 vis_faligndata(TMP4, TMP6, REF_S2);
1656 } else {
1657 vis_src1(TMP2, REF_S6);
1658 vis_src1(TMP6, REF_S2);
1659 }
1660
1661 vis_padd16(TMP18, CONST_2, TMP18);
1662 vis_mul8x16au(REF_S6, CONST_256, TMP22);
1663
1664 vis_padd16(TMP20, CONST_2, TMP20);
1665 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
1666
1667 vis_mul8x16au(REF_S0, CONST_256, TMP26);
1668 vis_pmerge(ZERO, REF_S0_1, TMP28);
1669
1670 vis_mul8x16au(REF_S2, CONST_256, TMP30);
1671 vis_padd16(TMP18, TMP22, TMP18);
1672
1673 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
1674 vis_padd16(TMP20, TMP24, TMP20);
1675
1676 vis_padd16(TMP8, TMP18, TMP8);
1677
1678 vis_padd16(TMP10, TMP20, TMP10);
1679
1680 vis_padd16(TMP8, TMP12, TMP8);
1681
1682 vis_padd16(TMP10, TMP14, TMP10);
1683 vis_pack16(TMP8, DST_0);
1684
1685 vis_pack16(TMP10, DST_1);
1686 vis_st64(DST_0, dest[0]);
1687 dest += stride;
1688 vis_padd16(TMP18, TMP26, TMP18);
1689
1690 vis_padd16(TMP20, TMP28, TMP20);
1691
1692 vis_padd16(TMP18, TMP30, TMP18);
1693
1694 vis_padd16(TMP20, TMP32, TMP20);
1695 vis_pack16(TMP18, DST_2);
1696
1697 vis_pack16(TMP20, DST_3);
1698 vis_st64(DST_2, dest[0]);
1699 dest += stride;
1700 } while (--height);
1701 }
1702
1703 static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * ref,
1704 const int stride, int height)
1705 {
1706 unsigned long off = (unsigned long) ref & 0x7;
1707 unsigned long off_plus_1 = off + 1;
1708 int stride_8 = stride + 8;
1709 int stride_16 = stride + 16;
1710
1711 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
1712
1713 ref = vis_alignaddr(ref);
1714
1715 vis_ld64(ref[ 0], TMP0);
1716 vis_fzero(ZERO);
1717
1718 vis_ld64(ref[ 8], TMP2);
1719
1720 vis_ld64(ref[16], TMP4);
1721
1722 vis_ld64(constants6[0], CONST_6);
1723 vis_faligndata(TMP0, TMP2, REF_S0);
1724
1725 vis_ld64(constants256_1024[0], CONST_256);
1726 vis_faligndata(TMP2, TMP4, REF_S4);
1727
1728 if (off != 0x7) {
1729 vis_alignaddr_g0((void *)off_plus_1);
1730 vis_faligndata(TMP0, TMP2, REF_S2);
1731 vis_faligndata(TMP2, TMP4, REF_S6);
1732 } else {
1733 vis_src1(TMP2, REF_S2);
1734 vis_src1(TMP4, REF_S6);
1735 }
1736
1737 height >>= 1;
1738 do { /* 55 cycles */
1739 vis_ld64_2(ref, stride, TMP0);
1740 vis_mul8x16au(REF_S0, CONST_256, TMP12);
1741 vis_pmerge(ZERO, REF_S0_1, TMP14);
1742
1743 vis_alignaddr_g0((void *)off);
1744
1745 vis_ld64_2(ref, stride_8, TMP2);
1746 vis_mul8x16au(REF_S2, CONST_256, TMP16);
1747 vis_pmerge(ZERO, REF_S2_1, TMP18);
1748
1749 vis_ld64_2(ref, stride_16, TMP4);
1750 ref += stride;
1751 vis_mul8x16au(REF_S4, CONST_256, TMP20);
1752 vis_pmerge(ZERO, REF_S4_1, TMP22);
1753
1754 vis_ld64_2(ref, stride, TMP6);
1755 vis_mul8x16au(REF_S6, CONST_256, TMP24);
1756 vis_pmerge(ZERO, REF_S6_1, TMP26);
1757
1758 vis_ld64_2(ref, stride_8, TMP8);
1759 vis_faligndata(TMP0, TMP2, REF_0);
1760
1761 vis_ld64_2(ref, stride_16, TMP10);
1762 ref += stride;
1763 vis_faligndata(TMP2, TMP4, REF_4);
1764
1765 vis_ld64(dest[0], DST_0);
1766 vis_faligndata(TMP6, TMP8, REF_S0);
1767
1768 vis_ld64_2(dest, 8, DST_2);
1769 vis_faligndata(TMP8, TMP10, REF_S4);
1770
1771 if (off != 0x7) {
1772 vis_alignaddr_g0((void *)off_plus_1);
1773 vis_faligndata(TMP0, TMP2, REF_2);
1774 vis_faligndata(TMP2, TMP4, REF_6);
1775 vis_faligndata(TMP6, TMP8, REF_S2);
1776 vis_faligndata(TMP8, TMP10, REF_S6);
1777 } else {
1778 vis_src1(TMP2, REF_2);
1779 vis_src1(TMP4, REF_6);
1780 vis_src1(TMP8, REF_S2);
1781 vis_src1(TMP10, REF_S6);
1782 }
1783
1784 vis_mul8x16al(DST_0, CONST_1024, TMP30);
1785 vis_pmerge(ZERO, REF_0, TMP0);
1786
1787 vis_mul8x16al(DST_1, CONST_1024, TMP32);
1788 vis_pmerge(ZERO, REF_0_1, TMP2);
1789
1790 vis_mul8x16au(REF_2, CONST_256, TMP4);
1791 vis_pmerge(ZERO, REF_2_1, TMP6);
1792
1793 vis_mul8x16al(DST_2, CONST_1024, REF_0);
1794 vis_padd16(TMP0, CONST_6, TMP0);
1795
1796 vis_mul8x16al(DST_3, CONST_1024, REF_2);
1797 vis_padd16(TMP2, CONST_6, TMP2);
1798
1799 vis_padd16(TMP0, TMP4, TMP0);
1800 vis_mul8x16au(REF_4, CONST_256, TMP4);
1801
1802 vis_padd16(TMP2, TMP6, TMP2);
1803 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
1804
1805 vis_padd16(TMP12, TMP0, TMP12);
1806 vis_mul8x16au(REF_6, CONST_256, TMP8);
1807
1808 vis_padd16(TMP14, TMP2, TMP14);
1809 vis_mul8x16au(REF_6_1, CONST_256, TMP10);
1810
1811 vis_padd16(TMP12, TMP16, TMP12);
1812 vis_mul8x16au(REF_S0, CONST_256, REF_4);
1813
1814 vis_padd16(TMP14, TMP18, TMP14);
1815 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
1816
1817 vis_padd16(TMP12, TMP30, TMP12);
1818
1819 vis_padd16(TMP14, TMP32, TMP14);
1820 vis_pack16(TMP12, DST_0);
1821
1822 vis_pack16(TMP14, DST_1);
1823 vis_st64(DST_0, dest[0]);
1824 vis_padd16(TMP4, CONST_6, TMP4);
1825
1826 vis_ld64_2(dest, stride, DST_0);
1827 vis_padd16(TMP6, CONST_6, TMP6);
1828 vis_mul8x16au(REF_S2, CONST_256, TMP12);
1829
1830 vis_padd16(TMP4, TMP8, TMP4);
1831 vis_mul8x16au(REF_S2_1, CONST_256, TMP14);
1832
1833 vis_padd16(TMP6, TMP10, TMP6);
1834
1835 vis_padd16(TMP20, TMP4, TMP20);
1836
1837 vis_padd16(TMP22, TMP6, TMP22);
1838
1839 vis_padd16(TMP20, TMP24, TMP20);
1840
1841 vis_padd16(TMP22, TMP26, TMP22);
1842
1843 vis_padd16(TMP20, REF_0, TMP20);
1844 vis_mul8x16au(REF_S4, CONST_256, REF_0);
1845
1846 vis_padd16(TMP22, REF_2, TMP22);
1847 vis_pack16(TMP20, DST_2);
1848
1849 vis_pack16(TMP22, DST_3);
1850 vis_st64_2(DST_2, dest, 8);
1851 dest += stride;
1852
1853 vis_ld64_2(dest, 8, DST_2);
1854 vis_mul8x16al(DST_0, CONST_1024, TMP30);
1855 vis_pmerge(ZERO, REF_S4_1, REF_2);
1856
1857 vis_mul8x16al(DST_1, CONST_1024, TMP32);
1858 vis_padd16(REF_4, TMP0, TMP8);
1859
1860 vis_mul8x16au(REF_S6, CONST_256, REF_4);
1861 vis_padd16(REF_6, TMP2, TMP10);
1862
1863 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
1864 vis_padd16(TMP8, TMP12, TMP8);
1865
1866 vis_padd16(TMP10, TMP14, TMP10);
1867
1868 vis_padd16(TMP8, TMP30, TMP8);
1869
1870 vis_padd16(TMP10, TMP32, TMP10);
1871 vis_pack16(TMP8, DST_0);
1872
1873 vis_pack16(TMP10, DST_1);
1874 vis_st64(DST_0, dest[0]);
1875
1876 vis_padd16(REF_0, TMP4, REF_0);
1877
1878 vis_mul8x16al(DST_2, CONST_1024, TMP30);
1879 vis_padd16(REF_2, TMP6, REF_2);
1880
1881 vis_mul8x16al(DST_3, CONST_1024, TMP32);
1882 vis_padd16(REF_0, REF_4, REF_0);
1883
1884 vis_padd16(REF_2, REF_6, REF_2);
1885
1886 vis_padd16(REF_0, TMP30, REF_0);
1887
1888 /* stall */
1889
1890 vis_padd16(REF_2, TMP32, REF_2);
1891 vis_pack16(REF_0, DST_2);
1892
1893 vis_pack16(REF_2, DST_3);
1894 vis_st64_2(DST_2, dest, 8);
1895 dest += stride;
1896 } while (--height);
1897 }
1898
1899 static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * ref,
1900 const int stride, int height)
1901 {
1902 unsigned long off = (unsigned long) ref & 0x7;
1903 unsigned long off_plus_1 = off + 1;
1904 int stride_8 = stride + 8;
1905
1906 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
1907
1908 ref = vis_alignaddr(ref);
1909
1910 vis_ld64(ref[0], TMP0);
1911 vis_fzero(ZERO);
1912
1913 vis_ld64_2(ref, 8, TMP2);
1914
1915 vis_ld64(constants6[0], CONST_6);
1916
1917 vis_ld64(constants256_1024[0], CONST_256);
1918 vis_faligndata(TMP0, TMP2, REF_S0);
1919
1920 if (off != 0x7) {
1921 vis_alignaddr_g0((void *)off_plus_1);
1922 vis_faligndata(TMP0, TMP2, REF_S2);
1923 } else {
1924 vis_src1(TMP2, REF_S2);
1925 }
1926
1927 height >>= 1;
1928 do { /* 31 cycles */
1929 vis_ld64_2(ref, stride, TMP0);
1930 vis_mul8x16au(REF_S0, CONST_256, TMP8);
1931 vis_pmerge(ZERO, REF_S0_1, TMP10);
1932
1933 vis_ld64_2(ref, stride_8, TMP2);
1934 ref += stride;
1935 vis_mul8x16au(REF_S2, CONST_256, TMP12);
1936 vis_pmerge(ZERO, REF_S2_1, TMP14);
1937
1938 vis_alignaddr_g0((void *)off);
1939
1940 vis_ld64_2(ref, stride, TMP4);
1941 vis_faligndata(TMP0, TMP2, REF_S4);
1942
1943 vis_ld64_2(ref, stride_8, TMP6);
1944 ref += stride;
1945
1946 vis_ld64(dest[0], DST_0);
1947 vis_faligndata(TMP4, TMP6, REF_S0);
1948
1949 vis_ld64_2(dest, stride, DST_2);
1950
1951 if (off != 0x7) {
1952 vis_alignaddr_g0((void *)off_plus_1);
1953 vis_faligndata(TMP0, TMP2, REF_S6);
1954 vis_faligndata(TMP4, TMP6, REF_S2);
1955 } else {
1956 vis_src1(TMP2, REF_S6);
1957 vis_src1(TMP6, REF_S2);
1958 }
1959
1960 vis_mul8x16al(DST_0, CONST_1024, TMP30);
1961 vis_pmerge(ZERO, REF_S4, TMP22);
1962
1963 vis_mul8x16al(DST_1, CONST_1024, TMP32);
1964 vis_pmerge(ZERO, REF_S4_1, TMP24);
1965
1966 vis_mul8x16au(REF_S6, CONST_256, TMP26);
1967 vis_pmerge(ZERO, REF_S6_1, TMP28);
1968
1969 vis_mul8x16au(REF_S0, CONST_256, REF_S4);
1970 vis_padd16(TMP22, CONST_6, TMP22);
1971
1972 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
1973 vis_padd16(TMP24, CONST_6, TMP24);
1974
1975 vis_mul8x16al(DST_2, CONST_1024, REF_0);
1976 vis_padd16(TMP22, TMP26, TMP22);
1977
1978 vis_mul8x16al(DST_3, CONST_1024, REF_2);
1979 vis_padd16(TMP24, TMP28, TMP24);
1980
1981 vis_mul8x16au(REF_S2, CONST_256, TMP26);
1982 vis_padd16(TMP8, TMP22, TMP8);
1983
1984 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
1985 vis_padd16(TMP10, TMP24, TMP10);
1986
1987 vis_padd16(TMP8, TMP12, TMP8);
1988
1989 vis_padd16(TMP10, TMP14, TMP10);
1990
1991 vis_padd16(TMP8, TMP30, TMP8);
1992
1993 vis_padd16(TMP10, TMP32, TMP10);
1994 vis_pack16(TMP8, DST_0);
1995
1996 vis_pack16(TMP10, DST_1);
1997 vis_st64(DST_0, dest[0]);
1998 dest += stride;
1999
2000 vis_padd16(REF_S4, TMP22, TMP12);
2001
2002 vis_padd16(REF_S6, TMP24, TMP14);
2003
2004 vis_padd16(TMP12, TMP26, TMP12);
2005
2006 vis_padd16(TMP14, TMP28, TMP14);
2007
2008 vis_padd16(TMP12, REF_0, TMP12);
2009
2010 vis_padd16(TMP14, REF_2, TMP14);
2011 vis_pack16(TMP12, DST_2);
2012
2013 vis_pack16(TMP14, DST_3);
2014 vis_st64(DST_2, dest[0]);
2015 dest += stride;
2016 } while (--height);
2017 }
2018
2019 /* End of rounding code */
2020
2021 /* Start of no rounding code */
2022 /* The trick used in some of this file is the formula from the MMX
2023 * motion comp code, which is:
2024 *
2025 * (x+y)>>1 == (x&y)+((x^y)>>1)
2026 *
2027 * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
2028 * We avoid overflows by masking before we do the shift, and we
2029 * implement the shift by multiplying by 1/2 using mul8x16. So in
2030 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
2031 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
2032 * the value 0x80808080 is in f8):
2033 *
2034 * fxor f0, f2, f10
2035 * fand f10, f4, f10
2036 * fmul8x16 f8, f10, f10
2037 * fand f10, f6, f10
2038 * fand f0, f2, f12
2039 * fpadd16 f12, f10, f10
2040 */
2041
2042 static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,
2043 const int stride, int height)
2044 {
2045 ref = vis_alignaddr(ref);
2046 do { /* 5 cycles */
2047 vis_ld64(ref[0], TMP0);
2048
2049 vis_ld64_2(ref, 8, TMP2);
2050
2051 vis_ld64_2(ref, 16, TMP4);
2052 ref += stride;
2053
2054 vis_faligndata(TMP0, TMP2, REF_0);
2055 vis_st64(REF_0, dest[0]);
2056
2057 vis_faligndata(TMP2, TMP4, REF_2);
2058 vis_st64_2(REF_2, dest, 8);
2059 dest += stride;
2060 } while (--height);
2061 }
2062
2063 static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,
2064 const int stride, int height)
2065 {
2066 ref = vis_alignaddr(ref);
2067 do { /* 4 cycles */
2068 vis_ld64(ref[0], TMP0);
2069
2070 vis_ld64(ref[8], TMP2);
2071 ref += stride;
2072
2073 /* stall */
2074
2075 vis_faligndata(TMP0, TMP2, REF_0);
2076 vis_st64(REF_0, dest[0]);
2077 dest += stride;
2078 } while (--height);
2079 }
2080
2081
2082 static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,
2083 const int stride, int height)
2084 {
2085 int stride_8 = stride + 8;
2086
2087 ref = vis_alignaddr(ref);
2088
2089 vis_ld64(ref[0], TMP0);
2090
2091 vis_ld64(ref[8], TMP2);
2092
2093 vis_ld64(ref[16], TMP4);
2094
2095 vis_ld64(dest[0], DST_0);
2096
2097 vis_ld64(dest[8], DST_2);
2098
2099 vis_ld64(constants_fe[0], MASK_fe);
2100 vis_faligndata(TMP0, TMP2, REF_0);
2101
2102 vis_ld64(constants_7f[0], MASK_7f);
2103 vis_faligndata(TMP2, TMP4, REF_2);
2104
2105 vis_ld64(constants128[0], CONST_128);
2106
2107 ref += stride;
2108 height = (height >> 1) - 1;
2109
2110 do { /* 24 cycles */
2111 vis_ld64(ref[0], TMP0);
2112 vis_xor(DST_0, REF_0, TMP6);
2113
2114 vis_ld64_2(ref, 8, TMP2);
2115 vis_and(TMP6, MASK_fe, TMP6);
2116
2117 vis_ld64_2(ref, 16, TMP4);
2118 ref += stride;
2119 vis_mul8x16(CONST_128, TMP6, TMP6);
2120 vis_xor(DST_2, REF_2, TMP8);
2121
2122 vis_and(TMP8, MASK_fe, TMP8);
2123
2124 vis_and(DST_0, REF_0, TMP10);
2125 vis_ld64_2(dest, stride, DST_0);
2126 vis_mul8x16(CONST_128, TMP8, TMP8);
2127
2128 vis_and(DST_2, REF_2, TMP12);
2129 vis_ld64_2(dest, stride_8, DST_2);
2130
2131 vis_ld64(ref[0], TMP14);
2132 vis_and(TMP6, MASK_7f, TMP6);
2133
2134 vis_and(TMP8, MASK_7f, TMP8);
2135
2136 vis_padd16(TMP10, TMP6, TMP6);
2137 vis_st64(TMP6, dest[0]);
2138
2139 vis_padd16(TMP12, TMP8, TMP8);
2140 vis_st64_2(TMP8, dest, 8);
2141
2142 dest += stride;
2143 vis_ld64_2(ref, 8, TMP16);
2144 vis_faligndata(TMP0, TMP2, REF_0);
2145
2146 vis_ld64_2(ref, 16, TMP18);
2147 vis_faligndata(TMP2, TMP4, REF_2);
2148 ref += stride;
2149
2150 vis_xor(DST_0, REF_0, TMP20);
2151
2152 vis_and(TMP20, MASK_fe, TMP20);
2153
2154 vis_xor(DST_2, REF_2, TMP22);
2155 vis_mul8x16(CONST_128, TMP20, TMP20);
2156
2157 vis_and(TMP22, MASK_fe, TMP22);
2158
2159 vis_and(DST_0, REF_0, TMP24);
2160 vis_mul8x16(CONST_128, TMP22, TMP22);
2161
2162 vis_and(DST_2, REF_2, TMP26);
2163
2164 vis_ld64_2(dest, stride, DST_0);
2165 vis_faligndata(TMP14, TMP16, REF_0);
2166
2167 vis_ld64_2(dest, stride_8, DST_2);
2168 vis_faligndata(TMP16, TMP18, REF_2);
2169
2170 vis_and(TMP20, MASK_7f, TMP20);
2171
2172 vis_and(TMP22, MASK_7f, TMP22);
2173
2174 vis_padd16(TMP24, TMP20, TMP20);
2175 vis_st64(TMP20, dest[0]);
2176
2177 vis_padd16(TMP26, TMP22, TMP22);
2178 vis_st64_2(TMP22, dest, 8);
2179 dest += stride;
2180 } while (--height);
2181
2182 vis_ld64(ref[0], TMP0);
2183 vis_xor(DST_0, REF_0, TMP6);
2184
2185 vis_ld64_2(ref, 8, TMP2);
2186 vis_and(TMP6, MASK_fe, TMP6);
2187
2188 vis_ld64_2(ref, 16, TMP4);
2189 vis_mul8x16(CONST_128, TMP6, TMP6);
2190 vis_xor(DST_2, REF_2, TMP8);
2191
2192 vis_and(TMP8, MASK_fe, TMP8);
2193
2194 vis_and(DST_0, REF_0, TMP10);
2195 vis_ld64_2(dest, stride, DST_0);
2196 vis_mul8x16(CONST_128, TMP8, TMP8);
2197
2198 vis_and(DST_2, REF_2, TMP12);
2199 vis_ld64_2(dest, stride_8, DST_2);
2200
2201 vis_ld64(ref[0], TMP14);
2202 vis_and(TMP6, MASK_7f, TMP6);
2203
2204 vis_and(TMP8, MASK_7f, TMP8);
2205
2206 vis_padd16(TMP10, TMP6, TMP6);
2207 vis_st64(TMP6, dest[0]);
2208
2209 vis_padd16(TMP12, TMP8, TMP8);
2210 vis_st64_2(TMP8, dest, 8);
2211
2212 dest += stride;
2213 vis_faligndata(TMP0, TMP2, REF_0);
2214
2215 vis_faligndata(TMP2, TMP4, REF_2);
2216
2217 vis_xor(DST_0, REF_0, TMP20);
2218
2219 vis_and(TMP20, MASK_fe, TMP20);
2220
2221 vis_xor(DST_2, REF_2, TMP22);
2222 vis_mul8x16(CONST_128, TMP20, TMP20);
2223
2224 vis_and(TMP22, MASK_fe, TMP22);
2225
2226 vis_and(DST_0, REF_0, TMP24);
2227 vis_mul8x16(CONST_128, TMP22, TMP22);
2228
2229 vis_and(DST_2, REF_2, TMP26);
2230
2231 vis_and(TMP20, MASK_7f, TMP20);
2232
2233 vis_and(TMP22, MASK_7f, TMP22);
2234
2235 vis_padd16(TMP24, TMP20, TMP20);
2236 vis_st64(TMP20, dest[0]);
2237
2238 vis_padd16(TMP26, TMP22, TMP22);
2239 vis_st64_2(TMP22, dest, 8);
2240 }
2241
2242 static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,
2243 const int stride, int height)
2244 {
2245 ref = vis_alignaddr(ref);
2246
2247 vis_ld64(ref[0], TMP0);
2248
2249 vis_ld64(ref[8], TMP2);
2250
2251 vis_ld64(dest[0], DST_0);
2252
2253 vis_ld64(constants_fe[0], MASK_fe);
2254
2255 vis_ld64(constants_7f[0], MASK_7f);
2256 vis_faligndata(TMP0, TMP2, REF_0);
2257
2258 vis_ld64(constants128[0], CONST_128);
2259
2260 ref += stride;
2261 height = (height >> 1) - 1;
2262
2263 do { /* 12 cycles */
2264 vis_ld64(ref[0], TMP0);
2265 vis_xor(DST_0, REF_0, TMP4);
2266
2267 vis_ld64(ref[8], TMP2);
2268 vis_and(TMP4, MASK_fe, TMP4);
2269
2270 vis_and(DST_0, REF_0, TMP6);
2271 vis_ld64_2(dest, stride, DST_0);
2272 ref += stride;
2273 vis_mul8x16(CONST_128, TMP4, TMP4);
2274
2275 vis_ld64(ref[0], TMP12);
2276 vis_faligndata(TMP0, TMP2, REF_0);
2277
2278 vis_ld64(ref[8], TMP2);
2279 vis_xor(DST_0, REF_0, TMP0);
2280 ref += stride;
2281
2282 vis_and(TMP0, MASK_fe, TMP0);
2283
2284 vis_and(TMP4, MASK_7f, TMP4);
2285
2286 vis_padd16(TMP6, TMP4, TMP4);
2287 vis_st64(TMP4, dest[0]);
2288 dest += stride;
2289 vis_mul8x16(CONST_128, TMP0, TMP0);
2290
2291 vis_and(DST_0, REF_0, TMP6);
2292 vis_ld64_2(dest, stride, DST_0);
2293
2294 vis_faligndata(TMP12, TMP2, REF_0);
2295
2296 vis_and(TMP0, MASK_7f, TMP0);
2297
2298 vis_padd16(TMP6, TMP0, TMP4);
2299 vis_st64(TMP4, dest[0]);
2300 dest += stride;
2301 } while (--height);
2302
2303 vis_ld64(ref[0], TMP0);
2304 vis_xor(DST_0, REF_0, TMP4);
2305
2306 vis_ld64(ref[8], TMP2);
2307 vis_and(TMP4, MASK_fe, TMP4);
2308
2309 vis_and(DST_0, REF_0, TMP6);
2310 vis_ld64_2(dest, stride, DST_0);
2311 vis_mul8x16(CONST_128, TMP4, TMP4);
2312
2313 vis_faligndata(TMP0, TMP2, REF_0);
2314
2315 vis_xor(DST_0, REF_0, TMP0);
2316
2317 vis_and(TMP0, MASK_fe, TMP0);
2318
2319 vis_and(TMP4, MASK_7f, TMP4);
2320
2321 vis_padd16(TMP6, TMP4, TMP4);
2322 vis_st64(TMP4, dest[0]);
2323 dest += stride;
2324 vis_mul8x16(CONST_128, TMP0, TMP0);
2325
2326 vis_and(DST_0, REF_0, TMP6);
2327
2328 vis_and(TMP0, MASK_7f, TMP0);
2329
2330 vis_padd16(TMP6, TMP0, TMP4);
2331 vis_st64(TMP4, dest[0]);
2332 }
2333
2334 static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,
2335 const int stride, int height)
2336 {
2337 unsigned long off = (unsigned long) ref & 0x7;
2338 unsigned long off_plus_1 = off + 1;
2339
2340 ref = vis_alignaddr(ref);
2341
2342 vis_ld64(ref[0], TMP0);
2343
2344 vis_ld64_2(ref, 8, TMP2);
2345
2346 vis_ld64_2(ref, 16, TMP4);
2347
2348 vis_ld64(constants_fe[0], MASK_fe);
2349
2350 vis_ld64(constants_7f[0], MASK_7f);
2351 vis_faligndata(TMP0, TMP2, REF_0);
2352
2353 vis_ld64(constants128[0], CONST_128);
2354 vis_faligndata(TMP2, TMP4, REF_4);
2355
2356 if (off != 0x7) {
2357 vis_alignaddr_g0((void *)off_plus_1);
2358 vis_faligndata(TMP0, TMP2, REF_2);
2359 vis_faligndata(TMP2, TMP4, REF_6);
2360 } else {
2361 vis_src1(TMP2, REF_2);
2362 vis_src1(TMP4, REF_6);
2363 }
2364
2365 ref += stride;
2366 height = (height >> 1) - 1;
2367
2368 do { /* 34 cycles */
2369 vis_ld64(ref[0], TMP0);
2370 vis_xor(REF_0, REF_2, TMP6);
2371
2372 vis_ld64_2(ref, 8, TMP2);
2373 vis_xor(REF_4, REF_6, TMP8);
2374
2375 vis_ld64_2(ref, 16, TMP4);
2376 vis_and(TMP6, MASK_fe, TMP6);
2377 ref += stride;
2378
2379 vis_ld64(ref[0], TMP14);
2380 vis_mul8x16(CONST_128, TMP6, TMP6);
2381 vis_and(TMP8, MASK_fe, TMP8);
2382
2383 vis_ld64_2(ref, 8, TMP16);
2384 vis_mul8x16(CONST_128, TMP8, TMP8);
2385 vis_and(REF_0, REF_2, TMP10);
2386
2387 vis_ld64_2(ref, 16, TMP18);
2388 ref += stride;
2389 vis_and(REF_4, REF_6, TMP12);
2390
2391 vis_alignaddr_g0((void *)off);
2392
2393 vis_faligndata(TMP0, TMP2, REF_0);
2394
2395 vis_faligndata(TMP2, TMP4, REF_4);
2396
2397 if (off != 0x7) {
2398 vis_alignaddr_g0((void *)off_plus_1);
2399 vis_faligndata(TMP0, TMP2, REF_2);
2400 vis_faligndata(TMP2, TMP4, REF_6);
2401 } else {
2402 vis_src1(TMP2, REF_2);
2403 vis_src1(TMP4, REF_6);
2404 }
2405
2406 vis_and(TMP6, MASK_7f, TMP6);
2407
2408 vis_and(TMP8, MASK_7f, TMP8);
2409
2410 vis_padd16(TMP10, TMP6, TMP6);
2411 vis_st64(TMP6, dest[0]);
2412
2413 vis_padd16(TMP12, TMP8, TMP8);
2414 vis_st64_2(TMP8, dest, 8);
2415 dest += stride;
2416
2417 vis_xor(REF_0, REF_2, TMP6);
2418
2419 vis_xor(REF_4, REF_6, TMP8);
2420
2421 vis_and(TMP6, MASK_fe, TMP6);
2422
2423 vis_mul8x16(CONST_128, TMP6, TMP6);
2424 vis_and(TMP8, MASK_fe, TMP8);
2425
2426 vis_mul8x16(CONST_128, TMP8, TMP8);
2427 vis_and(REF_0, REF_2, TMP10);
2428
2429 vis_and(REF_4, REF_6, TMP12);
2430
2431 vis_alignaddr_g0((void *)off);
2432
2433 vis_faligndata(TMP14, TMP16, REF_0);
2434
2435 vis_faligndata(TMP16, TMP18, REF_4);
2436
2437 if (off != 0x7) {
2438 vis_alignaddr_g0((void *)off_plus_1);
2439 vis_faligndata(TMP14, TMP16, REF_2);
2440 vis_faligndata(TMP16, TMP18, REF_6);
2441 } else {
2442 vis_src1(TMP16, REF_2);
2443 vis_src1(TMP18, REF_6);
2444 }
2445
2446 vis_and(TMP6, MASK_7f, TMP6);
2447
2448 vis_and(TMP8, MASK_7f, TMP8);
2449
2450 vis_padd16(TMP10, TMP6, TMP6);
2451 vis_st64(TMP6, dest[0]);
2452
2453 vis_padd16(TMP12, TMP8, TMP8);
2454 vis_st64_2(TMP8, dest, 8);
2455 dest += stride;
2456 } while (--height);
2457
2458 vis_ld64(ref[0], TMP0);
2459 vis_xor(REF_0, REF_2, TMP6);
2460
2461 vis_ld64_2(ref, 8, TMP2);
2462 vis_xor(REF_4, REF_6, TMP8);
2463
2464 vis_ld64_2(ref, 16, TMP4);
2465 vis_and(TMP6, MASK_fe, TMP6);
2466
2467 vis_mul8x16(CONST_128, TMP6, TMP6);
2468 vis_and(TMP8, MASK_fe, TMP8);
2469
2470 vis_mul8x16(CONST_128, TMP8, TMP8);
2471 vis_and(REF_0, REF_2, TMP10);
2472
2473 vis_and(REF_4, REF_6, TMP12);
2474
2475 vis_alignaddr_g0((void *)off);
2476
2477 vis_faligndata(TMP0, TMP2, REF_0);
2478
2479 vis_faligndata(TMP2, TMP4, REF_4);
2480
2481 if (off != 0x7) {
2482 vis_alignaddr_g0((void *)off_plus_1);
2483 vis_faligndata(TMP0, TMP2, REF_2);
2484 vis_faligndata(TMP2, TMP4, REF_6);
2485 } else {
2486 vis_src1(TMP2, REF_2);
2487 vis_src1(TMP4, REF_6);
2488 }
2489
2490 vis_and(TMP6, MASK_7f, TMP6);
2491
2492 vis_and(TMP8, MASK_7f, TMP8);
2493
2494 vis_padd16(TMP10, TMP6, TMP6);
2495 vis_st64(TMP6, dest[0]);
2496
2497 vis_padd16(TMP12, TMP8, TMP8);
2498 vis_st64_2(TMP8, dest, 8);
2499 dest += stride;
2500
2501 vis_xor(REF_0, REF_2, TMP6);
2502
2503 vis_xor(REF_4, REF_6, TMP8);
2504
2505 vis_and(TMP6, MASK_fe, TMP6);
2506
2507 vis_mul8x16(CONST_128, TMP6, TMP6);
2508 vis_and(TMP8, MASK_fe, TMP8);
2509
2510 vis_mul8x16(CONST_128, TMP8, TMP8);
2511 vis_and(REF_0, REF_2, TMP10);
2512
2513 vis_and(REF_4, REF_6, TMP12);
2514
2515 vis_and(TMP6, MASK_7f, TMP6);
2516
2517 vis_and(TMP8, MASK_7f, TMP8);
2518
2519 vis_padd16(TMP10, TMP6, TMP6);
2520 vis_st64(TMP6, dest[0]);
2521
2522 vis_padd16(TMP12, TMP8, TMP8);
2523 vis_st64_2(TMP8, dest, 8);
2524 }
2525
2526 static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,
2527 const int stride, int height)
2528 {
2529 unsigned long off = (unsigned long) ref & 0x7;
2530 unsigned long off_plus_1 = off + 1;
2531
2532 ref = vis_alignaddr(ref);
2533
2534 vis_ld64(ref[0], TMP0);
2535
2536 vis_ld64(ref[8], TMP2);
2537
2538 vis_ld64(constants_fe[0], MASK_fe);
2539
2540 vis_ld64(constants_7f[0], MASK_7f);
2541
2542 vis_ld64(constants128[0], CONST_128);
2543 vis_faligndata(TMP0, TMP2, REF_0);
2544
2545 if (off != 0x7) {
2546 vis_alignaddr_g0((void *)off_plus_1);
2547 vis_faligndata(TMP0, TMP2, REF_2);
2548 } else {
2549 vis_src1(TMP2, REF_2);
2550 }
2551
2552 ref += stride;
2553 height = (height >> 1) - 1;
2554
2555 do { /* 20 cycles */
2556 vis_ld64(ref[0], TMP0);
2557 vis_xor(REF_0, REF_2, TMP4);
2558
2559 vis_ld64_2(ref, 8, TMP2);
2560 vis_and(TMP4, MASK_fe, TMP4);
2561 ref += stride;
2562
2563 vis_ld64(ref[0], TMP8);
2564 vis_and(REF_0, REF_2, TMP6);
2565 vis_mul8x16(CONST_128, TMP4, TMP4);
2566
2567 vis_alignaddr_g0((void *)off);
2568
2569 vis_ld64_2(ref, 8, TMP10);
2570 ref += stride;
2571 vis_faligndata(TMP0, TMP2, REF_0);
2572
2573 if (off != 0x7) {
2574 vis_alignaddr_g0((void *)off_plus_1);
2575 vis_faligndata(TMP0, TMP2, REF_2);
2576 } else {
2577 vis_src1(TMP2, REF_2);
2578 }
2579
2580 vis_and(TMP4, MASK_7f, TMP4);
2581
2582 vis_padd16(TMP6, TMP4, DST_0);
2583 vis_st64(DST_0, dest[0]);
2584 dest += stride;
2585
2586 vis_xor(REF_0, REF_2, TMP12);
2587
2588 vis_and(TMP12, MASK_fe, TMP12);
2589
2590 vis_and(REF_0, REF_2, TMP14);
2591 vis_mul8x16(CONST_128, TMP12, TMP12);
2592
2593 vis_alignaddr_g0((void *)off);
2594 vis_faligndata(TMP8, TMP10, REF_0);
2595 if (off != 0x7) {
2596 vis_alignaddr_g0((void *)off_plus_1);
2597 vis_faligndata(TMP8, TMP10, REF_2);
2598 } else {
2599 vis_src1(TMP10, REF_2);
2600 }
2601
2602 vis_and(TMP12, MASK_7f, TMP12);
2603
2604 vis_padd16(TMP14, TMP12, DST_0);
2605 vis_st64(DST_0, dest[0]);
2606 dest += stride;
2607 } while (--height);
2608
2609 vis_ld64(ref[0], TMP0);
2610 vis_xor(REF_0, REF_2, TMP4);
2611
2612 vis_ld64_2(ref, 8, TMP2);
2613 vis_and(TMP4, MASK_fe, TMP4);
2614
2615 vis_and(REF_0, REF_2, TMP6);
2616 vis_mul8x16(CONST_128, TMP4, TMP4);
2617
2618 vis_alignaddr_g0((void *)off);
2619
2620 vis_faligndata(TMP0, TMP2, REF_0);
2621
2622 if (off != 0x7) {
2623 vis_alignaddr_g0((void *)off_plus_1);
2624 vis_faligndata(TMP0, TMP2, REF_2);
2625 } else {
2626 vis_src1(TMP2, REF_2);
2627 }
2628
2629 vis_and(TMP4, MASK_7f, TMP4);
2630
2631 vis_padd16(TMP6, TMP4, DST_0);
2632 vis_st64(DST_0, dest[0]);
2633 dest += stride;
2634
2635 vis_xor(REF_0, REF_2, TMP12);
2636
2637 vis_and(TMP12, MASK_fe, TMP12);
2638
2639 vis_and(REF_0, REF_2, TMP14);
2640 vis_mul8x16(CONST_128, TMP12, TMP12);
2641
2642 vis_and(TMP12, MASK_7f, TMP12);
2643
2644 vis_padd16(TMP14, TMP12, DST_0);
2645 vis_st64(DST_0, dest[0]);
2646 dest += stride;
2647 }
2648
2649 static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,
2650 const int stride, int height)
2651 {
2652 unsigned long off = (unsigned long) ref & 0x7;
2653 unsigned long off_plus_1 = off + 1;
2654
2655 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
2656
2657 vis_ld64(constants3[0], CONST_3);
2658 vis_fzero(ZERO);
2659 vis_ld64(constants256_512[0], CONST_256);
2660
2661 ref = vis_alignaddr(ref);
2662 do { /* 26 cycles */
2663 vis_ld64(ref[0], TMP0);
2664
2665 vis_ld64(ref[8], TMP2);
2666
2667 vis_alignaddr_g0((void *)off);
2668
2669 vis_ld64(ref[16], TMP4);
2670
2671 vis_ld64(dest[0], DST_0);
2672 vis_faligndata(TMP0, TMP2, REF_0);
2673
2674 vis_ld64(dest[8], DST_2);
2675 vis_faligndata(TMP2, TMP4, REF_4);
2676
2677 if (off != 0x7) {
2678 vis_alignaddr_g0((void *)off_plus_1);
2679 vis_faligndata(TMP0, TMP2, REF_2);
2680 vis_faligndata(TMP2, TMP4, REF_6);
2681 } else {
2682 vis_src1(TMP2, REF_2);
2683 vis_src1(TMP4, REF_6);
2684 }
2685
2686 vis_mul8x16au(REF_0, CONST_256, TMP0);
2687
2688 vis_pmerge(ZERO, REF_2, TMP4);
2689 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
2690
2691 vis_pmerge(ZERO, REF_2_1, TMP6);
2692
2693 vis_padd16(TMP0, TMP4, TMP0);
2694
2695 vis_mul8x16al(DST_0, CONST_512, TMP4);
2696 vis_padd16(TMP2, TMP6, TMP2);
2697
2698 vis_mul8x16al(DST_1, CONST_512, TMP6);
2699
2700 vis_mul8x16au(REF_6, CONST_256, TMP12);
2701
2702 vis_padd16(TMP0, TMP4, TMP0);
2703 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
2704
2705 vis_padd16(TMP2, TMP6, TMP2);
2706 vis_mul8x16au(REF_4, CONST_256, TMP16);
2707
2708 vis_padd16(TMP0, CONST_3, TMP8);
2709 vis_mul8x16au(REF_4_1, CONST_256, TMP18);
2710
2711 vis_padd16(TMP2, CONST_3, TMP10);
2712 vis_pack16(TMP8, DST_0);
2713
2714 vis_pack16(TMP10, DST_1);
2715 vis_padd16(TMP16, TMP12, TMP0);
2716
2717 vis_st64(DST_0, dest[0]);
2718 vis_mul8x16al(DST_2, CONST_512, TMP4);
2719 vis_padd16(TMP18, TMP14, TMP2);
2720
2721 vis_mul8x16al(DST_3, CONST_512, TMP6);
2722 vis_padd16(TMP0, CONST_3, TMP0);
2723
2724 vis_padd16(TMP2, CONST_3, TMP2);
2725
2726 vis_padd16(TMP0, TMP4, TMP0);
2727
2728 vis_padd16(TMP2, TMP6, TMP2);
2729 vis_pack16(TMP0, DST_2);
2730
2731 vis_pack16(TMP2, DST_3);
2732 vis_st64(DST_2, dest[8]);
2733
2734 ref += stride;
2735 dest += stride;
2736 } while (--height);
2737 }
2738
2739 static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,
2740 const int stride, int height)
2741 {
2742 unsigned long off = (unsigned long) ref & 0x7;
2743 unsigned long off_plus_1 = off + 1;
2744 int stride_times_2 = stride << 1;
2745
2746 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
2747
2748 vis_ld64(constants3[0], CONST_3);
2749 vis_fzero(ZERO);
2750 vis_ld64(constants256_512[0], CONST_256);
2751
2752 ref = vis_alignaddr(ref);
2753 height >>= 2;
2754 do { /* 47 cycles */
2755 vis_ld64(ref[0], TMP0);
2756
2757 vis_ld64_2(ref, 8, TMP2);
2758 ref += stride;
2759
2760 vis_alignaddr_g0((void *)off);
2761
2762 vis_ld64(ref[0], TMP4);
2763 vis_faligndata(TMP0, TMP2, REF_0);
2764
2765 vis_ld64_2(ref, 8, TMP6);
2766 ref += stride;
2767
2768 vis_ld64(ref[0], TMP8);
2769
2770 vis_ld64_2(ref, 8, TMP10);
2771 ref += stride;
2772 vis_faligndata(TMP4, TMP6, REF_4);
2773
2774 vis_ld64(ref[0], TMP12);
2775
2776 vis_ld64_2(ref, 8, TMP14);
2777 ref += stride;
2778 vis_faligndata(TMP8, TMP10, REF_S0);
2779
2780 vis_faligndata(TMP12, TMP14, REF_S4);
2781
2782 if (off != 0x7) {
2783 vis_alignaddr_g0((void *)off_plus_1);
2784
2785 vis_ld64(dest[0], DST_0);
2786 vis_faligndata(TMP0, TMP2, REF_2);
2787
2788 vis_ld64_2(dest, stride, DST_2);
2789 vis_faligndata(TMP4, TMP6, REF_6);
2790
2791 vis_faligndata(TMP8, TMP10, REF_S2);
2792
2793 vis_faligndata(TMP12, TMP14, REF_S6);
2794 } else {
2795 vis_ld64(dest[0], DST_0);
2796 vis_src1(TMP2, REF_2);
2797
2798 vis_ld64_2(dest, stride, DST_2);
2799 vis_src1(TMP6, REF_6);
2800
2801 vis_src1(TMP10, REF_S2);
2802
2803 vis_src1(TMP14, REF_S6);
2804 }
2805
2806 vis_pmerge(ZERO, REF_0, TMP0);
2807 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
2808
2809 vis_pmerge(ZERO, REF_2, TMP4);
2810 vis_mul8x16au(REF_2_1, CONST_256, TMP6);
2811
2812 vis_padd16(TMP0, CONST_3, TMP0);
2813 vis_mul8x16al(DST_0, CONST_512, TMP16);
2814
2815 vis_padd16(TMP2, CONST_3, TMP2);
2816 vis_mul8x16al(DST_1, CONST_512, TMP18);
2817
2818 vis_padd16(TMP0, TMP4, TMP0);
2819 vis_mul8x16au(REF_4, CONST_256, TMP8);
2820
2821 vis_padd16(TMP2, TMP6, TMP2);
2822 vis_mul8x16au(REF_4_1, CONST_256, TMP10);
2823
2824 vis_padd16(TMP0, TMP16, TMP0);
2825 vis_mul8x16au(REF_6, CONST_256, TMP12);
2826
2827 vis_padd16(TMP2, TMP18, TMP2);
2828 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
2829
2830 vis_padd16(TMP8, CONST_3, TMP8);
2831 vis_mul8x16al(DST_2, CONST_512, TMP16);
2832
2833 vis_padd16(TMP8, TMP12, TMP8);
2834 vis_mul8x16al(DST_3, CONST_512, TMP18);
2835
2836 vis_padd16(TMP10, TMP14, TMP10);
2837 vis_pack16(TMP0, DST_0);
2838
2839 vis_pack16(TMP2, DST_1);
2840 vis_st64(DST_0, dest[0]);
2841 dest += stride;
2842 vis_padd16(TMP10, CONST_3, TMP10);
2843
2844 vis_ld64_2(dest, stride, DST_0);
2845 vis_padd16(TMP8, TMP16, TMP8);
2846
2847 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
2848 vis_padd16(TMP10, TMP18, TMP10);
2849 vis_pack16(TMP8, DST_2);
2850
2851 vis_pack16(TMP10, DST_3);
2852 vis_st64(DST_2, dest[0]);
2853 dest += stride;
2854
2855 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
2856 vis_pmerge(ZERO, REF_S0, TMP0);
2857
2858 vis_pmerge(ZERO, REF_S2, TMP24);
2859 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
2860
2861 vis_padd16(TMP0, CONST_3, TMP0);
2862 vis_mul8x16au(REF_S4, CONST_256, TMP8);
2863
2864 vis_padd16(TMP2, CONST_3, TMP2);
2865 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
2866
2867 vis_padd16(TMP0, TMP24, TMP0);
2868 vis_mul8x16au(REF_S6, CONST_256, TMP12);
2869
2870 vis_padd16(TMP2, TMP6, TMP2);
2871 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
2872
2873 vis_padd16(TMP8, CONST_3, TMP8);
2874 vis_mul8x16al(DST_0, CONST_512, TMP16);
2875
2876 vis_padd16(TMP10, CONST_3, TMP10);
2877 vis_mul8x16al(DST_1, CONST_512, TMP18);
2878
2879 vis_padd16(TMP8, TMP12, TMP8);
2880 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
2881
2882 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
2883 vis_padd16(TMP0, TMP16, TMP0);
2884
2885 vis_padd16(TMP2, TMP18, TMP2);
2886 vis_pack16(TMP0, DST_0);
2887
2888 vis_padd16(TMP10, TMP14, TMP10);
2889 vis_pack16(TMP2, DST_1);
2890 vis_st64(DST_0, dest[0]);
2891 dest += stride;
2892
2893 vis_padd16(TMP8, TMP20, TMP8);
2894
2895 vis_padd16(TMP10, TMP22, TMP10);
2896 vis_pack16(TMP8, DST_2);
2897
2898 vis_pack16(TMP10, DST_3);
2899 vis_st64(DST_2, dest[0]);
2900 dest += stride;
2901 } while (--height);
2902 }
2903
2904 static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref,
2905 const int stride, int height)
2906 {
2907 ref = vis_alignaddr(ref);
2908 vis_ld64(ref[0], TMP0);
2909
2910 vis_ld64_2(ref, 8, TMP2);
2911
2912 vis_ld64_2(ref, 16, TMP4);
2913 ref += stride;
2914
2915 vis_ld64(ref[0], TMP6);
2916 vis_faligndata(TMP0, TMP2, REF_0);
2917
2918 vis_ld64_2(ref, 8, TMP8);
2919 vis_faligndata(TMP2, TMP4, REF_4);
2920
2921 vis_ld64_2(ref, 16, TMP10);
2922 ref += stride;
2923
2924 vis_ld64(constants_fe[0], MASK_fe);
2925 vis_faligndata(TMP6, TMP8, REF_2);
2926
2927 vis_ld64(constants_7f[0], MASK_7f);
2928 vis_faligndata(TMP8, TMP10, REF_6);
2929
2930 vis_ld64(constants128[0], CONST_128);
2931 height = (height >> 1) - 1;
2932 do { /* 24 cycles */
2933 vis_ld64(ref[0], TMP0);
2934 vis_xor(REF_0, REF_2, TMP12);
2935
2936 vis_ld64_2(ref, 8, TMP2);
2937 vis_xor(REF_4, REF_6, TMP16);
2938
2939 vis_ld64_2(ref, 16, TMP4);
2940 ref += stride;
2941 vis_and(REF_0, REF_2, TMP14);
2942
2943 vis_ld64(ref[0], TMP6);
2944 vis_and(REF_4, REF_6, TMP18);
2945
2946 vis_ld64_2(ref, 8, TMP8);
2947 vis_faligndata(TMP0, TMP2, REF_0);
2948
2949 vis_ld64_2(ref, 16, TMP10);
2950 ref += stride;
2951 vis_faligndata(TMP2, TMP4, REF_4);
2952
2953 vis_and(TMP12, MASK_fe, TMP12);
2954
2955 vis_and(TMP16, MASK_fe, TMP16);
2956 vis_mul8x16(CONST_128, TMP12, TMP12);
2957
2958 vis_mul8x16(CONST_128, TMP16, TMP16);
2959 vis_xor(REF_0, REF_2, TMP0);
2960
2961 vis_xor(REF_4, REF_6, TMP2);
2962
2963 vis_and(REF_0, REF_2, TMP20);
2964
2965 vis_and(TMP12, MASK_7f, TMP12);
2966
2967 vis_and(TMP16, MASK_7f, TMP16);
2968
2969 vis_padd16(TMP14, TMP12, TMP12);
2970 vis_st64(TMP12, dest[0]);
2971
2972 vis_padd16(TMP18, TMP16, TMP16);
2973 vis_st64_2(TMP16, dest, 8);
2974 dest += stride;
2975
2976 vis_and(REF_4, REF_6, TMP18);
2977
2978 vis_and(TMP0, MASK_fe, TMP0);
2979
2980 vis_and(TMP2, MASK_fe, TMP2);
2981 vis_mul8x16(CONST_128, TMP0, TMP0);
2982
2983 vis_faligndata(TMP6, TMP8, REF_2);
2984 vis_mul8x16(CONST_128, TMP2, TMP2);
2985
2986 vis_faligndata(TMP8, TMP10, REF_6);
2987
2988 vis_and(TMP0, MASK_7f, TMP0);
2989
2990 vis_and(TMP2, MASK_7f, TMP2);
2991
2992 vis_padd16(TMP20, TMP0, TMP0);
2993 vis_st64(TMP0, dest[0]);
2994
2995 vis_padd16(TMP18, TMP2, TMP2);
2996 vis_st64_2(TMP2, dest, 8);
2997 dest += stride;
2998 } while (--height);
2999
3000 vis_ld64(ref[0], TMP0);
3001 vis_xor(REF_0, REF_2, TMP12);
3002
3003 vis_ld64_2(ref, 8, TMP2);
3004 vis_xor(REF_4, REF_6, TMP16);
3005
3006 vis_ld64_2(ref, 16, TMP4);
3007 vis_and(REF_0, REF_2, TMP14);
3008
3009 vis_and(REF_4, REF_6, TMP18);
3010
3011 vis_faligndata(TMP0, TMP2, REF_0);
3012
3013 vis_faligndata(TMP2, TMP4, REF_4);
3014
3015 vis_and(TMP12, MASK_fe, TMP12);
3016
3017 vis_and(TMP16, MASK_fe, TMP16);
3018 vis_mul8x16(CONST_128, TMP12, TMP12);
3019
3020 vis_mul8x16(CONST_128, TMP16, TMP16);
3021 vis_xor(REF_0, REF_2, TMP0);
3022
3023 vis_xor(REF_4, REF_6, TMP2);
3024
3025 vis_and(REF_0, REF_2, TMP20);
3026
3027 vis_and(TMP12, MASK_7f, TMP12);
3028
3029 vis_and(TMP16, MASK_7f, TMP16);
3030
3031 vis_padd16(TMP14, TMP12, TMP12);
3032 vis_st64(TMP12, dest[0]);
3033
3034 vis_padd16(TMP18, TMP16, TMP16);
3035 vis_st64_2(TMP16, dest, 8);
3036 dest += stride;
3037
3038 vis_and(REF_4, REF_6, TMP18);
3039
3040 vis_and(TMP0, MASK_fe, TMP0);
3041
3042 vis_and(TMP2, MASK_fe, TMP2);
3043 vis_mul8x16(CONST_128, TMP0, TMP0);
3044
3045 vis_mul8x16(CONST_128, TMP2, TMP2);
3046
3047 vis_and(TMP0, MASK_7f, TMP0);
3048
3049 vis_and(TMP2, MASK_7f, TMP2);
3050
3051 vis_padd16(TMP20, TMP0, TMP0);
3052 vis_st64(TMP0, dest[0]);
3053
3054 vis_padd16(TMP18, TMP2, TMP2);
3055 vis_st64_2(TMP2, dest, 8);
3056 }
3057
3058 static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref,
3059 const int stride, int height)
3060 {
3061 ref = vis_alignaddr(ref);
3062 vis_ld64(ref[0], TMP0);
3063
3064 vis_ld64_2(ref, 8, TMP2);
3065 ref += stride;
3066
3067 vis_ld64(ref[0], TMP4);
3068
3069 vis_ld64_2(ref, 8, TMP6);
3070 ref += stride;
3071
3072 vis_ld64(constants_fe[0], MASK_fe);
3073 vis_faligndata(TMP0, TMP2, REF_0);
3074
3075 vis_ld64(constants_7f[0], MASK_7f);
3076 vis_faligndata(TMP4, TMP6, REF_2);
3077
3078 vis_ld64(constants128[0], CONST_128);
3079 height = (height >> 1) - 1;
3080 do { /* 12 cycles */
3081 vis_ld64(ref[0], TMP0);
3082 vis_xor(REF_0, REF_2, TMP4);
3083
3084 vis_ld64_2(ref, 8, TMP2);
3085 ref += stride;
3086 vis_and(TMP4, MASK_fe, TMP4);
3087
3088 vis_and(REF_0, REF_2, TMP6);
3089 vis_mul8x16(CONST_128, TMP4, TMP4);
3090
3091 vis_faligndata(TMP0, TMP2, REF_0);
3092 vis_ld64(ref[0], TMP0);
3093
3094 vis_ld64_2(ref, 8, TMP2);
3095 ref += stride;
3096 vis_xor(REF_0, REF_2, TMP12);
3097
3098 vis_and(TMP4, MASK_7f, TMP4);
3099
3100 vis_and(TMP12, MASK_fe, TMP12);
3101
3102 vis_mul8x16(CONST_128, TMP12, TMP12);
3103 vis_and(REF_0, REF_2, TMP14);
3104
3105 vis_padd16(TMP6, TMP4, DST_0);
3106 vis_st64(DST_0, dest[0]);
3107 dest += stride;
3108
3109 vis_faligndata(TMP0, TMP2, REF_2);
3110
3111 vis_and(TMP12, MASK_7f, TMP12);
3112
3113 vis_padd16(TMP14, TMP12, DST_0);
3114 vis_st64(DST_0, dest[0]);
3115 dest += stride;
3116 } while (--height);
3117
3118 vis_ld64(ref[0], TMP0);
3119 vis_xor(REF_0, REF_2, TMP4);
3120
3121 vis_ld64_2(ref, 8, TMP2);
3122 vis_and(TMP4, MASK_fe, TMP4);
3123
3124 vis_and(REF_0, REF_2, TMP6);
3125 vis_mul8x16(CONST_128, TMP4, TMP4);
3126
3127 vis_faligndata(TMP0, TMP2, REF_0);
3128
3129 vis_xor(REF_0, REF_2, TMP12);
3130
3131 vis_and(TMP4, MASK_7f, TMP4);
3132
3133 vis_and(TMP12, MASK_fe, TMP12);
3134
3135 vis_mul8x16(CONST_128, TMP12, TMP12);
3136 vis_and(REF_0, REF_2, TMP14);
3137
3138 vis_padd16(TMP6, TMP4, DST_0);
3139 vis_st64(DST_0, dest[0]);
3140 dest += stride;
3141
3142 vis_and(TMP12, MASK_7f, TMP12);
3143
3144 vis_padd16(TMP14, TMP12, DST_0);