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