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