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