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