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