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