dsputil_vis.c
Go to the documentation of this file.
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 "dsputil_vis.h"
31 
32 #include "vis.h"
33 
34 /* The trick used in some of this file is the formula from the MMX
35  * motion comp code, which is:
36  *
37  * (x+y+1)>>1 == (x|y)-((x^y)>>1)
38  *
39  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
40  * We avoid overflows by masking before we do the shift, and we
41  * implement the shift by multiplying by 1/2 using mul8x16. So in
42  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
43  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
44  * the value 0x80808080 is in f8):
45  *
46  * fxor f0, f2, f10
47  * fand f10, f4, f10
48  * fmul8x16 f8, f10, f10
49  * fand f10, f6, f10
50  * for f0, f2, f12
51  * fpsub16 f12, f10, f10
52  */
53 
54 #define DUP4(x) {x, x, x, x}
55 #define DUP8(x) {x, x, x, x, x, x, x, x}
56 DECLARE_ALIGNED(8, static const int16_t, constants1)[] = DUP4 (1);
57 DECLARE_ALIGNED(8, static const int16_t, constants2)[] = DUP4 (2);
58 DECLARE_ALIGNED(8, static const int16_t, constants3)[] = DUP4 (3);
59 DECLARE_ALIGNED(8, static const int16_t, constants6)[] = DUP4 (6);
60 DECLARE_ALIGNED(8, static const int8_t, constants_fe)[] = DUP8 (0xfe);
61 DECLARE_ALIGNED(8, static const int8_t, constants_7f)[] = DUP8 (0x7f);
62 DECLARE_ALIGNED(8, static const int8_t, constants128)[] = DUP8 (128);
63 DECLARE_ALIGNED(8, static const int16_t, constants256_512)[] =
64  {256, 512, 256, 512};
65 DECLARE_ALIGNED(8, static const int16_t, constants256_1024)[] =
66  {256, 1024, 256, 1024};
67 
68 #define REF_0 0
69 #define REF_0_1 1
70 #define REF_2 2
71 #define REF_2_1 3
72 #define REF_4 4
73 #define REF_4_1 5
74 #define REF_6 6
75 #define REF_6_1 7
76 #define REF_S0 8
77 #define REF_S0_1 9
78 #define REF_S2 10
79 #define REF_S2_1 11
80 #define REF_S4 12
81 #define REF_S4_1 13
82 #define REF_S6 14
83 #define REF_S6_1 15
84 #define DST_0 16
85 #define DST_1 17
86 #define DST_2 18
87 #define DST_3 19
88 #define CONST_1 20
89 #define CONST_2 20
90 #define CONST_3 20
91 #define CONST_6 20
92 #define MASK_fe 20
93 #define CONST_128 22
94 #define CONST_256 22
95 #define CONST_512 22
96 #define CONST_1024 22
97 #define TMP0 24
98 #define TMP1 25
99 #define TMP2 26
100 #define TMP3 27
101 #define TMP4 28
102 #define TMP5 29
103 #define ZERO 30
104 #define MASK_7f 30
105 
106 #define TMP6 32
107 #define TMP8 34
108 #define TMP10 36
109 #define TMP12 38
110 #define TMP14 40
111 #define TMP16 42
112 #define TMP18 44
113 #define TMP20 46
114 #define TMP22 48
115 #define TMP24 50
116 #define TMP26 52
117 #define TMP28 54
118 #define TMP30 56
119 #define TMP32 58
120 
121 static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * ref,
122  const int stride, int height)
123 {
124  ref = vis_alignaddr(ref);
125  do { /* 5 cycles */
126  vis_ld64(ref[0], TMP0);
127 
128  vis_ld64_2(ref, 8, TMP2);
129 
130  vis_ld64_2(ref, 16, TMP4);
131  ref += stride;
132 
134  vis_st64(REF_0, dest[0]);
135 
137  vis_st64_2(REF_2, dest, 8);
138  dest += stride;
139  } while (--height);
140 }
141 
142 static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * ref,
143  const int stride, int height)
144 {
145  ref = vis_alignaddr(ref);
146  do { /* 4 cycles */
147  vis_ld64(ref[0], TMP0);
148 
149  vis_ld64(ref[8], TMP2);
150  ref += stride;
151 
152  /* stall */
153 
155  vis_st64(REF_0, dest[0]);
156  dest += stride;
157  } while (--height);
158 }
159 
160 
161 static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * ref,
162  const int stride, int height)
163 {
164  int stride_8 = stride + 8;
165 
166  ref = vis_alignaddr(ref);
167 
168  vis_ld64(ref[0], TMP0);
169 
170  vis_ld64(ref[8], TMP2);
171 
172  vis_ld64(ref[16], TMP4);
173 
174  vis_ld64(dest[0], DST_0);
175 
176  vis_ld64(dest[8], DST_2);
177 
180 
183 
185 
186  ref += stride;
187  height = (height >> 1) - 1;
188 
189  do { /* 24 cycles */
190  vis_ld64(ref[0], TMP0);
191  vis_xor(DST_0, REF_0, TMP6);
192 
193  vis_ld64_2(ref, 8, TMP2);
195 
196  vis_ld64_2(ref, 16, TMP4);
197  ref += stride;
199  vis_xor(DST_2, REF_2, TMP8);
200 
202 
203  vis_or(DST_0, REF_0, TMP10);
204  vis_ld64_2(dest, stride, DST_0);
206 
207  vis_or(DST_2, REF_2, TMP12);
208  vis_ld64_2(dest, stride_8, DST_2);
209 
210  vis_ld64(ref[0], TMP14);
212 
214 
216  vis_st64(TMP6, dest[0]);
217 
219  vis_st64_2(TMP8, dest, 8);
220 
221  dest += stride;
222  vis_ld64_2(ref, 8, TMP16);
224 
225  vis_ld64_2(ref, 16, TMP18);
227  ref += stride;
228 
230 
232 
235 
237 
238  vis_or(DST_0, REF_0, TMP24);
240 
241  vis_or(DST_2, REF_2, TMP26);
242 
243  vis_ld64_2(dest, stride, DST_0);
245 
246  vis_ld64_2(dest, stride_8, DST_2);
248 
250 
252 
254  vis_st64(TMP20, dest[0]);
255 
257  vis_st64_2(TMP22, dest, 8);
258  dest += stride;
259  } while (--height);
260 
261  vis_ld64(ref[0], TMP0);
262  vis_xor(DST_0, REF_0, TMP6);
263 
264  vis_ld64_2(ref, 8, TMP2);
266 
267  vis_ld64_2(ref, 16, TMP4);
269  vis_xor(DST_2, REF_2, TMP8);
270 
272 
273  vis_or(DST_0, REF_0, TMP10);
274  vis_ld64_2(dest, stride, DST_0);
276 
277  vis_or(DST_2, REF_2, TMP12);
278  vis_ld64_2(dest, stride_8, DST_2);
279 
280  vis_ld64(ref[0], TMP14);
282 
284 
286  vis_st64(TMP6, dest[0]);
287 
289  vis_st64_2(TMP8, dest, 8);
290 
291  dest += stride;
293 
295 
297 
299 
302 
304 
305  vis_or(DST_0, REF_0, TMP24);
307 
308  vis_or(DST_2, REF_2, TMP26);
309 
311 
313 
315  vis_st64(TMP20, dest[0]);
316 
318  vis_st64_2(TMP22, dest, 8);
319 }
320 
321 static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * ref,
322  const int stride, int height)
323 {
324  ref = vis_alignaddr(ref);
325 
326  vis_ld64(ref[0], TMP0);
327 
328  vis_ld64(ref[8], TMP2);
329 
330  vis_ld64(dest[0], DST_0);
331 
333 
336 
338 
339  ref += stride;
340  height = (height >> 1) - 1;
341 
342  do { /* 12 cycles */
343  vis_ld64(ref[0], TMP0);
344  vis_xor(DST_0, REF_0, TMP4);
345 
346  vis_ld64(ref[8], TMP2);
348 
349  vis_or(DST_0, REF_0, TMP6);
350  vis_ld64_2(dest, stride, DST_0);
351  ref += stride;
353 
354  vis_ld64(ref[0], TMP12);
356 
357  vis_ld64(ref[8], TMP2);
358  vis_xor(DST_0, REF_0, TMP0);
359  ref += stride;
360 
362 
364 
366  vis_st64(TMP4, dest[0]);
367  dest += stride;
369 
370  vis_or(DST_0, REF_0, TMP6);
371  vis_ld64_2(dest, stride, DST_0);
372 
374 
376 
378  vis_st64(TMP4, dest[0]);
379  dest += stride;
380  } while (--height);
381 
382  vis_ld64(ref[0], TMP0);
383  vis_xor(DST_0, REF_0, TMP4);
384 
385  vis_ld64(ref[8], TMP2);
387 
388  vis_or(DST_0, REF_0, TMP6);
389  vis_ld64_2(dest, stride, DST_0);
391 
393 
394  vis_xor(DST_0, REF_0, TMP0);
395 
397 
399 
401  vis_st64(TMP4, dest[0]);
402  dest += stride;
404 
405  vis_or(DST_0, REF_0, TMP6);
406 
408 
410  vis_st64(TMP4, dest[0]);
411 }
412 
413 static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * ref,
414  const int stride, int height)
415 {
416  unsigned long off = (unsigned long) ref & 0x7;
417  unsigned long off_plus_1 = off + 1;
418 
419  ref = vis_alignaddr(ref);
420 
421  vis_ld64(ref[0], TMP0);
422 
423  vis_ld64_2(ref, 8, TMP2);
424 
425  vis_ld64_2(ref, 16, TMP4);
426 
428 
431 
434 
435  if (off != 0x7) {
436  vis_alignaddr_g0((void *)off_plus_1);
439  } else {
440  vis_src1(TMP2, REF_2);
441  vis_src1(TMP4, REF_6);
442  }
443 
444  ref += stride;
445  height = (height >> 1) - 1;
446 
447  do { /* 34 cycles */
448  vis_ld64(ref[0], TMP0);
449  vis_xor(REF_0, REF_2, TMP6);
450 
451  vis_ld64_2(ref, 8, TMP2);
452  vis_xor(REF_4, REF_6, TMP8);
453 
454  vis_ld64_2(ref, 16, TMP4);
456  ref += stride;
457 
458  vis_ld64(ref[0], TMP14);
461 
462  vis_ld64_2(ref, 8, TMP16);
464  vis_or(REF_0, REF_2, TMP10);
465 
466  vis_ld64_2(ref, 16, TMP18);
467  ref += stride;
468  vis_or(REF_4, REF_6, TMP12);
469 
470  vis_alignaddr_g0((void *)off);
471 
473 
475 
476  if (off != 0x7) {
477  vis_alignaddr_g0((void *)off_plus_1);
480  } else {
481  vis_src1(TMP2, REF_2);
482  vis_src1(TMP4, REF_6);
483  }
484 
486 
488 
490  vis_st64(TMP6, dest[0]);
491 
493  vis_st64_2(TMP8, dest, 8);
494  dest += stride;
495 
496  vis_xor(REF_0, REF_2, TMP6);
497 
498  vis_xor(REF_4, REF_6, TMP8);
499 
501 
504 
506  vis_or(REF_0, REF_2, TMP10);
507 
508  vis_or(REF_4, REF_6, TMP12);
509 
510  vis_alignaddr_g0((void *)off);
511 
513 
515 
516  if (off != 0x7) {
517  vis_alignaddr_g0((void *)off_plus_1);
520  } else {
521  vis_src1(TMP16, REF_2);
522  vis_src1(TMP18, REF_6);
523  }
524 
526 
528 
530  vis_st64(TMP6, dest[0]);
531 
533  vis_st64_2(TMP8, dest, 8);
534  dest += stride;
535  } while (--height);
536 
537  vis_ld64(ref[0], TMP0);
538  vis_xor(REF_0, REF_2, TMP6);
539 
540  vis_ld64_2(ref, 8, TMP2);
541  vis_xor(REF_4, REF_6, TMP8);
542 
543  vis_ld64_2(ref, 16, TMP4);
545 
548 
550  vis_or(REF_0, REF_2, TMP10);
551 
552  vis_or(REF_4, REF_6, TMP12);
553 
554  vis_alignaddr_g0((void *)off);
555 
557 
559 
560  if (off != 0x7) {
561  vis_alignaddr_g0((void *)off_plus_1);
564  } else {
565  vis_src1(TMP2, REF_2);
566  vis_src1(TMP4, REF_6);
567  }
568 
570 
572 
574  vis_st64(TMP6, dest[0]);
575 
577  vis_st64_2(TMP8, dest, 8);
578  dest += stride;
579 
580  vis_xor(REF_0, REF_2, TMP6);
581 
582  vis_xor(REF_4, REF_6, TMP8);
583 
585 
588 
590  vis_or(REF_0, REF_2, TMP10);
591 
592  vis_or(REF_4, REF_6, TMP12);
593 
595 
597 
599  vis_st64(TMP6, dest[0]);
600 
602  vis_st64_2(TMP8, dest, 8);
603 }
604 
605 static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * ref,
606  const int stride, int height)
607 {
608  unsigned long off = (unsigned long) ref & 0x7;
609  unsigned long off_plus_1 = off + 1;
610 
611  ref = vis_alignaddr(ref);
612 
613  vis_ld64(ref[0], TMP0);
614 
615  vis_ld64(ref[8], TMP2);
616 
618 
620 
623 
624  if (off != 0x7) {
625  vis_alignaddr_g0((void *)off_plus_1);
627  } else {
628  vis_src1(TMP2, REF_2);
629  }
630 
631  ref += stride;
632  height = (height >> 1) - 1;
633 
634  do { /* 20 cycles */
635  vis_ld64(ref[0], TMP0);
636  vis_xor(REF_0, REF_2, TMP4);
637 
638  vis_ld64_2(ref, 8, TMP2);
640  ref += stride;
641 
642  vis_ld64(ref[0], TMP8);
643  vis_or(REF_0, REF_2, TMP6);
645 
646  vis_alignaddr_g0((void *)off);
647 
648  vis_ld64_2(ref, 8, TMP10);
649  ref += stride;
651 
652  if (off != 0x7) {
653  vis_alignaddr_g0((void *)off_plus_1);
655  } else {
656  vis_src1(TMP2, REF_2);
657  }
658 
660 
662  vis_st64(DST_0, dest[0]);
663  dest += stride;
664 
666 
668 
669  vis_or(REF_0, REF_2, TMP14);
671 
672  vis_alignaddr_g0((void *)off);
674  if (off != 0x7) {
675  vis_alignaddr_g0((void *)off_plus_1);
677  } else {
678  vis_src1(TMP10, REF_2);
679  }
680 
682 
684  vis_st64(DST_0, dest[0]);
685  dest += stride;
686  } while (--height);
687 
688  vis_ld64(ref[0], TMP0);
689  vis_xor(REF_0, REF_2, TMP4);
690 
691  vis_ld64_2(ref, 8, TMP2);
693 
694  vis_or(REF_0, REF_2, TMP6);
696 
697  vis_alignaddr_g0((void *)off);
698 
700 
701  if (off != 0x7) {
702  vis_alignaddr_g0((void *)off_plus_1);
704  } else {
705  vis_src1(TMP2, REF_2);
706  }
707 
709 
711  vis_st64(DST_0, dest[0]);
712  dest += stride;
713 
715 
717 
718  vis_or(REF_0, REF_2, TMP14);
720 
722 
724  vis_st64(DST_0, dest[0]);
725  dest += stride;
726 }
727 
728 static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * ref,
729  const int stride, int height)
730 {
731  unsigned long off = (unsigned long) ref & 0x7;
732  unsigned long off_plus_1 = off + 1;
733 
735 
737  vis_fzero(ZERO);
739 
740  ref = vis_alignaddr(ref);
741  do { /* 26 cycles */
742  vis_ld64(ref[0], TMP0);
743 
744  vis_ld64(ref[8], TMP2);
745 
746  vis_alignaddr_g0((void *)off);
747 
748  vis_ld64(ref[16], TMP4);
749 
750  vis_ld64(dest[0], DST_0);
752 
753  vis_ld64(dest[8], DST_2);
755 
756  if (off != 0x7) {
757  vis_alignaddr_g0((void *)off_plus_1);
760  } else {
761  vis_src1(TMP2, REF_2);
762  vis_src1(TMP4, REF_6);
763  }
764 
766 
769 
771 
773 
776 
778 
780 
783 
786 
789 
792 
795 
796  vis_st64(DST_0, dest[0]);
799 
802 
804 
806 
809 
811  vis_st64(DST_2, dest[8]);
812 
813  ref += stride;
814  dest += stride;
815  } while (--height);
816 }
817 
818 static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * ref,
819  const int stride, int height)
820 {
821  unsigned long off = (unsigned long) ref & 0x7;
822  unsigned long off_plus_1 = off + 1;
823  int stride_times_2 = stride << 1;
824 
826 
828  vis_fzero(ZERO);
830 
831  ref = vis_alignaddr(ref);
832  height >>= 2;
833  do { /* 47 cycles */
834  vis_ld64(ref[0], TMP0);
835 
836  vis_ld64_2(ref, 8, TMP2);
837  ref += stride;
838 
839  vis_alignaddr_g0((void *)off);
840 
841  vis_ld64(ref[0], TMP4);
843 
844  vis_ld64_2(ref, 8, TMP6);
845  ref += stride;
846 
847  vis_ld64(ref[0], TMP8);
848 
849  vis_ld64_2(ref, 8, TMP10);
850  ref += stride;
852 
853  vis_ld64(ref[0], TMP12);
854 
855  vis_ld64_2(ref, 8, TMP14);
856  ref += stride;
858 
860 
861  if (off != 0x7) {
862  vis_alignaddr_g0((void *)off_plus_1);
863 
864  vis_ld64(dest[0], DST_0);
866 
867  vis_ld64_2(dest, stride, DST_2);
869 
871 
873  } else {
874  vis_ld64(dest[0], DST_0);
875  vis_src1(TMP2, REF_2);
876 
877  vis_ld64_2(dest, stride, DST_2);
878  vis_src1(TMP6, REF_6);
879 
881 
883  }
884 
887 
890 
893 
896 
899 
902 
905 
908 
911 
914 
917 
919  vis_st64(DST_0, dest[0]);
920  dest += stride;
922 
923  vis_ld64_2(dest, stride, DST_0);
925 
926  vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
929 
931  vis_st64(DST_2, dest[0]);
932  dest += stride;
933 
936 
939 
942 
945 
948 
951 
954 
957 
959  vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
960 
961  vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
963 
966 
969  vis_st64(DST_0, dest[0]);
970  dest += stride;
971 
973 
976 
978  vis_st64(DST_2, dest[0]);
979  dest += stride;
980  } while (--height);
981 }
982 
983 static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * ref,
984  const int stride, int height)
985 {
986  ref = vis_alignaddr(ref);
987  vis_ld64(ref[0], TMP0);
988 
989  vis_ld64_2(ref, 8, TMP2);
990 
991  vis_ld64_2(ref, 16, TMP4);
992  ref += stride;
993 
994  vis_ld64(ref[0], TMP6);
996 
997  vis_ld64_2(ref, 8, TMP8);
999 
1000  vis_ld64_2(ref, 16, TMP10);
1001  ref += stride;
1002 
1005 
1008 
1010  height = (height >> 1) - 1;
1011  do { /* 24 cycles */
1012  vis_ld64(ref[0], TMP0);
1013  vis_xor(REF_0, REF_2, TMP12);
1014 
1015  vis_ld64_2(ref, 8, TMP2);
1016  vis_xor(REF_4, REF_6, TMP16);
1017 
1018  vis_ld64_2(ref, 16, TMP4);
1019  ref += stride;
1020  vis_or(REF_0, REF_2, TMP14);
1021 
1022  vis_ld64(ref[0], TMP6);
1023  vis_or(REF_4, REF_6, TMP18);
1024 
1025  vis_ld64_2(ref, 8, TMP8);
1027 
1028  vis_ld64_2(ref, 16, TMP10);
1029  ref += stride;
1031 
1033 
1036 
1038  vis_xor(REF_0, REF_2, TMP0);
1039 
1040  vis_xor(REF_4, REF_6, TMP2);
1041 
1042  vis_or(REF_0, REF_2, TMP20);
1043 
1045 
1047 
1049  vis_st64(TMP12, dest[0]);
1050 
1052  vis_st64_2(TMP16, dest, 8);
1053  dest += stride;
1054 
1055  vis_or(REF_4, REF_6, TMP18);
1056 
1057  vis_and(TMP0, MASK_fe, TMP0);
1058 
1059  vis_and(TMP2, MASK_fe, TMP2);
1061 
1064 
1066 
1067  vis_and(TMP0, MASK_7f, TMP0);
1068 
1069  vis_and(TMP2, MASK_7f, TMP2);
1070 
1072  vis_st64(TMP0, dest[0]);
1073 
1075  vis_st64_2(TMP2, dest, 8);
1076  dest += stride;
1077  } while (--height);
1078 
1079  vis_ld64(ref[0], TMP0);
1080  vis_xor(REF_0, REF_2, TMP12);
1081 
1082  vis_ld64_2(ref, 8, TMP2);
1083  vis_xor(REF_4, REF_6, TMP16);
1084 
1085  vis_ld64_2(ref, 16, TMP4);
1086  vis_or(REF_0, REF_2, TMP14);
1087 
1088  vis_or(REF_4, REF_6, TMP18);
1089 
1091 
1093 
1095 
1098 
1100  vis_xor(REF_0, REF_2, TMP0);
1101 
1102  vis_xor(REF_4, REF_6, TMP2);
1103 
1104  vis_or(REF_0, REF_2, TMP20);
1105 
1107 
1109 
1111  vis_st64(TMP12, dest[0]);
1112 
1114  vis_st64_2(TMP16, dest, 8);
1115  dest += stride;
1116 
1117  vis_or(REF_4, REF_6, TMP18);
1118 
1119  vis_and(TMP0, MASK_fe, TMP0);
1120 
1121  vis_and(TMP2, MASK_fe, TMP2);
1123 
1125 
1126  vis_and(TMP0, MASK_7f, TMP0);
1127 
1128  vis_and(TMP2, MASK_7f, TMP2);
1129 
1131  vis_st64(TMP0, dest[0]);
1132 
1134  vis_st64_2(TMP2, dest, 8);
1135 }
1136 
1137 static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * ref,
1138  const int stride, int height)
1139 {
1140  ref = vis_alignaddr(ref);
1141  vis_ld64(ref[0], TMP0);
1142 
1143  vis_ld64_2(ref, 8, TMP2);
1144  ref += stride;
1145 
1146  vis_ld64(ref[0], TMP4);
1147 
1148  vis_ld64_2(ref, 8, TMP6);
1149  ref += stride;
1150 
1153 
1156 
1158  height = (height >> 1) - 1;
1159  do { /* 12 cycles */
1160  vis_ld64(ref[0], TMP0);
1161  vis_xor(REF_0, REF_2, TMP4);
1162 
1163  vis_ld64_2(ref, 8, TMP2);
1164  ref += stride;
1165  vis_and(TMP4, MASK_fe, TMP4);
1166 
1167  vis_or(REF_0, REF_2, TMP6);
1169 
1171  vis_ld64(ref[0], TMP0);
1172 
1173  vis_ld64_2(ref, 8, TMP2);
1174  ref += stride;
1175  vis_xor(REF_0, REF_2, TMP12);
1176 
1177  vis_and(TMP4, MASK_7f, TMP4);
1178 
1180 
1182  vis_or(REF_0, REF_2, TMP14);
1183 
1185  vis_st64(DST_0, dest[0]);
1186  dest += stride;
1187 
1189 
1191 
1193  vis_st64(DST_0, dest[0]);
1194  dest += stride;
1195  } while (--height);
1196 
1197  vis_ld64(ref[0], TMP0);
1198  vis_xor(REF_0, REF_2, TMP4);
1199 
1200  vis_ld64_2(ref, 8, TMP2);
1201  vis_and(TMP4, MASK_fe, TMP4);
1202 
1203  vis_or(REF_0, REF_2, TMP6);
1205 
1207 
1208  vis_xor(REF_0, REF_2, TMP12);
1209 
1210  vis_and(TMP4, MASK_7f, TMP4);
1211 
1213 
1215  vis_or(REF_0, REF_2, TMP14);
1216 
1218  vis_st64(DST_0, dest[0]);
1219  dest += stride;
1220 
1222 
1224  vis_st64(DST_0, dest[0]);
1225 }
1226 
1227 static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * ref,
1228  const int stride, int height)
1229 {
1230  int stride_8 = stride + 8;
1231  int stride_16 = stride + 16;
1232 
1234 
1235  ref = vis_alignaddr(ref);
1236 
1237  vis_ld64(ref[ 0], TMP0);
1238  vis_fzero(ZERO);
1239 
1240  vis_ld64(ref[ 8], TMP2);
1241 
1242  vis_ld64(ref[16], TMP4);
1243 
1246 
1249  height >>= 1;
1250 
1251  do { /* 31 cycles */
1252  vis_ld64_2(ref, stride, TMP0);
1255 
1256  vis_ld64_2(ref, stride_8, TMP2);
1259 
1260  vis_ld64_2(ref, stride_16, TMP4);
1261  ref += stride;
1262 
1263  vis_ld64(dest[0], DST_0);
1265 
1266  vis_ld64_2(dest, 8, DST_2);
1268 
1269  vis_ld64_2(ref, stride, TMP6);
1272 
1273  vis_ld64_2(ref, stride_8, TMP8);
1275 
1276  vis_ld64_2(ref, stride_16, TMP10);
1277  ref += stride;
1278 
1279  vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
1282 
1283  vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
1286 
1289 
1292 
1295 
1297 
1300 
1303 
1306 
1309 
1312 
1315 
1318 
1321 
1324 
1326  vis_st64(DST_0, dest[0]);
1328 
1331 
1333  vis_st64_2(DST_2, dest, 8);
1334  dest += stride;
1336 
1338 
1341 
1344  vis_st64(DST_0, dest[0]);
1345 
1348 
1350  vis_st64_2(DST_2, dest, 8);
1351  dest += stride;
1352  } while (--height);
1353 }
1354 
1355 static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * ref,
1356  const int stride, int height)
1357 {
1358  int stride_8 = stride + 8;
1359 
1361 
1362  ref = vis_alignaddr(ref);
1363 
1364  vis_ld64(ref[ 0], TMP0);
1365  vis_fzero(ZERO);
1366 
1367  vis_ld64(ref[ 8], TMP2);
1368 
1371 
1373 
1374  height >>= 1;
1375  do { /* 20 cycles */
1376  vis_ld64_2(ref, stride, TMP0);
1379 
1380  vis_ld64_2(ref, stride_8, TMP2);
1381  ref += stride;
1382 
1383  vis_ld64(dest[0], DST_0);
1384 
1385  vis_ld64_2(dest, stride, DST_2);
1387 
1388  vis_ld64_2(ref, stride, TMP4);
1391 
1392  vis_ld64_2(ref, stride_8, TMP6);
1393  ref += stride;
1396 
1399 
1402 
1404 
1406 
1409 
1412 
1414  vis_pack16(TMP0, DST_0);
1415 
1416  vis_pack16(TMP2, DST_1);
1417  vis_st64(DST_0, dest[0]);
1418  dest += stride;
1420 
1422 
1424 
1426  vis_pack16(TMP0, DST_2);
1427 
1428  vis_pack16(TMP2, DST_3);
1429  vis_st64(DST_2, dest[0]);
1430  dest += stride;
1431  } while (--height);
1432 }
1433 
1434 static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * ref,
1435  const int stride, int height)
1436 {
1437  unsigned long off = (unsigned long) ref & 0x7;
1438  unsigned long off_plus_1 = off + 1;
1439  int stride_8 = stride + 8;
1440  int stride_16 = stride + 16;
1441 
1443 
1444  ref = vis_alignaddr(ref);
1445 
1446  vis_ld64(ref[ 0], TMP0);
1447  vis_fzero(ZERO);
1448 
1449  vis_ld64(ref[ 8], TMP2);
1450 
1451  vis_ld64(ref[16], TMP4);
1452 
1455 
1458 
1459  if (off != 0x7) {
1460  vis_alignaddr_g0((void *)off_plus_1);
1463  } else {
1464  vis_src1(TMP2, REF_S2);
1465  vis_src1(TMP4, REF_S6);
1466  }
1467 
1468  height >>= 1;
1469  do {
1470  vis_ld64_2(ref, stride, TMP0);
1473 
1474  vis_alignaddr_g0((void *)off);
1475 
1476  vis_ld64_2(ref, stride_8, TMP2);
1479 
1480  vis_ld64_2(ref, stride_16, TMP4);
1481  ref += stride;
1484 
1485  vis_ld64_2(ref, stride, TMP6);
1488 
1489  vis_ld64_2(ref, stride_8, TMP8);
1491 
1492  vis_ld64_2(ref, stride_16, TMP10);
1493  ref += stride;
1495 
1497 
1499 
1500  if (off != 0x7) {
1501  vis_alignaddr_g0((void *)off_plus_1);
1506  } else {
1507  vis_src1(TMP2, REF_2);
1508  vis_src1(TMP4, REF_6);
1509  vis_src1(TMP8, REF_S2);
1510  vis_src1(TMP10, REF_S6);
1511  }
1512 
1515 
1518 
1521 
1524 
1525  vis_padd16(TMP8, TMP4, TMP8);
1527 
1530 
1532 
1534 
1536 
1539 
1541  vis_st64(DST_0, dest[0]);
1543 
1546 
1549 
1552 
1555 
1557 
1559 
1562 
1564  vis_st64_2(DST_2, dest, 8);
1565  dest += stride;
1567 
1570 
1573 
1576 
1578  vis_st64(DST_0, dest[0]);
1580 
1582 
1583  vis_padd16(TMP0, TMP4, TMP0);
1584 
1585  vis_padd16(TMP2, TMP6, TMP2);
1586 
1588 
1590  vis_pack16(TMP0, DST_2);
1591 
1592  vis_pack16(TMP2, DST_3);
1593  vis_st64_2(DST_2, dest, 8);
1594  dest += stride;
1595  } while (--height);
1596 }
1597 
1598 static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * ref,
1599  const int stride, int height)
1600 {
1601  unsigned long off = (unsigned long) ref & 0x7;
1602  unsigned long off_plus_1 = off + 1;
1603  int stride_8 = stride + 8;
1604 
1606 
1607  ref = vis_alignaddr(ref);
1608 
1609  vis_ld64(ref[ 0], TMP0);
1610  vis_fzero(ZERO);
1611 
1612  vis_ld64(ref[ 8], TMP2);
1613 
1615 
1618 
1619  if (off != 0x7) {
1620  vis_alignaddr_g0((void *)off_plus_1);
1622  } else {
1623  vis_src1(TMP2, REF_S2);
1624  }
1625 
1626  height >>= 1;
1627  do { /* 26 cycles */
1628  vis_ld64_2(ref, stride, TMP0);
1631 
1632  vis_alignaddr_g0((void *)off);
1633 
1634  vis_ld64_2(ref, stride_8, TMP2);
1635  ref += stride;
1638 
1639  vis_ld64_2(ref, stride, TMP4);
1640 
1641  vis_ld64_2(ref, stride_8, TMP6);
1642  ref += stride;
1644 
1646 
1648 
1650 
1651  if (off != 0x7) {
1652  vis_alignaddr_g0((void *)off_plus_1);
1655  } else {
1656  vis_src1(TMP2, REF_S6);
1657  vis_src1(TMP6, REF_S2);
1658  }
1659 
1662 
1665 
1668 
1671 
1674 
1676 
1678 
1680 
1682  vis_pack16(TMP8, DST_0);
1683 
1685  vis_st64(DST_0, dest[0]);
1686  dest += stride;
1688 
1690 
1692 
1695 
1697  vis_st64(DST_2, dest[0]);
1698  dest += stride;
1699  } while (--height);
1700 }
1701 
1702 static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * ref,
1703  const int stride, int height)
1704 {
1705  unsigned long off = (unsigned long) ref & 0x7;
1706  unsigned long off_plus_1 = off + 1;
1707  int stride_8 = stride + 8;
1708  int stride_16 = stride + 16;
1709 
1711 
1712  ref = vis_alignaddr(ref);
1713 
1714  vis_ld64(ref[ 0], TMP0);
1715  vis_fzero(ZERO);
1716 
1717  vis_ld64(ref[ 8], TMP2);
1718 
1719  vis_ld64(ref[16], TMP4);
1720 
1723 
1726 
1727  if (off != 0x7) {
1728  vis_alignaddr_g0((void *)off_plus_1);
1731  } else {
1732  vis_src1(TMP2, REF_S2);
1733  vis_src1(TMP4, REF_S6);
1734  }
1735 
1736  height >>= 1;
1737  do { /* 55 cycles */
1738  vis_ld64_2(ref, stride, TMP0);
1741 
1742  vis_alignaddr_g0((void *)off);
1743 
1744  vis_ld64_2(ref, stride_8, TMP2);
1747 
1748  vis_ld64_2(ref, stride_16, TMP4);
1749  ref += stride;
1752 
1753  vis_ld64_2(ref, stride, TMP6);
1756 
1757  vis_ld64_2(ref, stride_8, TMP8);
1759 
1760  vis_ld64_2(ref, stride_16, TMP10);
1761  ref += stride;
1763 
1764  vis_ld64(dest[0], DST_0);
1766 
1767  vis_ld64_2(dest, 8, DST_2);
1769 
1770  if (off != 0x7) {
1771  vis_alignaddr_g0((void *)off_plus_1);
1776  } else {
1777  vis_src1(TMP2, REF_2);
1778  vis_src1(TMP4, REF_6);
1779  vis_src1(TMP8, REF_S2);
1780  vis_src1(TMP10, REF_S6);
1781  }
1782 
1785 
1788 
1791 
1794 
1797 
1798  vis_padd16(TMP0, TMP4, TMP0);
1800 
1801  vis_padd16(TMP2, TMP6, TMP2);
1803 
1806 
1809 
1812 
1815 
1817 
1820 
1822  vis_st64(DST_0, dest[0]);
1824 
1825  vis_ld64_2(dest, stride, DST_0);
1828 
1829  vis_padd16(TMP4, TMP8, TMP4);
1831 
1833 
1835 
1837 
1839 
1841 
1844 
1847 
1849  vis_st64_2(DST_2, dest, 8);
1850  dest += stride;
1851 
1852  vis_ld64_2(dest, 8, DST_2);
1855 
1858 
1861 
1864 
1866 
1868 
1870  vis_pack16(TMP8, DST_0);
1871 
1873  vis_st64(DST_0, dest[0]);
1874 
1876 
1879 
1882 
1884 
1886 
1887  /* stall */
1888 
1891 
1893  vis_st64_2(DST_2, dest, 8);
1894  dest += stride;
1895  } while (--height);
1896 }
1897 
1898 static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * ref,
1899  const int stride, int height)
1900 {
1901  unsigned long off = (unsigned long) ref & 0x7;
1902  unsigned long off_plus_1 = off + 1;
1903  int stride_8 = stride + 8;
1904 
1906 
1907  ref = vis_alignaddr(ref);
1908 
1909  vis_ld64(ref[0], TMP0);
1910  vis_fzero(ZERO);
1911 
1912  vis_ld64_2(ref, 8, TMP2);
1913 
1915 
1918 
1919  if (off != 0x7) {
1920  vis_alignaddr_g0((void *)off_plus_1);
1922  } else {
1923  vis_src1(TMP2, REF_S2);
1924  }
1925 
1926  height >>= 1;
1927  do { /* 31 cycles */
1928  vis_ld64_2(ref, stride, TMP0);
1931 
1932  vis_ld64_2(ref, stride_8, TMP2);
1933  ref += stride;
1936 
1937  vis_alignaddr_g0((void *)off);
1938 
1939  vis_ld64_2(ref, stride, TMP4);
1941 
1942  vis_ld64_2(ref, stride_8, TMP6);
1943  ref += stride;
1944 
1945  vis_ld64(dest[0], DST_0);
1947 
1948  vis_ld64_2(dest, stride, DST_2);
1949 
1950  if (off != 0x7) {
1951  vis_alignaddr_g0((void *)off_plus_1);
1954  } else {
1955  vis_src1(TMP2, REF_S6);
1956  vis_src1(TMP6, REF_S2);
1957  }
1958 
1961 
1964 
1967 
1970 
1973 
1976 
1979 
1982 
1985 
1987 
1989 
1991 
1993  vis_pack16(TMP8, DST_0);
1994 
1996  vis_st64(DST_0, dest[0]);
1997  dest += stride;
1998 
2000 
2002 
2004 
2006 
2008 
2011 
2013  vis_st64(DST_2, dest[0]);
2014  dest += stride;
2015  } while (--height);
2016 }
2017 
2018 /* End of rounding code */
2019 
2020 /* Start of no rounding code */
2021 /* The trick used in some of this file is the formula from the MMX
2022  * motion comp code, which is:
2023  *
2024  * (x+y)>>1 == (x&y)+((x^y)>>1)
2025  *
2026  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
2027  * We avoid overflows by masking before we do the shift, and we
2028  * implement the shift by multiplying by 1/2 using mul8x16. So in
2029  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
2030  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
2031  * the value 0x80808080 is in f8):
2032  *
2033  * fxor f0, f2, f10
2034  * fand f10, f4, f10
2035  * fmul8x16 f8, f10, f10
2036  * fand f10, f6, f10
2037  * fand f0, f2, f12
2038  * fpadd16 f12, f10, f10
2039  */
2040 
2041 static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,
2042  const int stride, int height)
2043 {
2044  ref = vis_alignaddr(ref);
2045  do { /* 5 cycles */
2046  vis_ld64(ref[0], TMP0);
2047 
2048  vis_ld64_2(ref, 8, TMP2);
2049 
2050  vis_ld64_2(ref, 16, TMP4);
2051  ref += stride;
2052 
2054  vis_st64(REF_0, dest[0]);
2055 
2057  vis_st64_2(REF_2, dest, 8);
2058  dest += stride;
2059  } while (--height);
2060 }
2061 
2062 static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,
2063  const int stride, int height)
2064 {
2065  ref = vis_alignaddr(ref);
2066  do { /* 4 cycles */
2067  vis_ld64(ref[0], TMP0);
2068 
2069  vis_ld64(ref[8], TMP2);
2070  ref += stride;
2071 
2072  /* stall */
2073 
2075  vis_st64(REF_0, dest[0]);
2076  dest += stride;
2077  } while (--height);
2078 }
2079 
2080 
2081 static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,
2082  const int stride, int height)
2083 {
2084  int stride_8 = stride + 8;
2085 
2086  ref = vis_alignaddr(ref);
2087 
2088  vis_ld64(ref[0], TMP0);
2089 
2090  vis_ld64(ref[8], TMP2);
2091 
2092  vis_ld64(ref[16], TMP4);
2093 
2094  vis_ld64(dest[0], DST_0);
2095 
2096  vis_ld64(dest[8], DST_2);
2097 
2100 
2103 
2105 
2106  ref += stride;
2107  height = (height >> 1) - 1;
2108 
2109  do { /* 24 cycles */
2110  vis_ld64(ref[0], TMP0);
2111  vis_xor(DST_0, REF_0, TMP6);
2112 
2113  vis_ld64_2(ref, 8, TMP2);
2114  vis_and(TMP6, MASK_fe, TMP6);
2115 
2116  vis_ld64_2(ref, 16, TMP4);
2117  ref += stride;
2119  vis_xor(DST_2, REF_2, TMP8);
2120 
2121  vis_and(TMP8, MASK_fe, TMP8);
2122 
2123  vis_and(DST_0, REF_0, TMP10);
2124  vis_ld64_2(dest, stride, DST_0);
2126 
2127  vis_and(DST_2, REF_2, TMP12);
2128  vis_ld64_2(dest, stride_8, DST_2);
2129 
2130  vis_ld64(ref[0], TMP14);
2131  vis_and(TMP6, MASK_7f, TMP6);
2132 
2133  vis_and(TMP8, MASK_7f, TMP8);
2134 
2136  vis_st64(TMP6, dest[0]);
2137 
2139  vis_st64_2(TMP8, dest, 8);
2140 
2141  dest += stride;
2142  vis_ld64_2(ref, 8, TMP16);
2144 
2145  vis_ld64_2(ref, 16, TMP18);
2147  ref += stride;
2148 
2149  vis_xor(DST_0, REF_0, TMP20);
2150 
2152 
2153  vis_xor(DST_2, REF_2, TMP22);
2155 
2157 
2158  vis_and(DST_0, REF_0, TMP24);
2160 
2161  vis_and(DST_2, REF_2, TMP26);
2162 
2163  vis_ld64_2(dest, stride, DST_0);
2165 
2166  vis_ld64_2(dest, stride_8, DST_2);
2168 
2170 
2172 
2174  vis_st64(TMP20, dest[0]);
2175 
2177  vis_st64_2(TMP22, dest, 8);
2178  dest += stride;
2179  } while (--height);
2180 
2181  vis_ld64(ref[0], TMP0);
2182  vis_xor(DST_0, REF_0, TMP6);
2183 
2184  vis_ld64_2(ref, 8, TMP2);
2185  vis_and(TMP6, MASK_fe, TMP6);
2186 
2187  vis_ld64_2(ref, 16, TMP4);
2189  vis_xor(DST_2, REF_2, TMP8);
2190 
2191  vis_and(TMP8, MASK_fe, TMP8);
2192 
2193  vis_and(DST_0, REF_0, TMP10);
2194  vis_ld64_2(dest, stride, DST_0);
2196 
2197  vis_and(DST_2, REF_2, TMP12);
2198  vis_ld64_2(dest, stride_8, DST_2);
2199 
2200  vis_ld64(ref[0], TMP14);
2201  vis_and(TMP6, MASK_7f, TMP6);
2202 
2203  vis_and(TMP8, MASK_7f, TMP8);
2204 
2206  vis_st64(TMP6, dest[0]);
2207 
2209  vis_st64_2(TMP8, dest, 8);
2210 
2211  dest += stride;
2213 
2215 
2216  vis_xor(DST_0, REF_0, TMP20);
2217 
2219 
2220  vis_xor(DST_2, REF_2, TMP22);
2222 
2224 
2225  vis_and(DST_0, REF_0, TMP24);
2227 
2228  vis_and(DST_2, REF_2, TMP26);
2229 
2231 
2233 
2235  vis_st64(TMP20, dest[0]);
2236 
2238  vis_st64_2(TMP22, dest, 8);
2239 }
2240 
2241 static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,
2242  const int stride, int height)
2243 {
2244  ref = vis_alignaddr(ref);
2245 
2246  vis_ld64(ref[0], TMP0);
2247 
2248  vis_ld64(ref[8], TMP2);
2249 
2250  vis_ld64(dest[0], DST_0);
2251 
2253 
2256 
2258 
2259  ref += stride;
2260  height = (height >> 1) - 1;
2261 
2262  do { /* 12 cycles */
2263  vis_ld64(ref[0], TMP0);
2264  vis_xor(DST_0, REF_0, TMP4);
2265 
2266  vis_ld64(ref[8], TMP2);
2267  vis_and(TMP4, MASK_fe, TMP4);
2268 
2269  vis_and(DST_0, REF_0, TMP6);
2270  vis_ld64_2(dest, stride, DST_0);
2271  ref += stride;
2273 
2274  vis_ld64(ref[0], TMP12);
2276 
2277  vis_ld64(ref[8], TMP2);
2278  vis_xor(DST_0, REF_0, TMP0);
2279  ref += stride;
2280 
2281  vis_and(TMP0, MASK_fe, TMP0);
2282 
2283  vis_and(TMP4, MASK_7f, TMP4);
2284 
2285  vis_padd16(TMP6, TMP4, TMP4);
2286  vis_st64(TMP4, dest[0]);
2287  dest += stride;
2289 
2290  vis_and(DST_0, REF_0, TMP6);
2291  vis_ld64_2(dest, stride, DST_0);
2292 
2294 
2295  vis_and(TMP0, MASK_7f, TMP0);
2296 
2297  vis_padd16(TMP6, TMP0, TMP4);
2298  vis_st64(TMP4, dest[0]);
2299  dest += stride;
2300  } while (--height);
2301 
2302  vis_ld64(ref[0], TMP0);
2303  vis_xor(DST_0, REF_0, TMP4);
2304 
2305  vis_ld64(ref[8], TMP2);
2306  vis_and(TMP4, MASK_fe, TMP4);
2307 
2308  vis_and(DST_0, REF_0, TMP6);
2309  vis_ld64_2(dest, stride, DST_0);
2311 
2313 
2314  vis_xor(DST_0, REF_0, TMP0);
2315 
2316  vis_and(TMP0, MASK_fe, TMP0);
2317 
2318  vis_and(TMP4, MASK_7f, TMP4);
2319 
2320  vis_padd16(TMP6, TMP4, TMP4);
2321  vis_st64(TMP4, dest[0]);
2322  dest += stride;
2324 
2325  vis_and(DST_0, REF_0, TMP6);
2326 
2327  vis_and(TMP0, MASK_7f, TMP0);
2328 
2329  vis_padd16(TMP6, TMP0, TMP4);
2330  vis_st64(TMP4, dest[0]);
2331 }
2332 
2333 static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,
2334  const int stride, int height)
2335 {
2336  unsigned long off = (unsigned long) ref & 0x7;
2337  unsigned long off_plus_1 = off + 1;
2338 
2339  ref = vis_alignaddr(ref);
2340 
2341  vis_ld64(ref[0], TMP0);
2342 
2343  vis_ld64_2(ref, 8, TMP2);
2344 
2345  vis_ld64_2(ref, 16, TMP4);
2346 
2348 
2351 
2354 
2355  if (off != 0x7) {
2356  vis_alignaddr_g0((void *)off_plus_1);
2359  } else {
2360  vis_src1(TMP2, REF_2);
2361  vis_src1(TMP4, REF_6);
2362  }
2363 
2364  ref += stride;
2365  height = (height >> 1) - 1;
2366 
2367  do { /* 34 cycles */
2368  vis_ld64(ref[0], TMP0);
2369  vis_xor(REF_0, REF_2, TMP6);
2370 
2371  vis_ld64_2(ref, 8, TMP2);
2372  vis_xor(REF_4, REF_6, TMP8);
2373 
2374  vis_ld64_2(ref, 16, TMP4);
2375  vis_and(TMP6, MASK_fe, TMP6);
2376  ref += stride;
2377 
2378  vis_ld64(ref[0], TMP14);
2380  vis_and(TMP8, MASK_fe, TMP8);
2381 
2382  vis_ld64_2(ref, 8, TMP16);
2384  vis_and(REF_0, REF_2, TMP10);
2385 
2386  vis_ld64_2(ref, 16, TMP18);
2387  ref += stride;
2388  vis_and(REF_4, REF_6, TMP12);
2389 
2390  vis_alignaddr_g0((void *)off);
2391 
2393 
2395 
2396  if (off != 0x7) {
2397  vis_alignaddr_g0((void *)off_plus_1);
2400  } else {
2401  vis_src1(TMP2, REF_2);
2402  vis_src1(TMP4, REF_6);
2403  }
2404 
2405  vis_and(TMP6, MASK_7f, TMP6);
2406 
2407  vis_and(TMP8, MASK_7f, TMP8);
2408 
2410  vis_st64(TMP6, dest[0]);
2411 
2413  vis_st64_2(TMP8, dest, 8);
2414  dest += stride;
2415 
2416  vis_xor(REF_0, REF_2, TMP6);
2417 
2418  vis_xor(REF_4, REF_6, TMP8);
2419 
2420  vis_and(TMP6, MASK_fe, TMP6);
2421 
2423  vis_and(TMP8, MASK_fe, TMP8);
2424 
2426  vis_and(REF_0, REF_2, TMP10);
2427 
2428  vis_and(REF_4, REF_6, TMP12);
2429 
2430  vis_alignaddr_g0((void *)off);
2431 
2433 
2435 
2436  if (off != 0x7) {
2437  vis_alignaddr_g0((void *)off_plus_1);
2440  } else {
2441  vis_src1(TMP16, REF_2);
2442  vis_src1(TMP18, REF_6);
2443  }
2444 
2445  vis_and(TMP6, MASK_7f, TMP6);
2446 
2447  vis_and(TMP8, MASK_7f, TMP8);
2448 
2450  vis_st64(TMP6, dest[0]);
2451 
2453  vis_st64_2(TMP8, dest, 8);
2454  dest += stride;
2455  } while (--height);
2456 
2457  vis_ld64(ref[0], TMP0);
2458  vis_xor(REF_0, REF_2, TMP6);
2459 
2460  vis_ld64_2(ref, 8, TMP2);
2461  vis_xor(REF_4, REF_6, TMP8);
2462 
2463  vis_ld64_2(ref, 16, TMP4);
2464  vis_and(TMP6, MASK_fe, TMP6);
2465 
2467  vis_and(TMP8, MASK_fe, TMP8);
2468 
2470  vis_and(REF_0, REF_2, TMP10);
2471 
2472  vis_and(REF_4, REF_6, TMP12);
2473 
2474  vis_alignaddr_g0((void *)off);
2475 
2477 
2479 
2480  if (off != 0x7) {
2481  vis_alignaddr_g0((void *)off_plus_1);
2484  } else {
2485  vis_src1(TMP2, REF_2);
2486  vis_src1(TMP4, REF_6);
2487  }
2488 
2489  vis_and(TMP6, MASK_7f, TMP6);
2490 
2491  vis_and(TMP8, MASK_7f, TMP8);
2492 
2494  vis_st64(TMP6, dest[0]);
2495 
2497  vis_st64_2(TMP8, dest, 8);
2498  dest += stride;
2499 
2500  vis_xor(REF_0, REF_2, TMP6);
2501 
2502  vis_xor(REF_4, REF_6, TMP8);
2503 
2504  vis_and(TMP6, MASK_fe, TMP6);
2505 
2507  vis_and(TMP8, MASK_fe, TMP8);
2508 
2510  vis_and(REF_0, REF_2, TMP10);
2511 
2512  vis_and(REF_4, REF_6, TMP12);
2513 
2514  vis_and(TMP6, MASK_7f, TMP6);
2515 
2516  vis_and(TMP8, MASK_7f, TMP8);
2517 
2519  vis_st64(TMP6, dest[0]);
2520 
2522  vis_st64_2(TMP8, dest, 8);
2523 }
2524 
2525 static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,
2526  const int stride, int height)
2527 {
2528  unsigned long off = (unsigned long) ref & 0x7;
2529  unsigned long off_plus_1 = off + 1;
2530 
2531  ref = vis_alignaddr(ref);
2532 
2533  vis_ld64(ref[0], TMP0);
2534 
2535  vis_ld64(ref[8], TMP2);
2536 
2538 
2540 
2543 
2544  if (off != 0x7) {
2545  vis_alignaddr_g0((void *)off_plus_1);
2547  } else {
2548  vis_src1(TMP2, REF_2);
2549  }
2550 
2551  ref += stride;
2552  height = (height >> 1) - 1;
2553 
2554  do { /* 20 cycles */
2555  vis_ld64(ref[0], TMP0);
2556  vis_xor(REF_0, REF_2, TMP4);
2557 
2558  vis_ld64_2(ref, 8, TMP2);
2559  vis_and(TMP4, MASK_fe, TMP4);
2560  ref += stride;
2561 
2562  vis_ld64(ref[0], TMP8);
2563  vis_and(REF_0, REF_2, TMP6);
2565 
2566  vis_alignaddr_g0((void *)off);
2567 
2568  vis_ld64_2(ref, 8, TMP10);
2569  ref += stride;
2571 
2572  if (off != 0x7) {
2573  vis_alignaddr_g0((void *)off_plus_1);
2575  } else {
2576  vis_src1(TMP2, REF_2);
2577  }
2578 
2579  vis_and(TMP4, MASK_7f, TMP4);
2580 
2582  vis_st64(DST_0, dest[0]);
2583  dest += stride;
2584 
2585  vis_xor(REF_0, REF_2, TMP12);
2586 
2588 
2589  vis_and(REF_0, REF_2, TMP14);
2591 
2592  vis_alignaddr_g0((void *)off);
2594  if (off != 0x7) {
2595  vis_alignaddr_g0((void *)off_plus_1);
2597  } else {
2598  vis_src1(TMP10, REF_2);
2599  }
2600 
2602 
2604  vis_st64(DST_0, dest[0]);
2605  dest += stride;
2606  } while (--height);
2607 
2608  vis_ld64(ref[0], TMP0);
2609  vis_xor(REF_0, REF_2, TMP4);
2610 
2611  vis_ld64_2(ref, 8, TMP2);
2612  vis_and(TMP4, MASK_fe, TMP4);
2613 
2614  vis_and(REF_0, REF_2, TMP6);
2616 
2617  vis_alignaddr_g0((void *)off);
2618 
2620 
2621  if (off != 0x7) {
2622  vis_alignaddr_g0((void *)off_plus_1);
2624  } else {
2625  vis_src1(TMP2, REF_2);
2626  }
2627 
2628  vis_and(TMP4, MASK_7f, TMP4);
2629 
2631  vis_st64(DST_0, dest[0]);
2632  dest += stride;
2633 
2634  vis_xor(REF_0, REF_2, TMP12);
2635 
2637 
2638  vis_and(REF_0, REF_2, TMP14);
2640 
2642 
2644  vis_st64(DST_0, dest[0]);
2645  dest += stride;
2646 }
2647 
2648 static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,
2649  const int stride, int height)
2650 {
2651  unsigned long off = (unsigned long) ref & 0x7;
2652  unsigned long off_plus_1 = off + 1;
2653 
2655 
2657  vis_fzero(ZERO);
2659 
2660  ref = vis_alignaddr(ref);
2661  do { /* 26 cycles */
2662  vis_ld64(ref[0], TMP0);
2663 
2664  vis_ld64(ref[8], TMP2);
2665 
2666  vis_alignaddr_g0((void *)off);
2667 
2668  vis_ld64(ref[16], TMP4);
2669 
2670  vis_ld64(dest[0], DST_0);
2672 
2673  vis_ld64(dest[8], DST_2);
2675 
2676  if (off != 0x7) {
2677  vis_alignaddr_g0((void *)off_plus_1);
2680  } else {
2681  vis_src1(TMP2, REF_2);
2682  vis_src1(TMP4, REF_6);
2683  }
2684 
2686 
2689 
2691 
2692  vis_padd16(TMP0, TMP4, TMP0);
2693 
2695  vis_padd16(TMP2, TMP6, TMP2);
2696 
2698 
2700 
2701  vis_padd16(TMP0, TMP4, TMP0);
2703 
2704  vis_padd16(TMP2, TMP6, TMP2);
2706 
2709 
2711  vis_pack16(TMP8, DST_0);
2712 
2715 
2716  vis_st64(DST_0, dest[0]);
2719 
2722 
2724 
2725  vis_padd16(TMP0, TMP4, TMP0);
2726 
2727  vis_padd16(TMP2, TMP6, TMP2);
2728  vis_pack16(TMP0, DST_2);
2729 
2730  vis_pack16(TMP2, DST_3);
2731  vis_st64(DST_2, dest[8]);
2732 
2733  ref += stride;
2734  dest += stride;
2735  } while (--height);
2736 }
2737 
2738 static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,
2739  const int stride, int height)
2740 {
2741  unsigned long off = (unsigned long) ref & 0x7;
2742  unsigned long off_plus_1 = off + 1;
2743  int stride_times_2 = stride << 1;
2744 
2746 
2748  vis_fzero(ZERO);
2750 
2751  ref = vis_alignaddr(ref);
2752  height >>= 2;
2753  do { /* 47 cycles */
2754  vis_ld64(ref[0], TMP0);
2755 
2756  vis_ld64_2(ref, 8, TMP2);
2757  ref += stride;
2758 
2759  vis_alignaddr_g0((void *)off);
2760 
2761  vis_ld64(ref[0], TMP4);
2763 
2764  vis_ld64_2(ref, 8, TMP6);
2765  ref += stride;
2766 
2767  vis_ld64(ref[0], TMP8);
2768 
2769  vis_ld64_2(ref, 8, TMP10);
2770  ref += stride;
2772 
2773  vis_ld64(ref[0], TMP12);
2774 
2775  vis_ld64_2(ref, 8, TMP14);
2776  ref += stride;
2778 
2780 
2781  if (off != 0x7) {
2782  vis_alignaddr_g0((void *)off_plus_1);
2783 
2784  vis_ld64(dest[0], DST_0);
2786 
2787  vis_ld64_2(dest, stride, DST_2);
2789 
2791 
2793  } else {
2794  vis_ld64(dest[0], DST_0);
2795  vis_src1(TMP2, REF_2);
2796 
2797  vis_ld64_2(dest, stride, DST_2);
2798  vis_src1(TMP6, REF_6);
2799 
2800  vis_src1(TMP10, REF_S2);
2801 
2802  vis_src1(TMP14, REF_S6);
2803  }
2804 
2807 
2810 
2813 
2816 
2817  vis_padd16(TMP0, TMP4, TMP0);
2819 
2820  vis_padd16(TMP2, TMP6, TMP2);
2822 
2825 
2828 
2831 
2834 
2836  vis_pack16(TMP0, DST_0);
2837 
2838  vis_pack16(TMP2, DST_1);
2839  vis_st64(DST_0, dest[0]);
2840  dest += stride;
2842 
2843  vis_ld64_2(dest, stride, DST_0);
2845 
2846  vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
2848  vis_pack16(TMP8, DST_2);
2849 
2851  vis_st64(DST_2, dest[0]);
2852  dest += stride;
2853 
2856 
2859 
2862 
2865 
2868 
2869  vis_padd16(TMP2, TMP6, TMP2);
2871 
2874 
2877 
2879  vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
2880 
2881  vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
2883 
2885  vis_pack16(TMP0, DST_0);
2886 
2888  vis_pack16(TMP2, DST_1);
2889  vis_st64(DST_0, dest[0]);
2890  dest += stride;
2891 
2893 
2895  vis_pack16(TMP8, DST_2);
2896 
2898  vis_st64(DST_2, dest[0]);
2899  dest += stride;
2900  } while (--height);
2901 }
2902 
2903 static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref,
2904  const int stride, int height)
2905 {
2906  ref = vis_alignaddr(ref);
2907  vis_ld64(ref[0], TMP0);
2908 
2909  vis_ld64_2(ref, 8, TMP2);
2910 
2911  vis_ld64_2(ref, 16, TMP4);
2912  ref += stride;
2913 
2914  vis_ld64(ref[0], TMP6);
2916 
2917  vis_ld64_2(ref, 8, TMP8);
2919 
2920  vis_ld64_2(ref, 16, TMP10);
2921  ref += stride;
2922 
2925 
2928 
2930  height = (height >> 1) - 1;
2931  do { /* 24 cycles */
2932  vis_ld64(ref[0], TMP0);
2933  vis_xor(REF_0, REF_2, TMP12);
2934 
2935  vis_ld64_2(ref, 8, TMP2);
2936  vis_xor(REF_4, REF_6, TMP16);
2937 
2938  vis_ld64_2(ref, 16, TMP4);
2939  ref += stride;
2940  vis_and(REF_0, REF_2, TMP14);
2941 
2942  vis_ld64(ref[0], TMP6);
2943  vis_and(REF_4, REF_6, TMP18);
2944 
2945  vis_ld64_2(ref, 8, TMP8);
2947 
2948  vis_ld64_2(ref, 16, TMP10);
2949  ref += stride;
2951 
2953 
2956 
2958  vis_xor(REF_0, REF_2, TMP0);
2959 
2960  vis_xor(REF_4, REF_6, TMP2);
2961 
2962  vis_and(REF_0, REF_2, TMP20);
2963 
2965 
2967 
2969  vis_st64(TMP12, dest[0]);
2970 
2972  vis_st64_2(TMP16, dest, 8);
2973  dest += stride;
2974 
2975  vis_and(REF_4, REF_6, TMP18);
2976 
2977  vis_and(TMP0, MASK_fe, TMP0);
2978 
2979  vis_and(TMP2, MASK_fe, TMP2);
2981 
2984 
2986 
2987  vis_and(TMP0, MASK_7f, TMP0);
2988 
2989  vis_and(TMP2, MASK_7f, TMP2);
2990 
2992  vis_st64(TMP0, dest[0]);
2993 
2995  vis_st64_2(TMP2, dest, 8);
2996  dest += stride;
2997  } while (--height);
2998 
2999  vis_ld64(ref[0], TMP0);
3000  vis_xor(REF_0, REF_2, TMP12);
3001 
3002  vis_ld64_2(ref, 8, TMP2);
3003  vis_xor(REF_4, REF_6, TMP16);
3004 
3005  vis_ld64_2(ref, 16, TMP4);
3006  vis_and(REF_0, REF_2, TMP14);
3007 
3008  vis_and(REF_4, REF_6, TMP18);
3009 
3011 
3013 
3015 
3018 
3020  vis_xor(REF_0, REF_2, TMP0);
3021 
3022  vis_xor(REF_4, REF_6, TMP2);
3023 
3024  vis_and(REF_0, REF_2, TMP20);
3025 
3027 
3029 
3031  vis_st64(TMP12, dest[0]);
3032 
3034  vis_st64_2(TMP16, dest, 8);
3035  dest += stride;
3036 
3037  vis_and(REF_4, REF_6, TMP18);
3038 
3039  vis_and(TMP0, MASK_fe, TMP0);
3040 
3041  vis_and(TMP2, MASK_fe, TMP2);
3043 
3045 
3046  vis_and(TMP0, MASK_7f, TMP0);
3047 
3048  vis_and(TMP2, MASK_7f, TMP2);
3049 
3051  vis_st64(TMP0, dest[0]);
3052 
3054  vis_st64_2(TMP2, dest, 8);
3055 }
3056 
3057 static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref,
3058  const int stride, int height)
3059 {
3060  ref = vis_alignaddr(ref);
3061  vis_ld64(ref[0], TMP0);
3062 
3063  vis_ld64_2(ref, 8, TMP2);
3064  ref += stride;
3065 
3066  vis_ld64(ref[0], TMP4);
3067 
3068  vis_ld64_2(ref, 8, TMP6);
3069  ref += stride;
3070 
3073 
3076 
3078  height = (height >> 1) - 1;
3079  do { /* 12 cycles */
3080  vis_ld64(ref[0], TMP0);
3081  vis_xor(REF_0, REF_2, TMP4);
3082 
3083  vis_ld64_2(ref, 8, TMP2);
3084  ref += stride;
3085  vis_and(TMP4, MASK_fe, TMP4);
3086 
3087  vis_and(REF_0, REF_2, TMP6);
3089 
3091  vis_ld64(ref[0], TMP0);
3092 
3093  vis_ld64_2(ref, 8, TMP2);
3094  ref += stride;
3095  vis_xor(REF_0, REF_2, TMP12);
3096 
3097  vis_and(TMP4, MASK_7f, TMP4);
3098 
3100 
3102  vis_and(REF_0, REF_2, TMP14);
3103 
3105  vis_st64(DST_0, dest[0]);
3106  dest += stride;
3107 
3109 
3111 
3113  vis_st64(DST_0, dest[0]);
3114  dest += stride;
3115  } while (--height);
3116 
3117  vis_ld64(ref[0], TMP0);
3118  vis_xor(REF_0, REF_2, TMP4);
3119 
3120  vis_ld64_2(ref, 8, TMP2);
3121  vis_and(TMP4, MASK_fe, TMP4);
3122 
3123  vis_and(REF_0, REF_2, TMP6);
3125 
3127 
3128  vis_xor(REF_0, REF_2, TMP12);
3129 
3130  vis_and(TMP4, MASK_7f, TMP4);
3131 
3133 
3135  vis_and(REF_0, REF_2, TMP14);
3136 
3138  vis_st64(DST_0, dest[0]);
3139  dest += stride;
3140 
3142 
3144  vis_st64(DST_0, dest[0]);
3145 }
3146 
3147 static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref,
3148  const int stride, int height)
3149 {
3150  int stride_8 = stride + 8;
3151  int stride_16 = stride + 16;
3152 
3154 
3155  ref = vis_alignaddr(ref);
3156 
3157  vis_ld64(ref[ 0], TMP0);
3158  vis_fzero(ZERO);
3159 
3160  vis_ld64(ref[ 8], TMP2);
3161 
3162  vis_ld64(ref[16], TMP4);
3163 
3166 
3169  height >>= 1;
3170 
3171  do { /* 31 cycles */
3172  vis_ld64_2(ref, stride, TMP0);
3175 
3176  vis_ld64_2(ref, stride_8, TMP2);
3179 
3180  vis_ld64_2(ref, stride_16, TMP4);
3181  ref += stride;
3182 
3183  vis_ld64(dest[0], DST_0);
3185 
3186  vis_ld64_2(dest, 8, DST_2);
3188 
3189  vis_ld64_2(ref, stride, TMP6);
3192 
3193  vis_ld64_2(ref, stride_8, TMP8);
3195 
3196  vis_ld64_2(ref, stride_16, TMP10);
3197  ref += stride;
3198 
3199  vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
3202 
3203  vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
3206 
3209 
3212 
3215 
3217 
3220 
3223 
3226 
3229 
3232 
3235 
3238 
3241 
3244 
3246  vis_st64(DST_0, dest[0]);
3248 
3251 
3253  vis_st64_2(DST_2, dest, 8);
3254  dest += stride;
3256 
3258 
3261 
3264  vis_st64(DST_0, dest[0]);
3265 
3268 
3270  vis_st64_2(DST_2, dest, 8);
3271  dest += stride;
3272  } while (--height);
3273 }
3274 
3275 static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref,
3276  const int stride, int height)
3277 {
3278  int stride_8 = stride + 8;
3279 
3281 
3282  ref = vis_alignaddr(ref);
3283 
3284  vis_ld64(ref[ 0], TMP0);
3285  vis_fzero(ZERO);
3286 
3287  vis_ld64(ref[ 8], TMP2);
3288 
3291 
3293 
3294  height >>= 1;
3295  do { /* 20 cycles */
3296  vis_ld64_2(ref, stride, TMP0);
3299 
3300  vis_ld64_2(ref, stride_8, TMP2);
3301  ref += stride;
3302 
3303  vis_ld64(dest[0], DST_0);
3304 
3305  vis_ld64_2(dest, stride, DST_2);
3307 
3308  vis_ld64_2(ref, stride, TMP4);
3311 
3312  vis_ld64_2(ref, stride_8, TMP6);
3313  ref += stride;
3316 
3319 
3322 
3324 
3326 
3329 
3332 
3334  vis_pack16(TMP0, DST_0);
3335 
3336  vis_pack16(TMP2, DST_1);
3337  vis_st64(DST_0, dest[0]);
3338  dest += stride;
3340 
3342 
3344 
3346  vis_pack16(TMP0, DST_2);
3347 
3348  vis_pack16(TMP2, DST_3);
3349  vis_st64(DST_2, dest[0]);
3350  dest += stride;
3351  } while (--height);
3352 }
3353 
3354 static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref,
3355  const int stride, int height)
3356 {
3357  unsigned long off = (unsigned long) ref & 0x7;
3358  unsigned long off_plus_1 = off + 1;
3359  int stride_8 = stride + 8;
3360  int stride_16 = stride + 16;
3361 
3363 
3364  ref = vis_alignaddr(ref);
3365 
3366  vis_ld64(ref[ 0], TMP0);
3367  vis_fzero(ZERO);
3368 
3369  vis_ld64(ref[ 8], TMP2);
3370 
3371  vis_ld64(ref[16], TMP4);
3372 
3375 
3378 
3379  if (off != 0x7) {
3380  vis_alignaddr_g0((void *)off_plus_1);
3383  } else {
3384  vis_src1(TMP2, REF_S2);
3385  vis_src1(TMP4, REF_S6);
3386  }
3387 
3388  height >>= 1;
3389  do {
3390  vis_ld64_2(ref, stride, TMP0);
3393 
3394  vis_alignaddr_g0((void *)off);
3395 
3396  vis_ld64_2(ref, stride_8, TMP2);
3399 
3400  vis_ld64_2(ref, stride_16, TMP4);
3401  ref += stride;
3404 
3405  vis_ld64_2(ref, stride, TMP6);
3408 
3409  vis_ld64_2(ref, stride_8, TMP8);
3411 
3412  vis_ld64_2(ref, stride_16, TMP10);
3413  ref += stride;
3415 
3417 
3419 
3420  if (off != 0x7) {
3421  vis_alignaddr_g0((void *)off_plus_1);
3426  } else {
3427  vis_src1(TMP2, REF_2);
3428  vis_src1(TMP4, REF_6);
3429  vis_src1(TMP8, REF_S2);
3430  vis_src1(TMP10, REF_S6);
3431  }
3432 
3435 
3438 
3441 
3444 
3445  vis_padd16(TMP8, TMP4, TMP8);
3447 
3450 
3452 
3454 
3456 
3459 
3461  vis_st64(DST_0, dest[0]);
3463 
3466 
3469 
3472 
3475 
3477 
3479 
3482 
3484  vis_st64_2(DST_2, dest, 8);
3485  dest += stride;
3487 
3490 
3493 
3496 
3498  vis_st64(DST_0, dest[0]);
3500 
3502 
3503  vis_padd16(TMP0, TMP4, TMP0);
3504 
3505  vis_padd16(TMP2, TMP6, TMP2);
3506 
3508 
3510  vis_pack16(TMP0, DST_2);
3511 
3512  vis_pack16(TMP2, DST_3);
3513  vis_st64_2(DST_2, dest, 8);
3514  dest += stride;
3515  } while (--height);
3516 }
3517 
3518 static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref,
3519  const int stride, int height)
3520 {
3521  unsigned long off = (unsigned long) ref & 0x7;
3522  unsigned long off_plus_1 = off + 1;
3523  int stride_8 = stride + 8;
3524 
3526 
3527  ref = vis_alignaddr(ref);
3528 
3529  vis_ld64(ref[ 0], TMP0);
3530  vis_fzero(ZERO);
3531 
3532  vis_ld64(ref[ 8], TMP2);
3533 
3535 
3538 
3539  if (off != 0x7) {
3540  vis_alignaddr_g0((void *)off_plus_1);
3542  } else {
3543  vis_src1(TMP2, REF_S2);
3544  }
3545 
3546  height >>= 1;
3547  do { /* 26 cycles */
3548  vis_ld64_2(ref, stride, TMP0);
3551 
3552  vis_alignaddr_g0((void *)off);
3553 
3554  vis_ld64_2(ref, stride_8, TMP2);
3555  ref += stride;
3558 
3559  vis_ld64_2(ref, stride, TMP4);
3560 
3561  vis_ld64_2(ref, stride_8, TMP6);
3562  ref += stride;
3564 
3566 
3568 
3570 
3571  if (off != 0x7) {
3572  vis_alignaddr_g0((void *)off_plus_1);
3575  } else {
3576  vis_src1(TMP2, REF_S6);
3577  vis_src1(TMP6, REF_S2);
3578  }
3579 
3582 
3585 
3588 
3591 
3594 
3596 
3598 
3600 
3602  vis_pack16(TMP8, DST_0);
3603 
3605  vis_st64(DST_0, dest[0]);
3606  dest += stride;
3608 
3610 
3612 
3615 
3617  vis_st64(DST_2, dest[0]);
3618  dest += stride;
3619  } while (--height);
3620 }
3621 
3622 static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref,
3623  const int stride, int height)
3624 {
3625  unsigned long off = (unsigned long) ref & 0x7;
3626  unsigned long off_plus_1 = off + 1;
3627  int stride_8 = stride + 8;
3628  int stride_16 = stride + 16;
3629 
3631 
3632  ref = vis_alignaddr(ref);
3633 
3634  vis_ld64(ref[ 0], TMP0);
3635  vis_fzero(ZERO);
3636 
3637  vis_ld64(ref[ 8], TMP2);
3638 
3639  vis_ld64(ref[16], TMP4);
3640 
3643 
3646 
3647  if (off != 0x7) {
3648  vis_alignaddr_g0((void *)off_plus_1);
3651  } else {
3652  vis_src1(TMP2, REF_S2);
3653  vis_src1(TMP4, REF_S6);
3654  }
3655 
3656  height >>= 1;
3657  do { /* 55 cycles */
3658  vis_ld64_2(ref, stride, TMP0);
3661 
3662  vis_alignaddr_g0((void *)off);
3663 
3664  vis_ld64_2(ref, stride_8, TMP2);
3667 
3668  vis_ld64_2(ref, stride_16, TMP4);
3669  ref += stride;
3672 
3673  vis_ld64_2(ref, stride, TMP6);
3676 
3677  vis_ld64_2(ref, stride_8, TMP8);
3679 
3680  vis_ld64_2(ref, stride_16, TMP10);
3681  ref += stride;
3683 
3684  vis_ld64(dest[0], DST_0);
3686 
3687  vis_ld64_2(dest, 8, DST_2);
3689 
3690  if (off != 0x7) {
3691  vis_alignaddr_g0((void *)off_plus_1);
3696  } else {
3697  vis_src1(TMP2, REF_2);
3698  vis_src1(TMP4, REF_6);
3699  vis_src1(TMP8, REF_S2);
3700  vis_src1(TMP10, REF_S6);
3701  }
3702 
3705 
3708 
3711 
3714 
3717 
3718  vis_padd16(TMP0, TMP4, TMP0);
3720 
3721  vis_padd16(TMP2, TMP6, TMP2);
3723 
3726 
3729 
3732 
3735 
3737 
3740 
3742  vis_st64(DST_0, dest[0]);
3744 
3745  vis_ld64_2(dest, stride, DST_0);
3748 
3749  vis_padd16(TMP4, TMP8, TMP4);
3751 
3753 
3755 
3757 
3759 
3761 
3764 
3767 
3769  vis_st64_2(DST_2, dest, 8);
3770  dest += stride;
3771 
3772  vis_ld64_2(dest, 8, DST_2);
3775 
3778 
3781 
3784 
3786 
3788 
3790  vis_pack16(TMP8, DST_0);
3791 
3793  vis_st64(DST_0, dest[0]);
3794 
3796 
3799 
3802 
3804 
3806 
3807  /* stall */
3808 
3811 
3813  vis_st64_2(DST_2, dest, 8);
3814  dest += stride;
3815  } while (--height);
3816 }
3817 
3818 static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref,
3819  const int stride, int height)
3820 {
3821  unsigned long off = (unsigned long) ref & 0x7;
3822  unsigned long off_plus_1 = off + 1;
3823  int stride_8 = stride + 8;
3824 
3826 
3827  ref = vis_alignaddr(ref);
3828 
3829  vis_ld64(ref[0], TMP0);
3830  vis_fzero(ZERO);
3831 
3832  vis_ld64_2(ref, 8, TMP2);
3833 
3835 
3838 
3839  if (off != 0x7) {
3840  vis_alignaddr_g0((void *)off_plus_1);
3842  } else {
3843  vis_src1(TMP2, REF_S2);
3844  }
3845 
3846  height >>= 1;
3847  do { /* 31 cycles */
3848  vis_ld64_2(ref, stride, TMP0);
3851 
3852  vis_ld64_2(ref, stride_8, TMP2);
3853  ref += stride;
3856 
3857  vis_alignaddr_g0((void *)off);
3858 
3859  vis_ld64_2(ref, stride, TMP4);
3861 
3862  vis_ld64_2(ref, stride_8, TMP6);
3863  ref += stride;
3864 
3865  vis_ld64(dest[0], DST_0);
3867 
3868  vis_ld64_2(dest, stride, DST_2);
3869 
3870  if (off != 0x7) {
3871  vis_alignaddr_g0((void *)off_plus_1);
3874  } else {
3875  vis_src1(TMP2, REF_S6);
3876  vis_src1(TMP6, REF_S2);
3877  }
3878 
3881 
3884 
3887 
3890 
3893 
3896 
3899 
3902 
3905 
3907 
3909 
3911 
3913  vis_pack16(TMP8, DST_0);
3914 
3916  vis_st64(DST_0, dest[0]);
3917  dest += stride;
3918 
3920 
3922 
3924 
3926 
3928 
3931 
3933  vis_st64(DST_2, dest[0]);
3934  dest += stride;
3935  } while (--height);
3936 }
3937 
3938 /* End of no rounding code */
3939 
3940 #define ACCEL_SPARC_VIS 1
3941 #define ACCEL_SPARC_VIS2 2
3942 
3943 static int vis_level(void)
3944 {
3945  int accel = 0;
3946  accel |= ACCEL_SPARC_VIS;
3947  accel |= ACCEL_SPARC_VIS2;
3948  return accel;
3949 }
3950 
3951 /* libavcodec initialization code */
3953 {
3954  /* VIS-specific optimizations */
3955  int accel = vis_level ();
3956  const int high_bit_depth = avctx->bits_per_raw_sample > 8;
3957 
3958  if (accel & ACCEL_SPARC_VIS) {
3959  if (avctx->bits_per_raw_sample <= 8 &&
3960  avctx->idct_algo == FF_IDCT_SIMPLEVIS) {
3963  c->idct = ff_simple_idct_vis;
3965  }
3966 
3967  if (!high_bit_depth) {
3968  c->put_pixels_tab[0][0] = MC_put_o_16_vis;
3969  c->put_pixels_tab[0][1] = MC_put_x_16_vis;
3970  c->put_pixels_tab[0][2] = MC_put_y_16_vis;
3971  c->put_pixels_tab[0][3] = MC_put_xy_16_vis;
3972 
3973  c->put_pixels_tab[1][0] = MC_put_o_8_vis;
3974  c->put_pixels_tab[1][1] = MC_put_x_8_vis;
3975  c->put_pixels_tab[1][2] = MC_put_y_8_vis;
3976  c->put_pixels_tab[1][3] = MC_put_xy_8_vis;
3977 
3978  c->avg_pixels_tab[0][0] = MC_avg_o_16_vis;
3979  c->avg_pixels_tab[0][1] = MC_avg_x_16_vis;
3980  c->avg_pixels_tab[0][2] = MC_avg_y_16_vis;
3981  c->avg_pixels_tab[0][3] = MC_avg_xy_16_vis;
3982 
3983  c->avg_pixels_tab[1][0] = MC_avg_o_8_vis;
3984  c->avg_pixels_tab[1][1] = MC_avg_x_8_vis;
3985  c->avg_pixels_tab[1][2] = MC_avg_y_8_vis;
3986  c->avg_pixels_tab[1][3] = MC_avg_xy_8_vis;
3987 
3992 
3997 
4002 
4007  }
4008  }
4009 }