Statistics
| Branch: | Revision:

ffmpeg / libavcodec / sparc / dsputil_vis.c @ 0f12310f

History | View | Annotate | Download (89.8 KB)

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