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