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