Statistics
| Branch: | Revision:

ffmpeg / libavcodec / sparc / dsputil_vis.c @ be449fca

History | View | Annotate | Download (119 KB)

1
/*
2
 * dsputil_vis.c
3
 * Copyright (C) 2003 David S. Miller <davem@redhat.com>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* The *no_round* functions have been added by James A. Morrison, 2003,2004.
23
   The vis code from libmpeg2 was adapted for ffmpeg by James A. Morrison.
24
 */
25

    
26
#include "config.h"
27

    
28
#include <inttypes.h>
29

    
30
#include "libavcodec/dsputil.h"
31

    
32
#include "vis.h"
33

    
34
extern void ff_simple_idct_put_vis(uint8_t *dest, int line_size, DCTELEM *data);
35
extern void ff_simple_idct_add_vis(uint8_t *dest, int line_size, DCTELEM *data);
36
extern void ff_simple_idct_vis(DCTELEM *data);
37

    
38
/* The trick used in some of this file is the formula from the MMX
39
 * motion comp code, which is:
40
 *
41
 * (x+y+1)>>1 == (x|y)-((x^y)>>1)
42
 *
43
 * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
44
 * We avoid overflows by masking before we do the shift, and we
45
 * implement the shift by multiplying by 1/2 using mul8x16.  So in
46
 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
47
 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
48
 * the value 0x80808080 is in f8):
49
 *
50
 *      fxor            f0,   f2, f10
51
 *      fand            f10,  f4, f10
52
 *      fmul8x16        f8,  f10, f10
53
 *      fand            f10,  f6, f10
54
 *      for             f0,   f2, f12
55
 *      fpsub16         f12, f10, f10
56
 */
57

    
58
#define ATTR_ALIGN(alignd) __attribute__ ((aligned(alignd)))
59

    
60
#define DUP4(x) {x, x, x, x}
61
#define DUP8(x) {x, x, x, x, x, x, x, x}
62
static const int16_t constants1[] ATTR_ALIGN(8) = DUP4 (1);
63
static const int16_t constants2[] ATTR_ALIGN(8) = DUP4 (2);
64
static const int16_t constants3[] ATTR_ALIGN(8) = DUP4 (3);
65
static const int16_t constants6[] ATTR_ALIGN(8) = DUP4 (6);
66
static const int8_t constants_fe[] ATTR_ALIGN(8) = DUP8 (0xfe);
67
static const int8_t constants_7f[] ATTR_ALIGN(8) = DUP8 (0x7f);
68
static const int8_t constants128[] ATTR_ALIGN(8) = DUP8 (128);
69
static const int16_t constants256_512[] ATTR_ALIGN(8) =
70
        {256, 512, 256, 512};
71
static const int16_t constants256_1024[] ATTR_ALIGN(8) =
72
        {256, 1024, 256, 1024};
73

    
74
#define REF_0           0
75
#define REF_0_1         1
76
#define REF_2           2
77
#define REF_2_1         3
78
#define REF_4           4
79
#define REF_4_1         5
80
#define REF_6           6
81
#define REF_6_1         7
82
#define REF_S0          8
83
#define REF_S0_1        9
84
#define REF_S2          10
85
#define REF_S2_1        11
86
#define REF_S4          12
87
#define REF_S4_1        13
88
#define REF_S6          14
89
#define REF_S6_1        15
90
#define DST_0           16
91
#define DST_1           17
92
#define DST_2           18
93
#define DST_3           19
94
#define CONST_1         20
95
#define CONST_2         20
96
#define CONST_3         20
97
#define CONST_6         20
98
#define MASK_fe         20
99
#define CONST_128       22
100
#define CONST_256       22
101
#define CONST_512       22
102
#define CONST_1024      22
103
#define TMP0            24
104
#define TMP1            25
105
#define TMP2            26
106
#define TMP3            27
107
#define TMP4            28
108
#define TMP5            29
109
#define ZERO            30
110
#define MASK_7f         30
111

    
112
#define TMP6            32
113
#define TMP8            34
114
#define TMP10           36
115
#define TMP12           38
116
#define TMP14           40
117
#define TMP16           42
118
#define TMP18           44
119
#define TMP20           46
120
#define TMP22           48
121
#define TMP24           50
122
#define TMP26           52
123
#define TMP28           54
124
#define TMP30           56
125
#define TMP32           58
126

    
127
static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * _ref,
128
                             const int stride, int height)
129
{
130
        uint8_t *ref = (uint8_t *) _ref;
131

    
132
        ref = vis_alignaddr(ref);
133
        do {    /* 5 cycles */
134
                vis_ld64(ref[0], TMP0);
135

    
136
                vis_ld64_2(ref, 8, TMP2);
137

    
138
                vis_ld64_2(ref, 16, TMP4);
139
                ref += stride;
140

    
141
                vis_faligndata(TMP0, TMP2, REF_0);
142
                vis_st64(REF_0, dest[0]);
143

    
144
                vis_faligndata(TMP2, TMP4, REF_2);
145
                vis_st64_2(REF_2, dest, 8);
146
                dest += stride;
147
        } while (--height);
148
}
149

    
150
static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * _ref,
151
                            const int stride, int height)
152
{
153
        uint8_t *ref = (uint8_t *) _ref;
154

    
155
        ref = vis_alignaddr(ref);
156
        do {    /* 4 cycles */
157
                vis_ld64(ref[0], TMP0);
158

    
159
                vis_ld64(ref[8], TMP2);
160
                ref += stride;
161

    
162
                /* stall */
163

    
164
                vis_faligndata(TMP0, TMP2, REF_0);
165
                vis_st64(REF_0, dest[0]);
166
                dest += stride;
167
        } while (--height);
168
}
169

    
170

    
171
static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * _ref,
172
                             const int stride, int height)
173
{
174
        uint8_t *ref = (uint8_t *) _ref;
175
        int stride_8 = stride + 8;
176

    
177
        ref = vis_alignaddr(ref);
178

    
179
        vis_ld64(ref[0], TMP0);
180

    
181
        vis_ld64(ref[8], TMP2);
182

    
183
        vis_ld64(ref[16], TMP4);
184

    
185
        vis_ld64(dest[0], DST_0);
186

    
187
        vis_ld64(dest[8], DST_2);
188

    
189
        vis_ld64(constants_fe[0], MASK_fe);
190
        vis_faligndata(TMP0, TMP2, REF_0);
191

    
192
        vis_ld64(constants_7f[0], MASK_7f);
193
        vis_faligndata(TMP2, TMP4, REF_2);
194

    
195
        vis_ld64(constants128[0], CONST_128);
196

    
197
        ref += stride;
198
        height = (height >> 1) - 1;
199

    
200
        do {    /* 24 cycles */
201
                vis_ld64(ref[0], TMP0);
202
                vis_xor(DST_0, REF_0, TMP6);
203

    
204
                vis_ld64_2(ref, 8, TMP2);
205
                vis_and(TMP6, MASK_fe, TMP6);
206

    
207
                vis_ld64_2(ref, 16, TMP4);
208
                ref += stride;
209
                vis_mul8x16(CONST_128, TMP6, TMP6);
210
                vis_xor(DST_2, REF_2, TMP8);
211

    
212
                vis_and(TMP8, MASK_fe, TMP8);
213

    
214
                vis_or(DST_0, REF_0, TMP10);
215
                vis_ld64_2(dest, stride, DST_0);
216
                vis_mul8x16(CONST_128, TMP8, TMP8);
217

    
218
                vis_or(DST_2, REF_2, TMP12);
219
                vis_ld64_2(dest, stride_8, DST_2);
220

    
221
                vis_ld64(ref[0], TMP14);
222
                vis_and(TMP6, MASK_7f, TMP6);
223

    
224
                vis_and(TMP8, MASK_7f, TMP8);
225

    
226
                vis_psub16(TMP10, TMP6, TMP6);
227
                vis_st64(TMP6, dest[0]);
228

    
229
                vis_psub16(TMP12, TMP8, TMP8);
230
                vis_st64_2(TMP8, dest, 8);
231

    
232
                dest += stride;
233
                vis_ld64_2(ref, 8, TMP16);
234
                vis_faligndata(TMP0, TMP2, REF_0);
235

    
236
                vis_ld64_2(ref, 16, TMP18);
237
                vis_faligndata(TMP2, TMP4, REF_2);
238
                ref += stride;
239

    
240
                vis_xor(DST_0, REF_0, TMP20);
241

    
242
                vis_and(TMP20, MASK_fe, TMP20);
243

    
244
                vis_xor(DST_2, REF_2, TMP22);
245
                vis_mul8x16(CONST_128, TMP20, TMP20);
246

    
247
                vis_and(TMP22, MASK_fe, TMP22);
248

    
249
                vis_or(DST_0, REF_0, TMP24);
250
                vis_mul8x16(CONST_128, TMP22, TMP22);
251

    
252
                vis_or(DST_2, REF_2, TMP26);
253

    
254
                vis_ld64_2(dest, stride, DST_0);
255
                vis_faligndata(TMP14, TMP16, REF_0);
256

    
257
                vis_ld64_2(dest, stride_8, DST_2);
258
                vis_faligndata(TMP16, TMP18, REF_2);
259

    
260
                vis_and(TMP20, MASK_7f, TMP20);
261

    
262
                vis_and(TMP22, MASK_7f, TMP22);
263

    
264
                vis_psub16(TMP24, TMP20, TMP20);
265
                vis_st64(TMP20, dest[0]);
266

    
267
                vis_psub16(TMP26, TMP22, TMP22);
268
                vis_st64_2(TMP22, dest, 8);
269
                dest += stride;
270
        } while (--height);
271

    
272
        vis_ld64(ref[0], TMP0);
273
        vis_xor(DST_0, REF_0, TMP6);
274

    
275
        vis_ld64_2(ref, 8, TMP2);
276
        vis_and(TMP6, MASK_fe, TMP6);
277

    
278
        vis_ld64_2(ref, 16, TMP4);
279
        vis_mul8x16(CONST_128, TMP6, TMP6);
280
        vis_xor(DST_2, REF_2, TMP8);
281

    
282
        vis_and(TMP8, MASK_fe, TMP8);
283

    
284
        vis_or(DST_0, REF_0, TMP10);
285
        vis_ld64_2(dest, stride, DST_0);
286
        vis_mul8x16(CONST_128, TMP8, TMP8);
287

    
288
        vis_or(DST_2, REF_2, TMP12);
289
        vis_ld64_2(dest, stride_8, DST_2);
290

    
291
        vis_ld64(ref[0], TMP14);
292
        vis_and(TMP6, MASK_7f, TMP6);
293

    
294
        vis_and(TMP8, MASK_7f, TMP8);
295

    
296
        vis_psub16(TMP10, TMP6, TMP6);
297
        vis_st64(TMP6, dest[0]);
298

    
299
        vis_psub16(TMP12, TMP8, TMP8);
300
        vis_st64_2(TMP8, dest, 8);
301

    
302
        dest += stride;
303
        vis_faligndata(TMP0, TMP2, REF_0);
304

    
305
        vis_faligndata(TMP2, TMP4, REF_2);
306

    
307
        vis_xor(DST_0, REF_0, TMP20);
308

    
309
        vis_and(TMP20, MASK_fe, TMP20);
310

    
311
        vis_xor(DST_2, REF_2, TMP22);
312
        vis_mul8x16(CONST_128, TMP20, TMP20);
313

    
314
        vis_and(TMP22, MASK_fe, TMP22);
315

    
316
        vis_or(DST_0, REF_0, TMP24);
317
        vis_mul8x16(CONST_128, TMP22, TMP22);
318

    
319
        vis_or(DST_2, REF_2, TMP26);
320

    
321
        vis_and(TMP20, MASK_7f, TMP20);
322

    
323
        vis_and(TMP22, MASK_7f, TMP22);
324

    
325
        vis_psub16(TMP24, TMP20, TMP20);
326
        vis_st64(TMP20, dest[0]);
327

    
328
        vis_psub16(TMP26, TMP22, TMP22);
329
        vis_st64_2(TMP22, dest, 8);
330
}
331

    
332
static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * _ref,
333
                            const int stride, int height)
334
{
335
        uint8_t *ref = (uint8_t *) _ref;
336

    
337
        ref = vis_alignaddr(ref);
338

    
339
        vis_ld64(ref[0], TMP0);
340

    
341
        vis_ld64(ref[8], TMP2);
342

    
343
        vis_ld64(dest[0], DST_0);
344

    
345
        vis_ld64(constants_fe[0], MASK_fe);
346

    
347
        vis_ld64(constants_7f[0], MASK_7f);
348
        vis_faligndata(TMP0, TMP2, REF_0);
349

    
350
        vis_ld64(constants128[0], CONST_128);
351

    
352
        ref += stride;
353
        height = (height >> 1) - 1;
354

    
355
        do {    /* 12 cycles */
356
                vis_ld64(ref[0], TMP0);
357
                vis_xor(DST_0, REF_0, TMP4);
358

    
359
                vis_ld64(ref[8], TMP2);
360
                vis_and(TMP4, MASK_fe, TMP4);
361

    
362
                vis_or(DST_0, REF_0, TMP6);
363
                vis_ld64_2(dest, stride, DST_0);
364
                ref += stride;
365
                vis_mul8x16(CONST_128, TMP4, TMP4);
366

    
367
                vis_ld64(ref[0], TMP12);
368
                vis_faligndata(TMP0, TMP2, REF_0);
369

    
370
                vis_ld64(ref[8], TMP2);
371
                vis_xor(DST_0, REF_0, TMP0);
372
                ref += stride;
373

    
374
                vis_and(TMP0, MASK_fe, TMP0);
375

    
376
                vis_and(TMP4, MASK_7f, TMP4);
377

    
378
                vis_psub16(TMP6, TMP4, TMP4);
379
                vis_st64(TMP4, dest[0]);
380
                dest += stride;
381
                vis_mul8x16(CONST_128, TMP0, TMP0);
382

    
383
                vis_or(DST_0, REF_0, TMP6);
384
                vis_ld64_2(dest, stride, DST_0);
385

    
386
                vis_faligndata(TMP12, TMP2, REF_0);
387

    
388
                vis_and(TMP0, MASK_7f, TMP0);
389

    
390
                vis_psub16(TMP6, TMP0, TMP4);
391
                vis_st64(TMP4, dest[0]);
392
                dest += stride;
393
        } while (--height);
394

    
395
        vis_ld64(ref[0], TMP0);
396
        vis_xor(DST_0, REF_0, TMP4);
397

    
398
        vis_ld64(ref[8], TMP2);
399
        vis_and(TMP4, MASK_fe, TMP4);
400

    
401
        vis_or(DST_0, REF_0, TMP6);
402
        vis_ld64_2(dest, stride, DST_0);
403
        vis_mul8x16(CONST_128, TMP4, TMP4);
404

    
405
        vis_faligndata(TMP0, TMP2, REF_0);
406

    
407
        vis_xor(DST_0, REF_0, TMP0);
408

    
409
        vis_and(TMP0, MASK_fe, TMP0);
410

    
411
        vis_and(TMP4, MASK_7f, TMP4);
412

    
413
        vis_psub16(TMP6, TMP4, TMP4);
414
        vis_st64(TMP4, dest[0]);
415
        dest += stride;
416
        vis_mul8x16(CONST_128, TMP0, TMP0);
417

    
418
        vis_or(DST_0, REF_0, TMP6);
419

    
420
        vis_and(TMP0, MASK_7f, TMP0);
421

    
422
        vis_psub16(TMP6, TMP0, TMP4);
423
        vis_st64(TMP4, dest[0]);
424
}
425

    
426
static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * _ref,
427
                             const int stride, int height)
428
{
429
        uint8_t *ref = (uint8_t *) _ref;
430
        unsigned long off = (unsigned long) ref & 0x7;
431
        unsigned long off_plus_1 = off + 1;
432

    
433
        ref = vis_alignaddr(ref);
434

    
435
        vis_ld64(ref[0],    TMP0);
436

    
437
        vis_ld64_2(ref, 8,  TMP2);
438

    
439
        vis_ld64_2(ref, 16, TMP4);
440

    
441
        vis_ld64(constants_fe[0], MASK_fe);
442

    
443
        vis_ld64(constants_7f[0], MASK_7f);
444
        vis_faligndata(TMP0, TMP2, REF_0);
445

    
446
        vis_ld64(constants128[0], CONST_128);
447
        vis_faligndata(TMP2, TMP4, REF_4);
448

    
449
        if (off != 0x7) {
450
                vis_alignaddr_g0((void *)off_plus_1);
451
                vis_faligndata(TMP0, TMP2, REF_2);
452
                vis_faligndata(TMP2, TMP4, REF_6);
453
        } else {
454
                vis_src1(TMP2, REF_2);
455
                vis_src1(TMP4, REF_6);
456
        }
457

    
458
        ref += stride;
459
        height = (height >> 1) - 1;
460

    
461
        do {    /* 34 cycles */
462
                vis_ld64(ref[0],    TMP0);
463
                vis_xor(REF_0, REF_2, TMP6);
464

    
465
                vis_ld64_2(ref, 8,  TMP2);
466
                vis_xor(REF_4, REF_6, TMP8);
467

    
468
                vis_ld64_2(ref, 16, TMP4);
469
                vis_and(TMP6, MASK_fe, TMP6);
470
                ref += stride;
471

    
472
                vis_ld64(ref[0],    TMP14);
473
                vis_mul8x16(CONST_128, TMP6, TMP6);
474
                vis_and(TMP8, MASK_fe, TMP8);
475

    
476
                vis_ld64_2(ref, 8,  TMP16);
477
                vis_mul8x16(CONST_128, TMP8, TMP8);
478
                vis_or(REF_0, REF_2, TMP10);
479

    
480
                vis_ld64_2(ref, 16, TMP18);
481
                ref += stride;
482
                vis_or(REF_4, REF_6, TMP12);
483

    
484
                vis_alignaddr_g0((void *)off);
485

    
486
                vis_faligndata(TMP0, TMP2, REF_0);
487

    
488
                vis_faligndata(TMP2, TMP4, REF_4);
489

    
490
                if (off != 0x7) {
491
                        vis_alignaddr_g0((void *)off_plus_1);
492
                        vis_faligndata(TMP0, TMP2, REF_2);
493
                        vis_faligndata(TMP2, TMP4, REF_6);
494
                } else {
495
                        vis_src1(TMP2, REF_2);
496
                        vis_src1(TMP4, REF_6);
497
                }
498

    
499
                vis_and(TMP6, MASK_7f, TMP6);
500

    
501
                vis_and(TMP8, MASK_7f, TMP8);
502

    
503
                vis_psub16(TMP10, TMP6, TMP6);
504
                vis_st64(TMP6, dest[0]);
505

    
506
                vis_psub16(TMP12, TMP8, TMP8);
507
                vis_st64_2(TMP8, dest, 8);
508
                dest += stride;
509

    
510
                vis_xor(REF_0, REF_2, TMP6);
511

    
512
                vis_xor(REF_4, REF_6, TMP8);
513

    
514
                vis_and(TMP6, MASK_fe, TMP6);
515

    
516
                vis_mul8x16(CONST_128, TMP6, TMP6);
517
                vis_and(TMP8, MASK_fe, TMP8);
518

    
519
                vis_mul8x16(CONST_128, TMP8, TMP8);
520
                vis_or(REF_0, REF_2, TMP10);
521

    
522
                vis_or(REF_4, REF_6, TMP12);
523

    
524
                vis_alignaddr_g0((void *)off);
525

    
526
                vis_faligndata(TMP14, TMP16, REF_0);
527

    
528
                vis_faligndata(TMP16, TMP18, REF_4);
529

    
530
                if (off != 0x7) {
531
                        vis_alignaddr_g0((void *)off_plus_1);
532
                        vis_faligndata(TMP14, TMP16, REF_2);
533
                        vis_faligndata(TMP16, TMP18, REF_6);
534
                } else {
535
                        vis_src1(TMP16, REF_2);
536
                        vis_src1(TMP18, REF_6);
537
                }
538

    
539
                vis_and(TMP6, MASK_7f, TMP6);
540

    
541
                vis_and(TMP8, MASK_7f, TMP8);
542

    
543
                vis_psub16(TMP10, TMP6, TMP6);
544
                vis_st64(TMP6, dest[0]);
545

    
546
                vis_psub16(TMP12, TMP8, TMP8);
547
                vis_st64_2(TMP8, dest, 8);
548
                dest += stride;
549
        } while (--height);
550

    
551
        vis_ld64(ref[0],    TMP0);
552
        vis_xor(REF_0, REF_2, TMP6);
553

    
554
        vis_ld64_2(ref, 8,  TMP2);
555
        vis_xor(REF_4, REF_6, TMP8);
556

    
557
        vis_ld64_2(ref, 16, TMP4);
558
        vis_and(TMP6, MASK_fe, TMP6);
559

    
560
        vis_mul8x16(CONST_128, TMP6, TMP6);
561
        vis_and(TMP8, MASK_fe, TMP8);
562

    
563
        vis_mul8x16(CONST_128, TMP8, TMP8);
564
        vis_or(REF_0, REF_2, TMP10);
565

    
566
        vis_or(REF_4, REF_6, TMP12);
567

    
568
        vis_alignaddr_g0((void *)off);
569

    
570
        vis_faligndata(TMP0, TMP2, REF_0);
571

    
572
        vis_faligndata(TMP2, TMP4, REF_4);
573

    
574
        if (off != 0x7) {
575
                vis_alignaddr_g0((void *)off_plus_1);
576
                vis_faligndata(TMP0, TMP2, REF_2);
577
                vis_faligndata(TMP2, TMP4, REF_6);
578
        } else {
579
                vis_src1(TMP2, REF_2);
580
                vis_src1(TMP4, REF_6);
581
        }
582

    
583
        vis_and(TMP6, MASK_7f, TMP6);
584

    
585
        vis_and(TMP8, MASK_7f, TMP8);
586

    
587
        vis_psub16(TMP10, TMP6, TMP6);
588
        vis_st64(TMP6, dest[0]);
589

    
590
        vis_psub16(TMP12, TMP8, TMP8);
591
        vis_st64_2(TMP8, dest, 8);
592
        dest += stride;
593

    
594
        vis_xor(REF_0, REF_2, TMP6);
595

    
596
        vis_xor(REF_4, REF_6, TMP8);
597

    
598
        vis_and(TMP6, MASK_fe, TMP6);
599

    
600
        vis_mul8x16(CONST_128, TMP6, TMP6);
601
        vis_and(TMP8, MASK_fe, TMP8);
602

    
603
        vis_mul8x16(CONST_128, TMP8, TMP8);
604
        vis_or(REF_0, REF_2, TMP10);
605

    
606
        vis_or(REF_4, REF_6, TMP12);
607

    
608
        vis_and(TMP6, MASK_7f, TMP6);
609

    
610
        vis_and(TMP8, MASK_7f, TMP8);
611

    
612
        vis_psub16(TMP10, TMP6, TMP6);
613
        vis_st64(TMP6, dest[0]);
614

    
615
        vis_psub16(TMP12, TMP8, TMP8);
616
        vis_st64_2(TMP8, dest, 8);
617
}
618

    
619
static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * _ref,
620
                            const int stride, int height)
621
{
622
        uint8_t *ref = (uint8_t *) _ref;
623
        unsigned long off = (unsigned long) ref & 0x7;
624
        unsigned long off_plus_1 = off + 1;
625

    
626
        ref = vis_alignaddr(ref);
627

    
628
        vis_ld64(ref[0], TMP0);
629

    
630
        vis_ld64(ref[8], TMP2);
631

    
632
        vis_ld64(constants_fe[0], MASK_fe);
633

    
634
        vis_ld64(constants_7f[0], MASK_7f);
635

    
636
        vis_ld64(constants128[0], CONST_128);
637
        vis_faligndata(TMP0, TMP2, REF_0);
638

    
639
        if (off != 0x7) {
640
                vis_alignaddr_g0((void *)off_plus_1);
641
                vis_faligndata(TMP0, TMP2, REF_2);
642
        } else {
643
                vis_src1(TMP2, REF_2);
644
        }
645

    
646
        ref += stride;
647
        height = (height >> 1) - 1;
648

    
649
        do {    /* 20 cycles */
650
                vis_ld64(ref[0], TMP0);
651
                vis_xor(REF_0, REF_2, TMP4);
652

    
653
                vis_ld64_2(ref, 8, TMP2);
654
                vis_and(TMP4, MASK_fe, TMP4);
655
                ref += stride;
656

    
657
                vis_ld64(ref[0], TMP8);
658
                vis_or(REF_0, REF_2, TMP6);
659
                vis_mul8x16(CONST_128, TMP4, TMP4);
660

    
661
                vis_alignaddr_g0((void *)off);
662

    
663
                vis_ld64_2(ref, 8, TMP10);
664
                ref += stride;
665
                vis_faligndata(TMP0, TMP2, REF_0);
666

    
667
                if (off != 0x7) {
668
                        vis_alignaddr_g0((void *)off_plus_1);
669
                        vis_faligndata(TMP0, TMP2, REF_2);
670
                } else {
671
                        vis_src1(TMP2, REF_2);
672
                }
673

    
674
                vis_and(TMP4, MASK_7f, TMP4);
675

    
676
                vis_psub16(TMP6, TMP4, DST_0);
677
                vis_st64(DST_0, dest[0]);
678
                dest += stride;
679

    
680
                vis_xor(REF_0, REF_2, TMP12);
681

    
682
                vis_and(TMP12, MASK_fe, TMP12);
683

    
684
                vis_or(REF_0, REF_2, TMP14);
685
                vis_mul8x16(CONST_128, TMP12, TMP12);
686

    
687
                vis_alignaddr_g0((void *)off);
688
                vis_faligndata(TMP8, TMP10, REF_0);
689
                if (off != 0x7) {
690
                        vis_alignaddr_g0((void *)off_plus_1);
691
                        vis_faligndata(TMP8, TMP10, REF_2);
692
                } else {
693
                        vis_src1(TMP10, REF_2);
694
                }
695

    
696
                vis_and(TMP12, MASK_7f, TMP12);
697

    
698
                vis_psub16(TMP14, TMP12, DST_0);
699
                vis_st64(DST_0, dest[0]);
700
                dest += stride;
701
        } while (--height);
702

    
703
        vis_ld64(ref[0], TMP0);
704
        vis_xor(REF_0, REF_2, TMP4);
705

    
706
        vis_ld64_2(ref, 8, TMP2);
707
        vis_and(TMP4, MASK_fe, TMP4);
708

    
709
        vis_or(REF_0, REF_2, TMP6);
710
        vis_mul8x16(CONST_128, TMP4, TMP4);
711

    
712
        vis_alignaddr_g0((void *)off);
713

    
714
        vis_faligndata(TMP0, TMP2, REF_0);
715

    
716
        if (off != 0x7) {
717
                vis_alignaddr_g0((void *)off_plus_1);
718
                vis_faligndata(TMP0, TMP2, REF_2);
719
        } else {
720
                vis_src1(TMP2, REF_2);
721
        }
722

    
723
        vis_and(TMP4, MASK_7f, TMP4);
724

    
725
        vis_psub16(TMP6, TMP4, DST_0);
726
        vis_st64(DST_0, dest[0]);
727
        dest += stride;
728

    
729
        vis_xor(REF_0, REF_2, TMP12);
730

    
731
        vis_and(TMP12, MASK_fe, TMP12);
732

    
733
        vis_or(REF_0, REF_2, TMP14);
734
        vis_mul8x16(CONST_128, TMP12, TMP12);
735

    
736
        vis_and(TMP12, MASK_7f, TMP12);
737

    
738
        vis_psub16(TMP14, TMP12, DST_0);
739
        vis_st64(DST_0, dest[0]);
740
        dest += stride;
741
}
742

    
743
static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * _ref,
744
                             const int stride, int height)
745
{
746
        uint8_t *ref = (uint8_t *) _ref;
747
        unsigned long off = (unsigned long) ref & 0x7;
748
        unsigned long off_plus_1 = off + 1;
749

    
750
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
751

    
752
        vis_ld64(constants3[0], CONST_3);
753
        vis_fzero(ZERO);
754
        vis_ld64(constants256_512[0], CONST_256);
755

    
756
        ref = vis_alignaddr(ref);
757
        do {    /* 26 cycles */
758
                vis_ld64(ref[0], TMP0);
759

    
760
                vis_ld64(ref[8], TMP2);
761

    
762
                vis_alignaddr_g0((void *)off);
763

    
764
                vis_ld64(ref[16], TMP4);
765

    
766
                vis_ld64(dest[0], DST_0);
767
                vis_faligndata(TMP0, TMP2, REF_0);
768

    
769
                vis_ld64(dest[8], DST_2);
770
                vis_faligndata(TMP2, TMP4, REF_4);
771

    
772
                if (off != 0x7) {
773
                        vis_alignaddr_g0((void *)off_plus_1);
774
                        vis_faligndata(TMP0, TMP2, REF_2);
775
                        vis_faligndata(TMP2, TMP4, REF_6);
776
                } else {
777
                        vis_src1(TMP2, REF_2);
778
                        vis_src1(TMP4, REF_6);
779
                }
780

    
781
                vis_mul8x16au(REF_0,   CONST_256, TMP0);
782

    
783
                vis_pmerge(ZERO,     REF_2,     TMP4);
784
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);
785

    
786
                vis_pmerge(ZERO, REF_2_1, TMP6);
787

    
788
                vis_padd16(TMP0, TMP4, TMP0);
789

    
790
                vis_mul8x16al(DST_0,   CONST_512, TMP4);
791
                vis_padd16(TMP2, TMP6, TMP2);
792

    
793
                vis_mul8x16al(DST_1,   CONST_512, TMP6);
794

    
795
                vis_mul8x16au(REF_6,   CONST_256, TMP12);
796

    
797
                vis_padd16(TMP0, TMP4, TMP0);
798
                vis_mul8x16au(REF_6_1, CONST_256, TMP14);
799

    
800
                vis_padd16(TMP2, TMP6, TMP2);
801
                vis_mul8x16au(REF_4,   CONST_256, TMP16);
802

    
803
                vis_padd16(TMP0, CONST_3, TMP8);
804
                vis_mul8x16au(REF_4_1, CONST_256, TMP18);
805

    
806
                vis_padd16(TMP2, CONST_3, TMP10);
807
                vis_pack16(TMP8, DST_0);
808

    
809
                vis_pack16(TMP10, DST_1);
810
                vis_padd16(TMP16, TMP12, TMP0);
811

    
812
                vis_st64(DST_0, dest[0]);
813
                vis_mul8x16al(DST_2,   CONST_512, TMP4);
814
                vis_padd16(TMP18, TMP14, TMP2);
815

    
816
                vis_mul8x16al(DST_3,   CONST_512, TMP6);
817
                vis_padd16(TMP0, CONST_3, TMP0);
818

    
819
                vis_padd16(TMP2, CONST_3, TMP2);
820

    
821
                vis_padd16(TMP0, TMP4, TMP0);
822

    
823
                vis_padd16(TMP2, TMP6, TMP2);
824
                vis_pack16(TMP0, DST_2);
825

    
826
                vis_pack16(TMP2, DST_3);
827
                vis_st64(DST_2, dest[8]);
828

    
829
                ref += stride;
830
                dest += stride;
831
        } while (--height);
832
}
833

    
834
static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * _ref,
835
                            const int stride, int height)
836
{
837
        uint8_t *ref = (uint8_t *) _ref;
838
        unsigned long off = (unsigned long) ref & 0x7;
839
        unsigned long off_plus_1 = off + 1;
840
        int stride_times_2 = stride << 1;
841

    
842
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
843

    
844
        vis_ld64(constants3[0], CONST_3);
845
        vis_fzero(ZERO);
846
        vis_ld64(constants256_512[0], CONST_256);
847

    
848
        ref = vis_alignaddr(ref);
849
        height >>= 2;
850
        do {    /* 47 cycles */
851
                vis_ld64(ref[0],   TMP0);
852

    
853
                vis_ld64_2(ref, 8, TMP2);
854
                ref += stride;
855

    
856
                vis_alignaddr_g0((void *)off);
857

    
858
                vis_ld64(ref[0],   TMP4);
859
                vis_faligndata(TMP0, TMP2, REF_0);
860

    
861
                vis_ld64_2(ref, 8, TMP6);
862
                ref += stride;
863

    
864
                vis_ld64(ref[0],   TMP8);
865

    
866
                vis_ld64_2(ref, 8, TMP10);
867
                ref += stride;
868
                vis_faligndata(TMP4, TMP6, REF_4);
869

    
870
                vis_ld64(ref[0],   TMP12);
871

    
872
                vis_ld64_2(ref, 8, TMP14);
873
                ref += stride;
874
                vis_faligndata(TMP8, TMP10, REF_S0);
875

    
876
                vis_faligndata(TMP12, TMP14, REF_S4);
877

    
878
                if (off != 0x7) {
879
                        vis_alignaddr_g0((void *)off_plus_1);
880

    
881
                        vis_ld64(dest[0], DST_0);
882
                        vis_faligndata(TMP0, TMP2, REF_2);
883

    
884
                        vis_ld64_2(dest, stride, DST_2);
885
                        vis_faligndata(TMP4, TMP6, REF_6);
886

    
887
                        vis_faligndata(TMP8, TMP10, REF_S2);
888

    
889
                        vis_faligndata(TMP12, TMP14, REF_S6);
890
                } else {
891
                        vis_ld64(dest[0], DST_0);
892
                        vis_src1(TMP2, REF_2);
893

    
894
                        vis_ld64_2(dest, stride, DST_2);
895
                        vis_src1(TMP6, REF_6);
896

    
897
                        vis_src1(TMP10, REF_S2);
898

    
899
                        vis_src1(TMP14, REF_S6);
900
                }
901

    
902
                vis_pmerge(ZERO,     REF_0,     TMP0);
903
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);
904

    
905
                vis_pmerge(ZERO,     REF_2,     TMP4);
906
                vis_mul8x16au(REF_2_1, CONST_256, TMP6);
907

    
908
                vis_padd16(TMP0, CONST_3, TMP0);
909
                vis_mul8x16al(DST_0,   CONST_512, TMP16);
910

    
911
                vis_padd16(TMP2, CONST_3, TMP2);
912
                vis_mul8x16al(DST_1,   CONST_512, TMP18);
913

    
914
                vis_padd16(TMP0, TMP4, TMP0);
915
                vis_mul8x16au(REF_4, CONST_256, TMP8);
916

    
917
                vis_padd16(TMP2, TMP6, TMP2);
918
                vis_mul8x16au(REF_4_1, CONST_256, TMP10);
919

    
920
                vis_padd16(TMP0, TMP16, TMP0);
921
                vis_mul8x16au(REF_6, CONST_256, TMP12);
922

    
923
                vis_padd16(TMP2, TMP18, TMP2);
924
                vis_mul8x16au(REF_6_1, CONST_256, TMP14);
925

    
926
                vis_padd16(TMP8, CONST_3, TMP8);
927
                vis_mul8x16al(DST_2, CONST_512, TMP16);
928

    
929
                vis_padd16(TMP8, TMP12, TMP8);
930
                vis_mul8x16al(DST_3, CONST_512, TMP18);
931

    
932
                vis_padd16(TMP10, TMP14, TMP10);
933
                vis_pack16(TMP0, DST_0);
934

    
935
                vis_pack16(TMP2, DST_1);
936
                vis_st64(DST_0, dest[0]);
937
                dest += stride;
938
                vis_padd16(TMP10, CONST_3, TMP10);
939

    
940
                vis_ld64_2(dest, stride, DST_0);
941
                vis_padd16(TMP8, TMP16, TMP8);
942

    
943
                vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
944
                vis_padd16(TMP10, TMP18, TMP10);
945
                vis_pack16(TMP8, DST_2);
946

    
947
                vis_pack16(TMP10, DST_3);
948
                vis_st64(DST_2, dest[0]);
949
                dest += stride;
950

    
951
                vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
952
                vis_pmerge(ZERO,     REF_S0,     TMP0);
953

    
954
                vis_pmerge(ZERO,     REF_S2,     TMP24);
955
                vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
956

    
957
                vis_padd16(TMP0, CONST_3, TMP0);
958
                vis_mul8x16au(REF_S4, CONST_256, TMP8);
959

    
960
                vis_padd16(TMP2, CONST_3, TMP2);
961
                vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
962

    
963
                vis_padd16(TMP0, TMP24, TMP0);
964
                vis_mul8x16au(REF_S6, CONST_256, TMP12);
965

    
966
                vis_padd16(TMP2, TMP6, TMP2);
967
                vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
968

    
969
                vis_padd16(TMP8, CONST_3, TMP8);
970
                vis_mul8x16al(DST_0,   CONST_512, TMP16);
971

    
972
                vis_padd16(TMP10, CONST_3, TMP10);
973
                vis_mul8x16al(DST_1,   CONST_512, TMP18);
974

    
975
                vis_padd16(TMP8, TMP12, TMP8);
976
                vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
977

    
978
                vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
979
                vis_padd16(TMP0, TMP16, TMP0);
980

    
981
                vis_padd16(TMP2, TMP18, TMP2);
982
                vis_pack16(TMP0, DST_0);
983

    
984
                vis_padd16(TMP10, TMP14, TMP10);
985
                vis_pack16(TMP2, DST_1);
986
                vis_st64(DST_0, dest[0]);
987
                dest += stride;
988

    
989
                vis_padd16(TMP8, TMP20, TMP8);
990

    
991
                vis_padd16(TMP10, TMP22, TMP10);
992
                vis_pack16(TMP8, DST_2);
993

    
994
                vis_pack16(TMP10, DST_3);
995
                vis_st64(DST_2, dest[0]);
996
                dest += stride;
997
        } while (--height);
998
}
999

    
1000
static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * _ref,
1001
                             const int stride, int height)
1002
{
1003
        uint8_t *ref = (uint8_t *) _ref;
1004

    
1005
        ref = vis_alignaddr(ref);
1006
        vis_ld64(ref[0], TMP0);
1007

    
1008
        vis_ld64_2(ref, 8, TMP2);
1009

    
1010
        vis_ld64_2(ref, 16, TMP4);
1011
        ref += stride;
1012

    
1013
        vis_ld64(ref[0], TMP6);
1014
        vis_faligndata(TMP0, TMP2, REF_0);
1015

    
1016
        vis_ld64_2(ref, 8, TMP8);
1017
        vis_faligndata(TMP2, TMP4, REF_4);
1018

    
1019
        vis_ld64_2(ref, 16, TMP10);
1020
        ref += stride;
1021

    
1022
        vis_ld64(constants_fe[0], MASK_fe);
1023
        vis_faligndata(TMP6, TMP8, REF_2);
1024

    
1025
        vis_ld64(constants_7f[0], MASK_7f);
1026
        vis_faligndata(TMP8, TMP10, REF_6);
1027

    
1028
        vis_ld64(constants128[0], CONST_128);
1029
        height = (height >> 1) - 1;
1030
        do {    /* 24 cycles */
1031
                vis_ld64(ref[0], TMP0);
1032
                vis_xor(REF_0, REF_2, TMP12);
1033

    
1034
                vis_ld64_2(ref, 8, TMP2);
1035
                vis_xor(REF_4, REF_6, TMP16);
1036

    
1037
                vis_ld64_2(ref, 16, TMP4);
1038
                ref += stride;
1039
                vis_or(REF_0, REF_2, TMP14);
1040

    
1041
                vis_ld64(ref[0], TMP6);
1042
                vis_or(REF_4, REF_6, TMP18);
1043

    
1044
                vis_ld64_2(ref, 8, TMP8);
1045
                vis_faligndata(TMP0, TMP2, REF_0);
1046

    
1047
                vis_ld64_2(ref, 16, TMP10);
1048
                ref += stride;
1049
                vis_faligndata(TMP2, TMP4, REF_4);
1050

    
1051
                vis_and(TMP12, MASK_fe, TMP12);
1052

    
1053
                vis_and(TMP16, MASK_fe, TMP16);
1054
                vis_mul8x16(CONST_128, TMP12, TMP12);
1055

    
1056
                vis_mul8x16(CONST_128, TMP16, TMP16);
1057
                vis_xor(REF_0, REF_2, TMP0);
1058

    
1059
                vis_xor(REF_4, REF_6, TMP2);
1060

    
1061
                vis_or(REF_0, REF_2, TMP20);
1062

    
1063
                vis_and(TMP12, MASK_7f, TMP12);
1064

    
1065
                vis_and(TMP16, MASK_7f, TMP16);
1066

    
1067
                vis_psub16(TMP14, TMP12, TMP12);
1068
                vis_st64(TMP12, dest[0]);
1069

    
1070
                vis_psub16(TMP18, TMP16, TMP16);
1071
                vis_st64_2(TMP16, dest, 8);
1072
                dest += stride;
1073

    
1074
                vis_or(REF_4, REF_6, TMP18);
1075

    
1076
                vis_and(TMP0, MASK_fe, TMP0);
1077

    
1078
                vis_and(TMP2, MASK_fe, TMP2);
1079
                vis_mul8x16(CONST_128, TMP0, TMP0);
1080

    
1081
                vis_faligndata(TMP6, TMP8, REF_2);
1082
                vis_mul8x16(CONST_128, TMP2, TMP2);
1083

    
1084
                vis_faligndata(TMP8, TMP10, REF_6);
1085

    
1086
                vis_and(TMP0, MASK_7f, TMP0);
1087

    
1088
                vis_and(TMP2, MASK_7f, TMP2);
1089

    
1090
                vis_psub16(TMP20, TMP0, TMP0);
1091
                vis_st64(TMP0, dest[0]);
1092

    
1093
                vis_psub16(TMP18, TMP2, TMP2);
1094
                vis_st64_2(TMP2, dest, 8);
1095
                dest += stride;
1096
        } while (--height);
1097

    
1098
        vis_ld64(ref[0], TMP0);
1099
        vis_xor(REF_0, REF_2, TMP12);
1100

    
1101
        vis_ld64_2(ref, 8, TMP2);
1102
        vis_xor(REF_4, REF_6, TMP16);
1103

    
1104
        vis_ld64_2(ref, 16, TMP4);
1105
        vis_or(REF_0, REF_2, TMP14);
1106

    
1107
        vis_or(REF_4, REF_6, TMP18);
1108

    
1109
        vis_faligndata(TMP0, TMP2, REF_0);
1110

    
1111
        vis_faligndata(TMP2, TMP4, REF_4);
1112

    
1113
        vis_and(TMP12, MASK_fe, TMP12);
1114

    
1115
        vis_and(TMP16, MASK_fe, TMP16);
1116
        vis_mul8x16(CONST_128, TMP12, TMP12);
1117

    
1118
        vis_mul8x16(CONST_128, TMP16, TMP16);
1119
        vis_xor(REF_0, REF_2, TMP0);
1120

    
1121
        vis_xor(REF_4, REF_6, TMP2);
1122

    
1123
        vis_or(REF_0, REF_2, TMP20);
1124

    
1125
        vis_and(TMP12, MASK_7f, TMP12);
1126

    
1127
        vis_and(TMP16, MASK_7f, TMP16);
1128

    
1129
        vis_psub16(TMP14, TMP12, TMP12);
1130
        vis_st64(TMP12, dest[0]);
1131

    
1132
        vis_psub16(TMP18, TMP16, TMP16);
1133
        vis_st64_2(TMP16, dest, 8);
1134
        dest += stride;
1135

    
1136
        vis_or(REF_4, REF_6, TMP18);
1137

    
1138
        vis_and(TMP0, MASK_fe, TMP0);
1139

    
1140
        vis_and(TMP2, MASK_fe, TMP2);
1141
        vis_mul8x16(CONST_128, TMP0, TMP0);
1142

    
1143
        vis_mul8x16(CONST_128, TMP2, TMP2);
1144

    
1145
        vis_and(TMP0, MASK_7f, TMP0);
1146

    
1147
        vis_and(TMP2, MASK_7f, TMP2);
1148

    
1149
        vis_psub16(TMP20, TMP0, TMP0);
1150
        vis_st64(TMP0, dest[0]);
1151

    
1152
        vis_psub16(TMP18, TMP2, TMP2);
1153
        vis_st64_2(TMP2, dest, 8);
1154
}
1155

    
1156
static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * _ref,
1157
                            const int stride, int height)
1158
{
1159
        uint8_t *ref = (uint8_t *) _ref;
1160

    
1161
        ref = vis_alignaddr(ref);
1162
        vis_ld64(ref[0], TMP0);
1163

    
1164
        vis_ld64_2(ref, 8, TMP2);
1165
        ref += stride;
1166

    
1167
        vis_ld64(ref[0], TMP4);
1168

    
1169
        vis_ld64_2(ref, 8, TMP6);
1170
        ref += stride;
1171

    
1172
        vis_ld64(constants_fe[0], MASK_fe);
1173
        vis_faligndata(TMP0, TMP2, REF_0);
1174

    
1175
        vis_ld64(constants_7f[0], MASK_7f);
1176
        vis_faligndata(TMP4, TMP6, REF_2);
1177

    
1178
        vis_ld64(constants128[0], CONST_128);
1179
        height = (height >> 1) - 1;
1180
        do {    /* 12 cycles */
1181
                vis_ld64(ref[0], TMP0);
1182
                vis_xor(REF_0, REF_2, TMP4);
1183

    
1184
                vis_ld64_2(ref, 8, TMP2);
1185
                ref += stride;
1186
                vis_and(TMP4, MASK_fe, TMP4);
1187

    
1188
                vis_or(REF_0, REF_2, TMP6);
1189
                vis_mul8x16(CONST_128, TMP4, TMP4);
1190

    
1191
                vis_faligndata(TMP0, TMP2, REF_0);
1192
                vis_ld64(ref[0], TMP0);
1193

    
1194
                vis_ld64_2(ref, 8, TMP2);
1195
                ref += stride;
1196
                vis_xor(REF_0, REF_2, TMP12);
1197

    
1198
                vis_and(TMP4, MASK_7f, TMP4);
1199

    
1200
                vis_and(TMP12, MASK_fe, TMP12);
1201

    
1202
                vis_mul8x16(CONST_128, TMP12, TMP12);
1203
                vis_or(REF_0, REF_2, TMP14);
1204

    
1205
                vis_psub16(TMP6, TMP4, DST_0);
1206
                vis_st64(DST_0, dest[0]);
1207
                dest += stride;
1208

    
1209
                vis_faligndata(TMP0, TMP2, REF_2);
1210

    
1211
                vis_and(TMP12, MASK_7f, TMP12);
1212

    
1213
                vis_psub16(TMP14, TMP12, DST_0);
1214
                vis_st64(DST_0, dest[0]);
1215
                dest += stride;
1216
        } while (--height);
1217

    
1218
        vis_ld64(ref[0], TMP0);
1219
        vis_xor(REF_0, REF_2, TMP4);
1220

    
1221
        vis_ld64_2(ref, 8, TMP2);
1222
        vis_and(TMP4, MASK_fe, TMP4);
1223

    
1224
        vis_or(REF_0, REF_2, TMP6);
1225
        vis_mul8x16(CONST_128, TMP4, TMP4);
1226

    
1227
        vis_faligndata(TMP0, TMP2, REF_0);
1228

    
1229
        vis_xor(REF_0, REF_2, TMP12);
1230

    
1231
        vis_and(TMP4, MASK_7f, TMP4);
1232

    
1233
        vis_and(TMP12, MASK_fe, TMP12);
1234

    
1235
        vis_mul8x16(CONST_128, TMP12, TMP12);
1236
        vis_or(REF_0, REF_2, TMP14);
1237

    
1238
        vis_psub16(TMP6, TMP4, DST_0);
1239
        vis_st64(DST_0, dest[0]);
1240
        dest += stride;
1241

    
1242
        vis_and(TMP12, MASK_7f, TMP12);
1243

    
1244
        vis_psub16(TMP14, TMP12, DST_0);
1245
        vis_st64(DST_0, dest[0]);
1246
}
1247

    
1248
static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * _ref,
1249
                             const int stride, int height)
1250
{
1251
        uint8_t *ref = (uint8_t *) _ref;
1252
        int stride_8 = stride + 8;
1253
        int stride_16 = stride + 16;
1254

    
1255
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1256

    
1257
        ref = vis_alignaddr(ref);
1258

    
1259
        vis_ld64(ref[ 0], TMP0);
1260
        vis_fzero(ZERO);
1261

    
1262
        vis_ld64(ref[ 8], TMP2);
1263

    
1264
        vis_ld64(ref[16], TMP4);
1265

    
1266
        vis_ld64(constants3[0], CONST_3);
1267
        vis_faligndata(TMP0, TMP2, REF_2);
1268

    
1269
        vis_ld64(constants256_512[0], CONST_256);
1270
        vis_faligndata(TMP2, TMP4, REF_6);
1271
        height >>= 1;
1272

    
1273
        do {    /* 31 cycles */
1274
                vis_ld64_2(ref, stride, TMP0);
1275
                vis_pmerge(ZERO,       REF_2,     TMP12);
1276
                vis_mul8x16au(REF_2_1, CONST_256, TMP14);
1277

    
1278
                vis_ld64_2(ref, stride_8, TMP2);
1279
                vis_pmerge(ZERO,       REF_6,     TMP16);
1280
                vis_mul8x16au(REF_6_1, CONST_256, TMP18);
1281

    
1282
                vis_ld64_2(ref, stride_16, TMP4);
1283
                ref += stride;
1284

    
1285
                vis_ld64(dest[0], DST_0);
1286
                vis_faligndata(TMP0, TMP2, REF_0);
1287

    
1288
                vis_ld64_2(dest, 8, DST_2);
1289
                vis_faligndata(TMP2, TMP4, REF_4);
1290

    
1291
                vis_ld64_2(ref, stride, TMP6);
1292
                vis_pmerge(ZERO,     REF_0,     TMP0);
1293
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);
1294

    
1295
                vis_ld64_2(ref, stride_8, TMP8);
1296
                vis_pmerge(ZERO,     REF_4,     TMP4);
1297

    
1298
                vis_ld64_2(ref, stride_16, TMP10);
1299
                ref += stride;
1300

    
1301
                vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
1302
                vis_faligndata(TMP6, TMP8, REF_2);
1303
                vis_mul8x16au(REF_4_1, CONST_256, TMP6);
1304

    
1305
                vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
1306
                vis_faligndata(TMP8, TMP10, REF_6);
1307
                vis_mul8x16al(DST_0,   CONST_512, TMP20);
1308

    
1309
                vis_padd16(TMP0, CONST_3, TMP0);
1310
                vis_mul8x16al(DST_1,   CONST_512, TMP22);
1311

    
1312
                vis_padd16(TMP2, CONST_3, TMP2);
1313
                vis_mul8x16al(DST_2,   CONST_512, TMP24);
1314

    
1315
                vis_padd16(TMP4, CONST_3, TMP4);
1316
                vis_mul8x16al(DST_3,   CONST_512, TMP26);
1317

    
1318
                vis_padd16(TMP6, CONST_3, TMP6);
1319

    
1320
                vis_padd16(TMP12, TMP20, TMP12);
1321
                vis_mul8x16al(REF_S0,   CONST_512, TMP20);
1322

    
1323
                vis_padd16(TMP14, TMP22, TMP14);
1324
                vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
1325

    
1326
                vis_padd16(TMP16, TMP24, TMP16);
1327
                vis_mul8x16al(REF_S2,   CONST_512, TMP24);
1328

    
1329
                vis_padd16(TMP18, TMP26, TMP18);
1330
                vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
1331

    
1332
                vis_padd16(TMP12, TMP0, TMP12);
1333
                vis_mul8x16au(REF_2,   CONST_256, TMP28);
1334

    
1335
                vis_padd16(TMP14, TMP2, TMP14);
1336
                vis_mul8x16au(REF_2_1, CONST_256, TMP30);
1337

    
1338
                vis_padd16(TMP16, TMP4, TMP16);
1339
                vis_mul8x16au(REF_6,   CONST_256, REF_S4);
1340

    
1341
                vis_padd16(TMP18, TMP6, TMP18);
1342
                vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
1343

    
1344
                vis_pack16(TMP12, DST_0);
1345
                vis_padd16(TMP28, TMP0, TMP12);
1346

    
1347
                vis_pack16(TMP14, DST_1);
1348
                vis_st64(DST_0, dest[0]);
1349
                vis_padd16(TMP30, TMP2, TMP14);
1350

    
1351
                vis_pack16(TMP16, DST_2);
1352
                vis_padd16(REF_S4, TMP4, TMP16);
1353

    
1354
                vis_pack16(TMP18, DST_3);
1355
                vis_st64_2(DST_2, dest, 8);
1356
                dest += stride;
1357
                vis_padd16(REF_S6, TMP6, TMP18);
1358

    
1359
                vis_padd16(TMP12, TMP20, TMP12);
1360

    
1361
                vis_padd16(TMP14, TMP22, TMP14);
1362
                vis_pack16(TMP12, DST_0);
1363

    
1364
                vis_padd16(TMP16, TMP24, TMP16);
1365
                vis_pack16(TMP14, DST_1);
1366
                vis_st64(DST_0, dest[0]);
1367

    
1368
                vis_padd16(TMP18, TMP26, TMP18);
1369
                vis_pack16(TMP16, DST_2);
1370

    
1371
                vis_pack16(TMP18, DST_3);
1372
                vis_st64_2(DST_2, dest, 8);
1373
                dest += stride;
1374
        } while (--height);
1375
}
1376

    
1377
static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * _ref,
1378
                            const int stride, int height)
1379
{
1380
        uint8_t *ref = (uint8_t *) _ref;
1381
        int stride_8 = stride + 8;
1382

    
1383
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1384

    
1385
        ref = vis_alignaddr(ref);
1386

    
1387
        vis_ld64(ref[ 0], TMP0);
1388
        vis_fzero(ZERO);
1389

    
1390
        vis_ld64(ref[ 8], TMP2);
1391

    
1392
        vis_ld64(constants3[0], CONST_3);
1393
        vis_faligndata(TMP0, TMP2, REF_2);
1394

    
1395
        vis_ld64(constants256_512[0], CONST_256);
1396

    
1397
        height >>= 1;
1398
        do {    /* 20 cycles */
1399
                vis_ld64_2(ref, stride, TMP0);
1400
                vis_pmerge(ZERO,       REF_2,     TMP8);
1401
                vis_mul8x16au(REF_2_1, CONST_256, TMP10);
1402

    
1403
                vis_ld64_2(ref, stride_8, TMP2);
1404
                ref += stride;
1405

    
1406
                vis_ld64(dest[0], DST_0);
1407

    
1408
                vis_ld64_2(dest, stride, DST_2);
1409
                vis_faligndata(TMP0, TMP2, REF_0);
1410

    
1411
                vis_ld64_2(ref, stride, TMP4);
1412
                vis_mul8x16al(DST_0,   CONST_512, TMP16);
1413
                vis_pmerge(ZERO,       REF_0,     TMP12);
1414

    
1415
                vis_ld64_2(ref, stride_8, TMP6);
1416
                ref += stride;
1417
                vis_mul8x16al(DST_1,   CONST_512, TMP18);
1418
                vis_pmerge(ZERO,       REF_0_1,   TMP14);
1419

    
1420
                vis_padd16(TMP12, CONST_3, TMP12);
1421
                vis_mul8x16al(DST_2,   CONST_512, TMP24);
1422

    
1423
                vis_padd16(TMP14, CONST_3, TMP14);
1424
                vis_mul8x16al(DST_3,   CONST_512, TMP26);
1425

    
1426
                vis_faligndata(TMP4, TMP6, REF_2);
1427

    
1428
                vis_padd16(TMP8, TMP12, TMP8);
1429

    
1430
                vis_padd16(TMP10, TMP14, TMP10);
1431
                vis_mul8x16au(REF_2,   CONST_256, TMP20);
1432

    
1433
                vis_padd16(TMP8, TMP16, TMP0);
1434
                vis_mul8x16au(REF_2_1, CONST_256, TMP22);
1435

    
1436
                vis_padd16(TMP10, TMP18, TMP2);
1437
                vis_pack16(TMP0, DST_0);
1438

    
1439
                vis_pack16(TMP2, DST_1);
1440
                vis_st64(DST_0, dest[0]);
1441
                dest += stride;
1442
                vis_padd16(TMP12, TMP20, TMP12);
1443

    
1444
                vis_padd16(TMP14, TMP22, TMP14);
1445

    
1446
                vis_padd16(TMP12, TMP24, TMP0);
1447

    
1448
                vis_padd16(TMP14, TMP26, TMP2);
1449
                vis_pack16(TMP0, DST_2);
1450

    
1451
                vis_pack16(TMP2, DST_3);
1452
                vis_st64(DST_2, dest[0]);
1453
                dest += stride;
1454
        } while (--height);
1455
}
1456

    
1457
static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
1458
                              const int stride, int height)
1459
{
1460
        uint8_t *ref = (uint8_t *) _ref;
1461
        unsigned long off = (unsigned long) ref & 0x7;
1462
        unsigned long off_plus_1 = off + 1;
1463
        int stride_8 = stride + 8;
1464
        int stride_16 = stride + 16;
1465

    
1466
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1467

    
1468
        ref = vis_alignaddr(ref);
1469

    
1470
        vis_ld64(ref[ 0], TMP0);
1471
        vis_fzero(ZERO);
1472

    
1473
        vis_ld64(ref[ 8], TMP2);
1474

    
1475
        vis_ld64(ref[16], TMP4);
1476

    
1477
        vis_ld64(constants2[0], CONST_2);
1478
        vis_faligndata(TMP0, TMP2, REF_S0);
1479

    
1480
        vis_ld64(constants256_512[0], CONST_256);
1481
        vis_faligndata(TMP2, TMP4, REF_S4);
1482

    
1483
        if (off != 0x7) {
1484
                vis_alignaddr_g0((void *)off_plus_1);
1485
                vis_faligndata(TMP0, TMP2, REF_S2);
1486
                vis_faligndata(TMP2, TMP4, REF_S6);
1487
        } else {
1488
                vis_src1(TMP2, REF_S2);
1489
                vis_src1(TMP4, REF_S6);
1490
        }
1491

    
1492
        height >>= 1;
1493
        do {
1494
                vis_ld64_2(ref, stride, TMP0);
1495
                vis_mul8x16au(REF_S0, CONST_256, TMP12);
1496
                vis_pmerge(ZERO,      REF_S0_1,  TMP14);
1497

    
1498
                vis_alignaddr_g0((void *)off);
1499

    
1500
                vis_ld64_2(ref, stride_8, TMP2);
1501
                vis_mul8x16au(REF_S2, CONST_256, TMP16);
1502
                vis_pmerge(ZERO,      REF_S2_1,  TMP18);
1503

    
1504
                vis_ld64_2(ref, stride_16, TMP4);
1505
                ref += stride;
1506
                vis_mul8x16au(REF_S4, CONST_256, TMP20);
1507
                vis_pmerge(ZERO,      REF_S4_1,  TMP22);
1508

    
1509
                vis_ld64_2(ref, stride, TMP6);
1510
                vis_mul8x16au(REF_S6, CONST_256, TMP24);
1511
                vis_pmerge(ZERO,      REF_S6_1,  TMP26);
1512

    
1513
                vis_ld64_2(ref, stride_8, TMP8);
1514
                vis_faligndata(TMP0, TMP2, REF_0);
1515

    
1516
                vis_ld64_2(ref, stride_16, TMP10);
1517
                ref += stride;
1518
                vis_faligndata(TMP2, TMP4, REF_4);
1519

    
1520
                vis_faligndata(TMP6, TMP8, REF_S0);
1521

    
1522
                vis_faligndata(TMP8, TMP10, REF_S4);
1523

    
1524
                if (off != 0x7) {
1525
                        vis_alignaddr_g0((void *)off_plus_1);
1526
                        vis_faligndata(TMP0, TMP2, REF_2);
1527
                        vis_faligndata(TMP2, TMP4, REF_6);
1528
                        vis_faligndata(TMP6, TMP8, REF_S2);
1529
                        vis_faligndata(TMP8, TMP10, REF_S6);
1530
                } else {
1531
                        vis_src1(TMP2, REF_2);
1532
                        vis_src1(TMP4, REF_6);
1533
                        vis_src1(TMP8, REF_S2);
1534
                        vis_src1(TMP10, REF_S6);
1535
                }
1536

    
1537
                vis_mul8x16au(REF_0, CONST_256, TMP0);
1538
                vis_pmerge(ZERO,      REF_0_1,  TMP2);
1539

    
1540
                vis_mul8x16au(REF_2, CONST_256, TMP4);
1541
                vis_pmerge(ZERO,      REF_2_1,  TMP6);
1542

    
1543
                vis_padd16(TMP0, CONST_2, TMP8);
1544
                vis_mul8x16au(REF_4, CONST_256, TMP0);
1545

    
1546
                vis_padd16(TMP2, CONST_2, TMP10);
1547
                vis_mul8x16au(REF_4_1, CONST_256, TMP2);
1548

    
1549
                vis_padd16(TMP8, TMP4, TMP8);
1550
                vis_mul8x16au(REF_6, CONST_256, TMP4);
1551

    
1552
                vis_padd16(TMP10, TMP6, TMP10);
1553
                vis_mul8x16au(REF_6_1, CONST_256, TMP6);
1554

    
1555
                vis_padd16(TMP12, TMP8, TMP12);
1556

    
1557
                vis_padd16(TMP14, TMP10, TMP14);
1558

    
1559
                vis_padd16(TMP12, TMP16, TMP12);
1560

    
1561
                vis_padd16(TMP14, TMP18, TMP14);
1562
                vis_pack16(TMP12, DST_0);
1563

    
1564
                vis_pack16(TMP14, DST_1);
1565
                vis_st64(DST_0, dest[0]);
1566
                vis_padd16(TMP0, CONST_2, TMP12);
1567

    
1568
                vis_mul8x16au(REF_S0, CONST_256, TMP0);
1569
                vis_padd16(TMP2, CONST_2, TMP14);
1570

    
1571
                vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
1572
                vis_padd16(TMP12, TMP4, TMP12);
1573

    
1574
                vis_mul8x16au(REF_S2, CONST_256, TMP4);
1575
                vis_padd16(TMP14, TMP6, TMP14);
1576

    
1577
                vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
1578
                vis_padd16(TMP20, TMP12, TMP20);
1579

    
1580
                vis_padd16(TMP22, TMP14, TMP22);
1581

    
1582
                vis_padd16(TMP20, TMP24, TMP20);
1583

    
1584
                vis_padd16(TMP22, TMP26, TMP22);
1585
                vis_pack16(TMP20, DST_2);
1586

    
1587
                vis_pack16(TMP22, DST_3);
1588
                vis_st64_2(DST_2, dest, 8);
1589
                dest += stride;
1590
                vis_padd16(TMP0, TMP4, TMP24);
1591

    
1592
                vis_mul8x16au(REF_S4, CONST_256, TMP0);
1593
                vis_padd16(TMP2, TMP6, TMP26);
1594

    
1595
                vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
1596
                vis_padd16(TMP24, TMP8, TMP24);
1597

    
1598
                vis_padd16(TMP26, TMP10, TMP26);
1599
                vis_pack16(TMP24, DST_0);
1600

    
1601
                vis_pack16(TMP26, DST_1);
1602
                vis_st64(DST_0, dest[0]);
1603
                vis_pmerge(ZERO, REF_S6, TMP4);
1604

    
1605
                vis_pmerge(ZERO,      REF_S6_1,  TMP6);
1606

    
1607
                vis_padd16(TMP0, TMP4, TMP0);
1608

    
1609
                vis_padd16(TMP2, TMP6, TMP2);
1610

    
1611
                vis_padd16(TMP0, TMP12, TMP0);
1612

    
1613
                vis_padd16(TMP2, TMP14, TMP2);
1614
                vis_pack16(TMP0, DST_2);
1615

    
1616
                vis_pack16(TMP2, DST_3);
1617
                vis_st64_2(DST_2, dest, 8);
1618
                dest += stride;
1619
        } while (--height);
1620
}
1621

    
1622
static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
1623
                             const int stride, int height)
1624
{
1625
        uint8_t *ref = (uint8_t *) _ref;
1626
        unsigned long off = (unsigned long) ref & 0x7;
1627
        unsigned long off_plus_1 = off + 1;
1628
        int stride_8 = stride + 8;
1629

    
1630
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
1631

    
1632
        ref = vis_alignaddr(ref);
1633

    
1634
        vis_ld64(ref[ 0], TMP0);
1635
        vis_fzero(ZERO);
1636

    
1637
        vis_ld64(ref[ 8], TMP2);
1638

    
1639
        vis_ld64(constants2[0], CONST_2);
1640

    
1641
        vis_ld64(constants256_512[0], CONST_256);
1642
        vis_faligndata(TMP0, TMP2, REF_S0);
1643

    
1644
        if (off != 0x7) {
1645
                vis_alignaddr_g0((void *)off_plus_1);
1646
                vis_faligndata(TMP0, TMP2, REF_S2);
1647
        } else {
1648
                vis_src1(TMP2, REF_S2);
1649
        }
1650

    
1651
        height >>= 1;
1652
        do {    /* 26 cycles */
1653
                vis_ld64_2(ref, stride, TMP0);
1654
                vis_mul8x16au(REF_S0,   CONST_256, TMP8);
1655
                vis_pmerge(ZERO,        REF_S2,    TMP12);
1656

    
1657
                vis_alignaddr_g0((void *)off);
1658

    
1659
                vis_ld64_2(ref, stride_8, TMP2);
1660
                ref += stride;
1661
                vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
1662
                vis_pmerge(ZERO,        REF_S2_1,  TMP14);
1663

    
1664
                vis_ld64_2(ref, stride, TMP4);
1665

    
1666
                vis_ld64_2(ref, stride_8, TMP6);
1667
                ref += stride;
1668
                vis_faligndata(TMP0, TMP2, REF_S4);
1669

    
1670
                vis_pmerge(ZERO, REF_S4, TMP18);
1671

    
1672
                vis_pmerge(ZERO, REF_S4_1, TMP20);
1673

    
1674
                vis_faligndata(TMP4, TMP6, REF_S0);
1675

    
1676
                if (off != 0x7) {
1677
                        vis_alignaddr_g0((void *)off_plus_1);
1678
                        vis_faligndata(TMP0, TMP2, REF_S6);
1679
                        vis_faligndata(TMP4, TMP6, REF_S2);
1680
                } else {
1681
                        vis_src1(TMP2, REF_S6);
1682
                        vis_src1(TMP6, REF_S2);
1683
                }
1684

    
1685
                vis_padd16(TMP18, CONST_2, TMP18);
1686
                vis_mul8x16au(REF_S6,   CONST_256, TMP22);
1687

    
1688
                vis_padd16(TMP20, CONST_2, TMP20);
1689
                vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
1690

    
1691
                vis_mul8x16au(REF_S0,   CONST_256, TMP26);
1692
                vis_pmerge(ZERO, REF_S0_1, TMP28);
1693

    
1694
                vis_mul8x16au(REF_S2,   CONST_256, TMP30);
1695
                vis_padd16(TMP18, TMP22, TMP18);
1696

    
1697
                vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
1698
                vis_padd16(TMP20, TMP24, TMP20);
1699

    
1700
                vis_padd16(TMP8,  TMP18, TMP8);
1701

    
1702
                vis_padd16(TMP10, TMP20, TMP10);
1703

    
1704
                vis_padd16(TMP8,  TMP12, TMP8);
1705

    
1706
                vis_padd16(TMP10, TMP14, TMP10);
1707
                vis_pack16(TMP8,  DST_0);
1708

    
1709
                vis_pack16(TMP10, DST_1);
1710
                vis_st64(DST_0, dest[0]);
1711
                dest += stride;
1712
                vis_padd16(TMP18, TMP26, TMP18);
1713

    
1714
                vis_padd16(TMP20, TMP28, TMP20);
1715

    
1716
                vis_padd16(TMP18, TMP30, TMP18);
1717

    
1718
                vis_padd16(TMP20, TMP32, TMP20);
1719
                vis_pack16(TMP18, DST_2);
1720

    
1721
                vis_pack16(TMP20, DST_3);
1722
                vis_st64(DST_2, dest[0]);
1723
                dest += stride;
1724
        } while (--height);
1725
}
1726

    
1727
static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
1728
                              const int stride, int height)
1729
{
1730
        uint8_t *ref = (uint8_t *) _ref;
1731
        unsigned long off = (unsigned long) ref & 0x7;
1732
        unsigned long off_plus_1 = off + 1;
1733
        int stride_8 = stride + 8;
1734
        int stride_16 = stride + 16;
1735

    
1736
        vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
1737

    
1738
        ref = vis_alignaddr(ref);
1739

    
1740
        vis_ld64(ref[ 0], TMP0);
1741
        vis_fzero(ZERO);
1742

    
1743
        vis_ld64(ref[ 8], TMP2);
1744

    
1745
        vis_ld64(ref[16], TMP4);
1746

    
1747
        vis_ld64(constants6[0], CONST_6);
1748
        vis_faligndata(TMP0, TMP2, REF_S0);
1749

    
1750
        vis_ld64(constants256_1024[0], CONST_256);
1751
        vis_faligndata(TMP2, TMP4, REF_S4);
1752

    
1753
        if (off != 0x7) {
1754
                vis_alignaddr_g0((void *)off_plus_1);
1755
                vis_faligndata(TMP0, TMP2, REF_S2);
1756
                vis_faligndata(TMP2, TMP4, REF_S6);
1757
        } else {
1758
                vis_src1(TMP2, REF_S2);
1759
                vis_src1(TMP4, REF_S6);
1760
        }
1761

    
1762
        height >>= 1;
1763
        do {    /* 55 cycles */
1764
                vis_ld64_2(ref, stride, TMP0);
1765
                vis_mul8x16au(REF_S0, CONST_256, TMP12);
1766
                vis_pmerge(ZERO,      REF_S0_1,  TMP14);
1767

    
1768
                vis_alignaddr_g0((void *)off);
1769

    
1770
                vis_ld64_2(ref, stride_8, TMP2);
1771
                vis_mul8x16au(REF_S2, CONST_256, TMP16);
1772
                vis_pmerge(ZERO,      REF_S2_1,  TMP18);
1773

    
1774
                vis_ld64_2(ref, stride_16, TMP4);
1775
                ref += stride;
1776
                vis_mul8x16au(REF_S4, CONST_256, TMP20);
1777
                vis_pmerge(ZERO,      REF_S4_1,  TMP22);
1778

    
1779
                vis_ld64_2(ref, stride, TMP6);
1780
                vis_mul8x16au(REF_S6, CONST_256, TMP24);
1781
                vis_pmerge(ZERO,      REF_S6_1,  TMP26);
1782

    
1783
                vis_ld64_2(ref, stride_8, TMP8);
1784
                vis_faligndata(TMP0, TMP2, REF_0);
1785

    
1786
                vis_ld64_2(ref, stride_16, TMP10);
1787
                ref += stride;
1788
                vis_faligndata(TMP2, TMP4, REF_4);
1789

    
1790
                vis_ld64(dest[0], DST_0);
1791
                vis_faligndata(TMP6, TMP8, REF_S0);
1792

    
1793
                vis_ld64_2(dest, 8, DST_2);
1794
                vis_faligndata(TMP8, TMP10, REF_S4);
1795

    
1796
                if (off != 0x7) {
1797
                        vis_alignaddr_g0((void *)off_plus_1);
1798
                        vis_faligndata(TMP0, TMP2, REF_2);
1799
                        vis_faligndata(TMP2, TMP4, REF_6);
1800
                        vis_faligndata(TMP6, TMP8, REF_S2);
1801
                        vis_faligndata(TMP8, TMP10, REF_S6);
1802
                } else {
1803
                        vis_src1(TMP2, REF_2);
1804
                        vis_src1(TMP4, REF_6);
1805
                        vis_src1(TMP8, REF_S2);
1806
                        vis_src1(TMP10, REF_S6);
1807
                }
1808

    
1809
                vis_mul8x16al(DST_0,   CONST_1024, TMP30);
1810
                vis_pmerge(ZERO, REF_0, TMP0);
1811

    
1812
                vis_mul8x16al(DST_1,   CONST_1024, TMP32);
1813
                vis_pmerge(ZERO,      REF_0_1,  TMP2);
1814

    
1815
                vis_mul8x16au(REF_2, CONST_256, TMP4);
1816
                vis_pmerge(ZERO,      REF_2_1,  TMP6);
1817

    
1818
                vis_mul8x16al(DST_2,   CONST_1024, REF_0);
1819
                vis_padd16(TMP0, CONST_6, TMP0);
1820

    
1821
                vis_mul8x16al(DST_3,   CONST_1024, REF_2);
1822
                vis_padd16(TMP2, CONST_6, TMP2);
1823

    
1824
                vis_padd16(TMP0, TMP4, TMP0);
1825
                vis_mul8x16au(REF_4, CONST_256, TMP4);
1826

    
1827
                vis_padd16(TMP2, TMP6, TMP2);
1828
                vis_mul8x16au(REF_4_1, CONST_256, TMP6);
1829

    
1830
                vis_padd16(TMP12, TMP0, TMP12);
1831
                vis_mul8x16au(REF_6, CONST_256, TMP8);
1832

    
1833
                vis_padd16(TMP14, TMP2, TMP14);
1834
                vis_mul8x16au(REF_6_1, CONST_256, TMP10);
1835

    
1836
                vis_padd16(TMP12, TMP16, TMP12);
1837
                vis_mul8x16au(REF_S0, CONST_256, REF_4);
1838

    
1839
                vis_padd16(TMP14, TMP18, TMP14);
1840
                vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
1841

    
1842
                vis_padd16(TMP12, TMP30, TMP12);
1843

    
1844
                vis_padd16(TMP14, TMP32, TMP14);
1845
                vis_pack16(TMP12, DST_0);
1846

    
1847
                vis_pack16(TMP14, DST_1);
1848
                vis_st64(DST_0, dest[0]);
1849
                vis_padd16(TMP4, CONST_6, TMP4);
1850

    
1851
                vis_ld64_2(dest, stride, DST_0);
1852
                vis_padd16(TMP6, CONST_6, TMP6);
1853
                vis_mul8x16au(REF_S2, CONST_256, TMP12);
1854

    
1855
                vis_padd16(TMP4, TMP8, TMP4);
1856
                vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);
1857

    
1858
                vis_padd16(TMP6, TMP10, TMP6);
1859

    
1860
                vis_padd16(TMP20, TMP4, TMP20);
1861

    
1862
                vis_padd16(TMP22, TMP6, TMP22);
1863

    
1864
                vis_padd16(TMP20, TMP24, TMP20);
1865

    
1866
                vis_padd16(TMP22, TMP26, TMP22);
1867

    
1868
                vis_padd16(TMP20, REF_0, TMP20);
1869
                vis_mul8x16au(REF_S4, CONST_256, REF_0);
1870

    
1871
                vis_padd16(TMP22, REF_2, TMP22);
1872
                vis_pack16(TMP20, DST_2);
1873

    
1874
                vis_pack16(TMP22, DST_3);
1875
                vis_st64_2(DST_2, dest, 8);
1876
                dest += stride;
1877

    
1878
                vis_ld64_2(dest, 8, DST_2);
1879
                vis_mul8x16al(DST_0,   CONST_1024, TMP30);
1880
                vis_pmerge(ZERO,      REF_S4_1,  REF_2);
1881

    
1882
                vis_mul8x16al(DST_1,   CONST_1024, TMP32);
1883
                vis_padd16(REF_4, TMP0, TMP8);
1884

    
1885
                vis_mul8x16au(REF_S6, CONST_256, REF_4);
1886
                vis_padd16(REF_6, TMP2, TMP10);
1887

    
1888
                vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
1889
                vis_padd16(TMP8, TMP12, TMP8);
1890

    
1891
                vis_padd16(TMP10, TMP14, TMP10);
1892

    
1893
                vis_padd16(TMP8, TMP30, TMP8);
1894

    
1895
                vis_padd16(TMP10, TMP32, TMP10);
1896
                vis_pack16(TMP8, DST_0);
1897

    
1898
                vis_pack16(TMP10, DST_1);
1899
                vis_st64(DST_0, dest[0]);
1900

    
1901
                vis_padd16(REF_0, TMP4, REF_0);
1902

    
1903
                vis_mul8x16al(DST_2,   CONST_1024, TMP30);
1904
                vis_padd16(REF_2, TMP6, REF_2);
1905

    
1906
                vis_mul8x16al(DST_3,   CONST_1024, TMP32);
1907
                vis_padd16(REF_0, REF_4, REF_0);
1908

    
1909
                vis_padd16(REF_2, REF_6, REF_2);
1910

    
1911
                vis_padd16(REF_0, TMP30, REF_0);
1912

    
1913
                /* stall */
1914

    
1915
                vis_padd16(REF_2, TMP32, REF_2);
1916
                vis_pack16(REF_0, DST_2);
1917

    
1918
                vis_pack16(REF_2, DST_3);
1919
                vis_st64_2(DST_2, dest, 8);
1920
                dest += stride;
1921
        } while (--height);
1922
}
1923

    
1924
static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
1925
                             const int stride, int height)
1926
{
1927
        uint8_t *ref = (uint8_t *) _ref;
1928
        unsigned long off = (unsigned long) ref & 0x7;
1929
        unsigned long off_plus_1 = off + 1;
1930
        int stride_8 = stride + 8;
1931

    
1932
        vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
1933

    
1934
        ref = vis_alignaddr(ref);
1935

    
1936
        vis_ld64(ref[0], TMP0);
1937
        vis_fzero(ZERO);
1938

    
1939
        vis_ld64_2(ref, 8, TMP2);
1940

    
1941
        vis_ld64(constants6[0], CONST_6);
1942

    
1943
        vis_ld64(constants256_1024[0], CONST_256);
1944
        vis_faligndata(TMP0, TMP2, REF_S0);
1945

    
1946
        if (off != 0x7) {
1947
                vis_alignaddr_g0((void *)off_plus_1);
1948
                vis_faligndata(TMP0, TMP2, REF_S2);
1949
        } else {
1950
                vis_src1(TMP2, REF_S2);
1951
        }
1952

    
1953
        height >>= 1;
1954
        do {    /* 31 cycles */
1955
                vis_ld64_2(ref, stride, TMP0);
1956
                vis_mul8x16au(REF_S0, CONST_256, TMP8);
1957
                vis_pmerge(ZERO,      REF_S0_1,  TMP10);
1958

    
1959
                vis_ld64_2(ref, stride_8, TMP2);
1960
                ref += stride;
1961
                vis_mul8x16au(REF_S2, CONST_256, TMP12);
1962
                vis_pmerge(ZERO,      REF_S2_1,  TMP14);
1963

    
1964
                vis_alignaddr_g0((void *)off);
1965

    
1966
                vis_ld64_2(ref, stride, TMP4);
1967
                vis_faligndata(TMP0, TMP2, REF_S4);
1968

    
1969
                vis_ld64_2(ref, stride_8, TMP6);
1970
                ref += stride;
1971

    
1972
                vis_ld64(dest[0], DST_0);
1973
                vis_faligndata(TMP4, TMP6, REF_S0);
1974

    
1975
                vis_ld64_2(dest, stride, DST_2);
1976

    
1977
                if (off != 0x7) {
1978
                        vis_alignaddr_g0((void *)off_plus_1);
1979
                        vis_faligndata(TMP0, TMP2, REF_S6);
1980
                        vis_faligndata(TMP4, TMP6, REF_S2);
1981
                } else {
1982
                        vis_src1(TMP2, REF_S6);
1983
                        vis_src1(TMP6, REF_S2);
1984
                }
1985

    
1986
                vis_mul8x16al(DST_0,   CONST_1024, TMP30);
1987
                vis_pmerge(ZERO, REF_S4, TMP22);
1988

    
1989
                vis_mul8x16al(DST_1,   CONST_1024, TMP32);
1990
                vis_pmerge(ZERO,      REF_S4_1,  TMP24);
1991

    
1992
                vis_mul8x16au(REF_S6, CONST_256, TMP26);
1993
                vis_pmerge(ZERO,      REF_S6_1,  TMP28);
1994

    
1995
                vis_mul8x16au(REF_S0, CONST_256, REF_S4);
1996
                vis_padd16(TMP22, CONST_6, TMP22);
1997

    
1998
                vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
1999
                vis_padd16(TMP24, CONST_6, TMP24);
2000

    
2001
                vis_mul8x16al(DST_2,   CONST_1024, REF_0);
2002
                vis_padd16(TMP22, TMP26, TMP22);
2003

    
2004
                vis_mul8x16al(DST_3,   CONST_1024, REF_2);
2005
                vis_padd16(TMP24, TMP28, TMP24);
2006

    
2007
                vis_mul8x16au(REF_S2, CONST_256, TMP26);
2008
                vis_padd16(TMP8, TMP22, TMP8);
2009

    
2010
                vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
2011
                vis_padd16(TMP10, TMP24, TMP10);
2012

    
2013
                vis_padd16(TMP8, TMP12, TMP8);
2014

    
2015
                vis_padd16(TMP10, TMP14, TMP10);
2016

    
2017
                vis_padd16(TMP8, TMP30, TMP8);
2018

    
2019
                vis_padd16(TMP10, TMP32, TMP10);
2020
                vis_pack16(TMP8, DST_0);
2021

    
2022
                vis_pack16(TMP10, DST_1);
2023
                vis_st64(DST_0, dest[0]);
2024
                dest += stride;
2025

    
2026
                vis_padd16(REF_S4, TMP22, TMP12);
2027

    
2028
                vis_padd16(REF_S6, TMP24, TMP14);
2029

    
2030
                vis_padd16(TMP12, TMP26, TMP12);
2031

    
2032
                vis_padd16(TMP14, TMP28, TMP14);
2033

    
2034
                vis_padd16(TMP12, REF_0, TMP12);
2035

    
2036
                vis_padd16(TMP14, REF_2, TMP14);
2037
                vis_pack16(TMP12, DST_2);
2038

    
2039
                vis_pack16(TMP14, DST_3);
2040
                vis_st64(DST_2, dest[0]);
2041
                dest += stride;
2042
        } while (--height);
2043
}
2044

    
2045
/* End of rounding code */
2046

    
2047
/* Start of no rounding code */
2048
/* The trick used in some of this file is the formula from the MMX
2049
 * motion comp code, which is:
2050
 *
2051
 * (x+y)>>1 == (x&y)+((x^y)>>1)
2052
 *
2053
 * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
2054
 * We avoid overflows by masking before we do the shift, and we
2055
 * implement the shift by multiplying by 1/2 using mul8x16.  So in
2056
 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
2057
 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
2058
 * the value 0x80808080 is in f8):
2059
 *
2060
 *      fxor            f0,   f2, f10
2061
 *      fand            f10,  f4, f10
2062
 *      fmul8x16        f8,  f10, f10
2063
 *      fand            f10,  f6, f10
2064
 *      fand            f0,   f2, f12
2065
 *      fpadd16         f12, f10, f10
2066
 */
2067

    
2068
static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * _ref,
2069
                                      const int stride, int height)
2070
{
2071
        uint8_t *ref = (uint8_t *) _ref;
2072

    
2073
        ref = vis_alignaddr(ref);
2074
        do {    /* 5 cycles */
2075
                vis_ld64(ref[0], TMP0);
2076

    
2077
                vis_ld64_2(ref, 8, TMP2);
2078

    
2079
                vis_ld64_2(ref, 16, TMP4);
2080
                ref += stride;
2081

    
2082
                vis_faligndata(TMP0, TMP2, REF_0);
2083
                vis_st64(REF_0, dest[0]);
2084

    
2085
                vis_faligndata(TMP2, TMP4, REF_2);
2086
                vis_st64_2(REF_2, dest, 8);
2087
                dest += stride;
2088
        } while (--height);
2089
}
2090

    
2091
static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * _ref,
2092
                            const int stride, int height)
2093
{
2094
        uint8_t *ref = (uint8_t *) _ref;
2095

    
2096
        ref = vis_alignaddr(ref);
2097
        do {    /* 4 cycles */
2098
                vis_ld64(ref[0], TMP0);
2099

    
2100
                vis_ld64(ref[8], TMP2);
2101
                ref += stride;
2102

    
2103
                /* stall */
2104

    
2105
                vis_faligndata(TMP0, TMP2, REF_0);
2106
                vis_st64(REF_0, dest[0]);
2107
                dest += stride;
2108
        } while (--height);
2109
}
2110

    
2111

    
2112
static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * _ref,
2113
                             const int stride, int height)
2114
{
2115
        uint8_t *ref = (uint8_t *) _ref;
2116
        int stride_8 = stride + 8;
2117

    
2118
        ref = vis_alignaddr(ref);
2119

    
2120
        vis_ld64(ref[0], TMP0);
2121

    
2122
        vis_ld64(ref[8], TMP2);
2123

    
2124
        vis_ld64(ref[16], TMP4);
2125

    
2126
        vis_ld64(dest[0], DST_0);
2127

    
2128
        vis_ld64(dest[8], DST_2);
2129

    
2130
        vis_ld64(constants_fe[0], MASK_fe);
2131
        vis_faligndata(TMP0, TMP2, REF_0);
2132

    
2133
        vis_ld64(constants_7f[0], MASK_7f);
2134
        vis_faligndata(TMP2, TMP4, REF_2);
2135

    
2136
        vis_ld64(constants128[0], CONST_128);
2137

    
2138
        ref += stride;
2139
        height = (height >> 1) - 1;
2140

    
2141
        do {    /* 24 cycles */
2142
                vis_ld64(ref[0], TMP0);
2143
                vis_xor(DST_0, REF_0, TMP6);
2144

    
2145
                vis_ld64_2(ref, 8, TMP2);
2146
                vis_and(TMP6, MASK_fe, TMP6);
2147

    
2148
                vis_ld64_2(ref, 16, TMP4);
2149
                ref += stride;
2150
                vis_mul8x16(CONST_128, TMP6, TMP6);
2151
                vis_xor(DST_2, REF_2, TMP8);
2152

    
2153
                vis_and(TMP8, MASK_fe, TMP8);
2154

    
2155
                vis_and(DST_0, REF_0, TMP10);
2156
                vis_ld64_2(dest, stride, DST_0);
2157
                vis_mul8x16(CONST_128, TMP8, TMP8);
2158

    
2159
                vis_and(DST_2, REF_2, TMP12);
2160
                vis_ld64_2(dest, stride_8, DST_2);
2161

    
2162
                vis_ld64(ref[0], TMP14);
2163
                vis_and(TMP6, MASK_7f, TMP6);
2164

    
2165
                vis_and(TMP8, MASK_7f, TMP8);
2166

    
2167
                vis_padd16(TMP10, TMP6, TMP6);
2168
                vis_st64(TMP6, dest[0]);
2169

    
2170
                vis_padd16(TMP12, TMP8, TMP8);
2171
                vis_st64_2(TMP8, dest, 8);
2172

    
2173
                dest += stride;
2174
                vis_ld64_2(ref, 8, TMP16);
2175
                vis_faligndata(TMP0, TMP2, REF_0);
2176

    
2177
                vis_ld64_2(ref, 16, TMP18);
2178
                vis_faligndata(TMP2, TMP4, REF_2);
2179
                ref += stride;
2180

    
2181
                vis_xor(DST_0, REF_0, TMP20);
2182

    
2183
                vis_and(TMP20, MASK_fe, TMP20);
2184

    
2185
                vis_xor(DST_2, REF_2, TMP22);
2186
                vis_mul8x16(CONST_128, TMP20, TMP20);
2187

    
2188
                vis_and(TMP22, MASK_fe, TMP22);
2189

    
2190
                vis_and(DST_0, REF_0, TMP24);
2191
                vis_mul8x16(CONST_128, TMP22, TMP22);
2192

    
2193
                vis_and(DST_2, REF_2, TMP26);
2194

    
2195
                vis_ld64_2(dest, stride, DST_0);
2196
                vis_faligndata(TMP14, TMP16, REF_0);
2197

    
2198
                vis_ld64_2(dest, stride_8, DST_2);
2199
                vis_faligndata(TMP16, TMP18, REF_2);
2200

    
2201
                vis_and(TMP20, MASK_7f, TMP20);
2202

    
2203
                vis_and(TMP22, MASK_7f, TMP22);
2204

    
2205
                vis_padd16(TMP24, TMP20, TMP20);
2206
                vis_st64(TMP20, dest[0]);
2207

    
2208
                vis_padd16(TMP26, TMP22, TMP22);
2209
                vis_st64_2(TMP22, dest, 8);
2210
                dest += stride;
2211
        } while (--height);
2212

    
2213
        vis_ld64(ref[0], TMP0);
2214
        vis_xor(DST_0, REF_0, TMP6);
2215

    
2216
        vis_ld64_2(ref, 8, TMP2);
2217
        vis_and(TMP6, MASK_fe, TMP6);
2218

    
2219
        vis_ld64_2(ref, 16, TMP4);
2220
        vis_mul8x16(CONST_128, TMP6, TMP6);
2221
        vis_xor(DST_2, REF_2, TMP8);
2222

    
2223
        vis_and(TMP8, MASK_fe, TMP8);
2224

    
2225
        vis_and(DST_0, REF_0, TMP10);
2226
        vis_ld64_2(dest, stride, DST_0);
2227
        vis_mul8x16(CONST_128, TMP8, TMP8);
2228

    
2229
        vis_and(DST_2, REF_2, TMP12);
2230
        vis_ld64_2(dest, stride_8, DST_2);
2231

    
2232
        vis_ld64(ref[0], TMP14);
2233
        vis_and(TMP6, MASK_7f, TMP6);
2234

    
2235
        vis_and(TMP8, MASK_7f, TMP8);
2236

    
2237
        vis_padd16(TMP10, TMP6, TMP6);
2238
        vis_st64(TMP6, dest[0]);
2239

    
2240
        vis_padd16(TMP12, TMP8, TMP8);
2241
        vis_st64_2(TMP8, dest, 8);
2242

    
2243
        dest += stride;
2244
        vis_faligndata(TMP0, TMP2, REF_0);
2245

    
2246
        vis_faligndata(TMP2, TMP4, REF_2);
2247

    
2248
        vis_xor(DST_0, REF_0, TMP20);
2249

    
2250
        vis_and(TMP20, MASK_fe, TMP20);
2251

    
2252
        vis_xor(DST_2, REF_2, TMP22);
2253
        vis_mul8x16(CONST_128, TMP20, TMP20);
2254

    
2255
        vis_and(TMP22, MASK_fe, TMP22);
2256

    
2257
        vis_and(DST_0, REF_0, TMP24);
2258
        vis_mul8x16(CONST_128, TMP22, TMP22);
2259

    
2260
        vis_and(DST_2, REF_2, TMP26);
2261

    
2262
        vis_and(TMP20, MASK_7f, TMP20);
2263

    
2264
        vis_and(TMP22, MASK_7f, TMP22);
2265

    
2266
        vis_padd16(TMP24, TMP20, TMP20);
2267
        vis_st64(TMP20, dest[0]);
2268

    
2269
        vis_padd16(TMP26, TMP22, TMP22);
2270
        vis_st64_2(TMP22, dest, 8);
2271
}
2272

    
2273
static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * _ref,
2274
                            const int stride, int height)
2275
{
2276
        uint8_t *ref = (uint8_t *) _ref;
2277

    
2278
        ref = vis_alignaddr(ref);
2279

    
2280
        vis_ld64(ref[0], TMP0);
2281

    
2282
        vis_ld64(ref[8], TMP2);
2283

    
2284
        vis_ld64(dest[0], DST_0);
2285

    
2286
        vis_ld64(constants_fe[0], MASK_fe);
2287

    
2288
        vis_ld64(constants_7f[0], MASK_7f);
2289
        vis_faligndata(TMP0, TMP2, REF_0);
2290

    
2291
        vis_ld64(constants128[0], CONST_128);
2292

    
2293
        ref += stride;
2294
        height = (height >> 1) - 1;
2295

    
2296
        do {    /* 12 cycles */
2297
                vis_ld64(ref[0], TMP0);
2298
                vis_xor(DST_0, REF_0, TMP4);
2299

    
2300
                vis_ld64(ref[8], TMP2);
2301
                vis_and(TMP4, MASK_fe, TMP4);
2302

    
2303
                vis_and(DST_0, REF_0, TMP6);
2304
                vis_ld64_2(dest, stride, DST_0);
2305
                ref += stride;
2306
                vis_mul8x16(CONST_128, TMP4, TMP4);
2307

    
2308
                vis_ld64(ref[0], TMP12);
2309
                vis_faligndata(TMP0, TMP2, REF_0);
2310

    
2311
                vis_ld64(ref[8], TMP2);
2312
                vis_xor(DST_0, REF_0, TMP0);
2313
                ref += stride;
2314

    
2315
                vis_and(TMP0, MASK_fe, TMP0);
2316

    
2317
                vis_and(TMP4, MASK_7f, TMP4);
2318

    
2319
                vis_padd16(TMP6, TMP4, TMP4);
2320
                vis_st64(TMP4, dest[0]);
2321
                dest += stride;
2322
                vis_mul8x16(CONST_128, TMP0, TMP0);
2323

    
2324
                vis_and(DST_0, REF_0, TMP6);
2325
                vis_ld64_2(dest, stride, DST_0);
2326

    
2327
                vis_faligndata(TMP12, TMP2, REF_0);
2328

    
2329
                vis_and(TMP0, MASK_7f, TMP0);
2330

    
2331
                vis_padd16(TMP6, TMP0, TMP4);
2332
                vis_st64(TMP4, dest[0]);
2333
                dest += stride;
2334
        } while (--height);
2335

    
2336
        vis_ld64(ref[0], TMP0);
2337
        vis_xor(DST_0, REF_0, TMP4);
2338

    
2339
        vis_ld64(ref[8], TMP2);
2340
        vis_and(TMP4, MASK_fe, TMP4);
2341

    
2342
        vis_and(DST_0, REF_0, TMP6);
2343
        vis_ld64_2(dest, stride, DST_0);
2344
        vis_mul8x16(CONST_128, TMP4, TMP4);
2345

    
2346
        vis_faligndata(TMP0, TMP2, REF_0);
2347

    
2348
        vis_xor(DST_0, REF_0, TMP0);
2349

    
2350
        vis_and(TMP0, MASK_fe, TMP0);
2351

    
2352
        vis_and(TMP4, MASK_7f, TMP4);
2353

    
2354
        vis_padd16(TMP6, TMP4, TMP4);
2355
        vis_st64(TMP4, dest[0]);
2356
        dest += stride;
2357
        vis_mul8x16(CONST_128, TMP0, TMP0);
2358

    
2359
        vis_and(DST_0, REF_0, TMP6);
2360

    
2361
        vis_and(TMP0, MASK_7f, TMP0);
2362

    
2363
        vis_padd16(TMP6, TMP0, TMP4);
2364
        vis_st64(TMP4, dest[0]);
2365
}
2366

    
2367
static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * _ref,
2368
                             const int stride, int height)
2369
{
2370
        uint8_t *ref = (uint8_t *) _ref;
2371
        unsigned long off = (unsigned long) ref & 0x7;
2372
        unsigned long off_plus_1 = off + 1;
2373

    
2374
        ref = vis_alignaddr(ref);
2375

    
2376
        vis_ld64(ref[0],    TMP0);
2377

    
2378
        vis_ld64_2(ref, 8,  TMP2);
2379

    
2380
        vis_ld64_2(ref, 16, TMP4);
2381

    
2382
        vis_ld64(constants_fe[0], MASK_fe);
2383

    
2384
        vis_ld64(constants_7f[0], MASK_7f);
2385
        vis_faligndata(TMP0, TMP2, REF_0);
2386

    
2387
        vis_ld64(constants128[0], CONST_128);
2388
        vis_faligndata(TMP2, TMP4, REF_4);
2389

    
2390
        if (off != 0x7) {
2391
                vis_alignaddr_g0((void *)off_plus_1);
2392
                vis_faligndata(TMP0, TMP2, REF_2);
2393
                vis_faligndata(TMP2, TMP4, REF_6);
2394
        } else {
2395
                vis_src1(TMP2, REF_2);
2396
                vis_src1(TMP4, REF_6);
2397
        }
2398

    
2399
        ref += stride;
2400
        height = (height >> 1) - 1;
2401

    
2402
        do {    /* 34 cycles */
2403
                vis_ld64(ref[0],    TMP0);
2404
                vis_xor(REF_0, REF_2, TMP6);
2405

    
2406
                vis_ld64_2(ref, 8,  TMP2);
2407
                vis_xor(REF_4, REF_6, TMP8);
2408

    
2409
                vis_ld64_2(ref, 16, TMP4);
2410
                vis_and(TMP6, MASK_fe, TMP6);
2411
                ref += stride;
2412

    
2413
                vis_ld64(ref[0],    TMP14);
2414
                vis_mul8x16(CONST_128, TMP6, TMP6);
2415
                vis_and(TMP8, MASK_fe, TMP8);
2416

    
2417
                vis_ld64_2(ref, 8,  TMP16);
2418
                vis_mul8x16(CONST_128, TMP8, TMP8);
2419
                vis_and(REF_0, REF_2, TMP10);
2420

    
2421
                vis_ld64_2(ref, 16, TMP18);
2422
                ref += stride;
2423
                vis_and(REF_4, REF_6, TMP12);
2424

    
2425
                vis_alignaddr_g0((void *)off);
2426

    
2427
                vis_faligndata(TMP0, TMP2, REF_0);
2428

    
2429
                vis_faligndata(TMP2, TMP4, REF_4);
2430

    
2431
                if (off != 0x7) {
2432
                        vis_alignaddr_g0((void *)off_plus_1);
2433
                        vis_faligndata(TMP0, TMP2, REF_2);
2434
                        vis_faligndata(TMP2, TMP4, REF_6);
2435
                } else {
2436
                        vis_src1(TMP2, REF_2);
2437
                        vis_src1(TMP4, REF_6);
2438
                }
2439

    
2440
                vis_and(TMP6, MASK_7f, TMP6);
2441

    
2442
                vis_and(TMP8, MASK_7f, TMP8);
2443

    
2444
                vis_padd16(TMP10, TMP6, TMP6);
2445
                vis_st64(TMP6, dest[0]);
2446

    
2447
                vis_padd16(TMP12, TMP8, TMP8);
2448
                vis_st64_2(TMP8, dest, 8);
2449
                dest += stride;
2450

    
2451
                vis_xor(REF_0, REF_2, TMP6);
2452

    
2453
                vis_xor(REF_4, REF_6, TMP8);
2454

    
2455
                vis_and(TMP6, MASK_fe, TMP6);
2456

    
2457
                vis_mul8x16(CONST_128, TMP6, TMP6);
2458
                vis_and(TMP8, MASK_fe, TMP8);
2459

    
2460
                vis_mul8x16(CONST_128, TMP8, TMP8);
2461
                vis_and(REF_0, REF_2, TMP10);
2462

    
2463
                vis_and(REF_4, REF_6, TMP12);
2464

    
2465
                vis_alignaddr_g0((void *)off);
2466

    
2467
                vis_faligndata(TMP14, TMP16, REF_0);
2468

    
2469
                vis_faligndata(TMP16, TMP18, REF_4);
2470

    
2471
                if (off != 0x7) {
2472
                        vis_alignaddr_g0((void *)off_plus_1);
2473
                        vis_faligndata(TMP14, TMP16, REF_2);
2474
                        vis_faligndata(TMP16, TMP18, REF_6);
2475
                } else {
2476
                        vis_src1(TMP16, REF_2);
2477
                        vis_src1(TMP18, REF_6);
2478
                }
2479

    
2480
                vis_and(TMP6, MASK_7f, TMP6);
2481

    
2482
                vis_and(TMP8, MASK_7f, TMP8);
2483

    
2484
                vis_padd16(TMP10, TMP6, TMP6);
2485
                vis_st64(TMP6, dest[0]);
2486

    
2487
                vis_padd16(TMP12, TMP8, TMP8);
2488
                vis_st64_2(TMP8, dest, 8);
2489
                dest += stride;
2490
        } while (--height);
2491

    
2492
        vis_ld64(ref[0],    TMP0);
2493
        vis_xor(REF_0, REF_2, TMP6);
2494

    
2495
        vis_ld64_2(ref, 8,  TMP2);
2496
        vis_xor(REF_4, REF_6, TMP8);
2497

    
2498
        vis_ld64_2(ref, 16, TMP4);
2499
        vis_and(TMP6, MASK_fe, TMP6);
2500

    
2501
        vis_mul8x16(CONST_128, TMP6, TMP6);
2502
        vis_and(TMP8, MASK_fe, TMP8);
2503

    
2504
        vis_mul8x16(CONST_128, TMP8, TMP8);
2505
        vis_and(REF_0, REF_2, TMP10);
2506

    
2507
        vis_and(REF_4, REF_6, TMP12);
2508

    
2509
        vis_alignaddr_g0((void *)off);
2510

    
2511
        vis_faligndata(TMP0, TMP2, REF_0);
2512

    
2513
        vis_faligndata(TMP2, TMP4, REF_4);
2514

    
2515
        if (off != 0x7) {
2516
                vis_alignaddr_g0((void *)off_plus_1);
2517
                vis_faligndata(TMP0, TMP2, REF_2);
2518
                vis_faligndata(TMP2, TMP4, REF_6);
2519
        } else {
2520
                vis_src1(TMP2, REF_2);
2521
                vis_src1(TMP4, REF_6);
2522
        }
2523

    
2524
        vis_and(TMP6, MASK_7f, TMP6);
2525

    
2526
        vis_and(TMP8, MASK_7f, TMP8);
2527

    
2528
        vis_padd16(TMP10, TMP6, TMP6);
2529
        vis_st64(TMP6, dest[0]);
2530

    
2531
        vis_padd16(TMP12, TMP8, TMP8);
2532
        vis_st64_2(TMP8, dest, 8);
2533
        dest += stride;
2534

    
2535
        vis_xor(REF_0, REF_2, TMP6);
2536

    
2537
        vis_xor(REF_4, REF_6, TMP8);
2538

    
2539
        vis_and(TMP6, MASK_fe, TMP6);
2540

    
2541
        vis_mul8x16(CONST_128, TMP6, TMP6);
2542
        vis_and(TMP8, MASK_fe, TMP8);
2543

    
2544
        vis_mul8x16(CONST_128, TMP8, TMP8);
2545
        vis_and(REF_0, REF_2, TMP10);
2546

    
2547
        vis_and(REF_4, REF_6, TMP12);
2548

    
2549
        vis_and(TMP6, MASK_7f, TMP6);
2550

    
2551
        vis_and(TMP8, MASK_7f, TMP8);
2552

    
2553
        vis_padd16(TMP10, TMP6, TMP6);
2554
        vis_st64(TMP6, dest[0]);
2555

    
2556
        vis_padd16(TMP12, TMP8, TMP8);
2557
        vis_st64_2(TMP8, dest, 8);
2558
}
2559

    
2560
static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * _ref,
2561
                            const int stride, int height)
2562
{
2563
        uint8_t *ref = (uint8_t *) _ref;
2564
        unsigned long off = (unsigned long) ref & 0x7;
2565
        unsigned long off_plus_1 = off + 1;
2566

    
2567
        ref = vis_alignaddr(ref);
2568

    
2569
        vis_ld64(ref[0], TMP0);
2570

    
2571
        vis_ld64(ref[8], TMP2);
2572

    
2573
        vis_ld64(constants_fe[0], MASK_fe);
2574

    
2575
        vis_ld64(constants_7f[0], MASK_7f);
2576

    
2577
        vis_ld64(constants128[0], CONST_128);
2578
        vis_faligndata(TMP0, TMP2, REF_0);
2579

    
2580
        if (off != 0x7) {
2581
                vis_alignaddr_g0((void *)off_plus_1);
2582
                vis_faligndata(TMP0, TMP2, REF_2);
2583
        } else {
2584
                vis_src1(TMP2, REF_2);
2585
        }
2586

    
2587
        ref += stride;
2588
        height = (height >> 1) - 1;
2589

    
2590
        do {    /* 20 cycles */
2591
                vis_ld64(ref[0], TMP0);
2592
                vis_xor(REF_0, REF_2, TMP4);
2593

    
2594
                vis_ld64_2(ref, 8, TMP2);
2595
                vis_and(TMP4, MASK_fe, TMP4);
2596
                ref += stride;
2597

    
2598
                vis_ld64(ref[0], TMP8);
2599
                vis_and(REF_0, REF_2, TMP6);
2600
                vis_mul8x16(CONST_128, TMP4, TMP4);
2601

    
2602
                vis_alignaddr_g0((void *)off);
2603

    
2604
                vis_ld64_2(ref, 8, TMP10);
2605
                ref += stride;
2606
                vis_faligndata(TMP0, TMP2, REF_0);
2607

    
2608
                if (off != 0x7) {
2609
                        vis_alignaddr_g0((void *)off_plus_1);
2610
                        vis_faligndata(TMP0, TMP2, REF_2);
2611
                } else {
2612
                        vis_src1(TMP2, REF_2);
2613
                }
2614

    
2615
                vis_and(TMP4, MASK_7f, TMP4);
2616

    
2617
                vis_padd16(TMP6, TMP4, DST_0);
2618
                vis_st64(DST_0, dest[0]);
2619
                dest += stride;
2620

    
2621
                vis_xor(REF_0, REF_2, TMP12);
2622

    
2623
                vis_and(TMP12, MASK_fe, TMP12);
2624

    
2625
                vis_and(REF_0, REF_2, TMP14);
2626
                vis_mul8x16(CONST_128, TMP12, TMP12);
2627

    
2628
                vis_alignaddr_g0((void *)off);
2629
                vis_faligndata(TMP8, TMP10, REF_0);
2630
                if (off != 0x7) {
2631
                        vis_alignaddr_g0((void *)off_plus_1);
2632
                        vis_faligndata(TMP8, TMP10, REF_2);
2633
                } else {
2634
                        vis_src1(TMP10, REF_2);
2635
                }
2636

    
2637
                vis_and(TMP12, MASK_7f, TMP12);
2638

    
2639
                vis_padd16(TMP14, TMP12, DST_0);
2640
                vis_st64(DST_0, dest[0]);
2641
                dest += stride;
2642
        } while (--height);
2643

    
2644
        vis_ld64(ref[0], TMP0);
2645
        vis_xor(REF_0, REF_2, TMP4);
2646

    
2647
        vis_ld64_2(ref, 8, TMP2);
2648
        vis_and(TMP4, MASK_fe, TMP4);
2649

    
2650
        vis_and(REF_0, REF_2, TMP6);
2651
        vis_mul8x16(CONST_128, TMP4, TMP4);
2652

    
2653
        vis_alignaddr_g0((void *)off);
2654

    
2655
        vis_faligndata(TMP0, TMP2, REF_0);
2656

    
2657
        if (off != 0x7) {
2658
                vis_alignaddr_g0((void *)off_plus_1);
2659
                vis_faligndata(TMP0, TMP2, REF_2);
2660
        } else {
2661
                vis_src1(TMP2, REF_2);
2662
        }
2663

    
2664
        vis_and(TMP4, MASK_7f, TMP4);
2665

    
2666
        vis_padd16(TMP6, TMP4, DST_0);
2667
        vis_st64(DST_0, dest[0]);
2668
        dest += stride;
2669

    
2670
        vis_xor(REF_0, REF_2, TMP12);
2671

    
2672
        vis_and(TMP12, MASK_fe, TMP12);
2673

    
2674
        vis_and(REF_0, REF_2, TMP14);
2675
        vis_mul8x16(CONST_128, TMP12, TMP12);
2676

    
2677
        vis_and(TMP12, MASK_7f, TMP12);
2678

    
2679
        vis_padd16(TMP14, TMP12, DST_0);
2680
        vis_st64(DST_0, dest[0]);
2681
        dest += stride;
2682
}
2683

    
2684
static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * _ref,
2685
                             const int stride, int height)
2686
{
2687
        uint8_t *ref = (uint8_t *) _ref;
2688
        unsigned long off = (unsigned long) ref & 0x7;
2689
        unsigned long off_plus_1 = off + 1;
2690

    
2691
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
2692

    
2693
        vis_ld64(constants3[0], CONST_3);
2694
        vis_fzero(ZERO);
2695
        vis_ld64(constants256_512[0], CONST_256);
2696

    
2697
        ref = vis_alignaddr(ref);
2698
        do {    /* 26 cycles */
2699
                vis_ld64(ref[0], TMP0);
2700

    
2701
                vis_ld64(ref[8], TMP2);
2702

    
2703
                vis_alignaddr_g0((void *)off);
2704

    
2705
                vis_ld64(ref[16], TMP4);
2706

    
2707
                vis_ld64(dest[0], DST_0);
2708
                vis_faligndata(TMP0, TMP2, REF_0);
2709

    
2710
                vis_ld64(dest[8], DST_2);
2711
                vis_faligndata(TMP2, TMP4, REF_4);
2712

    
2713
                if (off != 0x7) {
2714
                        vis_alignaddr_g0((void *)off_plus_1);
2715
                        vis_faligndata(TMP0, TMP2, REF_2);
2716
                        vis_faligndata(TMP2, TMP4, REF_6);
2717
                } else {
2718
                        vis_src1(TMP2, REF_2);
2719
                        vis_src1(TMP4, REF_6);
2720
                }
2721

    
2722
                vis_mul8x16au(REF_0,   CONST_256, TMP0);
2723

    
2724
                vis_pmerge(ZERO,     REF_2,     TMP4);
2725
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);
2726

    
2727
                vis_pmerge(ZERO, REF_2_1, TMP6);
2728

    
2729
                vis_padd16(TMP0, TMP4, TMP0);
2730

    
2731
                vis_mul8x16al(DST_0,   CONST_512, TMP4);
2732
                vis_padd16(TMP2, TMP6, TMP2);
2733

    
2734
                vis_mul8x16al(DST_1,   CONST_512, TMP6);
2735

    
2736
                vis_mul8x16au(REF_6,   CONST_256, TMP12);
2737

    
2738
                vis_padd16(TMP0, TMP4, TMP0);
2739
                vis_mul8x16au(REF_6_1, CONST_256, TMP14);
2740

    
2741
                vis_padd16(TMP2, TMP6, TMP2);
2742
                vis_mul8x16au(REF_4,   CONST_256, TMP16);
2743

    
2744
                vis_padd16(TMP0, CONST_3, TMP8);
2745
                vis_mul8x16au(REF_4_1, CONST_256, TMP18);
2746

    
2747
                vis_padd16(TMP2, CONST_3, TMP10);
2748
                vis_pack16(TMP8, DST_0);
2749

    
2750
                vis_pack16(TMP10, DST_1);
2751
                vis_padd16(TMP16, TMP12, TMP0);
2752

    
2753
                vis_st64(DST_0, dest[0]);
2754
                vis_mul8x16al(DST_2,   CONST_512, TMP4);
2755
                vis_padd16(TMP18, TMP14, TMP2);
2756

    
2757
                vis_mul8x16al(DST_3,   CONST_512, TMP6);
2758
                vis_padd16(TMP0, CONST_3, TMP0);
2759

    
2760
                vis_padd16(TMP2, CONST_3, TMP2);
2761

    
2762
                vis_padd16(TMP0, TMP4, TMP0);
2763

    
2764
                vis_padd16(TMP2, TMP6, TMP2);
2765
                vis_pack16(TMP0, DST_2);
2766

    
2767
                vis_pack16(TMP2, DST_3);
2768
                vis_st64(DST_2, dest[8]);
2769

    
2770
                ref += stride;
2771
                dest += stride;
2772
        } while (--height);
2773
}
2774

    
2775
static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * _ref,
2776
                            const int stride, int height)
2777
{
2778
        uint8_t *ref = (uint8_t *) _ref;
2779
        unsigned long off = (unsigned long) ref & 0x7;
2780
        unsigned long off_plus_1 = off + 1;
2781
        int stride_times_2 = stride << 1;
2782

    
2783
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
2784

    
2785
        vis_ld64(constants3[0], CONST_3);
2786
        vis_fzero(ZERO);
2787
        vis_ld64(constants256_512[0], CONST_256);
2788

    
2789
        ref = vis_alignaddr(ref);
2790
        height >>= 2;
2791
        do {    /* 47 cycles */
2792
                vis_ld64(ref[0],   TMP0);
2793

    
2794
                vis_ld64_2(ref, 8, TMP2);
2795
                ref += stride;
2796

    
2797
                vis_alignaddr_g0((void *)off);
2798

    
2799
                vis_ld64(ref[0],   TMP4);
2800
                vis_faligndata(TMP0, TMP2, REF_0);
2801

    
2802
                vis_ld64_2(ref, 8, TMP6);
2803
                ref += stride;
2804

    
2805
                vis_ld64(ref[0],   TMP8);
2806

    
2807
                vis_ld64_2(ref, 8, TMP10);
2808
                ref += stride;
2809
                vis_faligndata(TMP4, TMP6, REF_4);
2810

    
2811
                vis_ld64(ref[0],   TMP12);
2812

    
2813
                vis_ld64_2(ref, 8, TMP14);
2814
                ref += stride;
2815
                vis_faligndata(TMP8, TMP10, REF_S0);
2816

    
2817
                vis_faligndata(TMP12, TMP14, REF_S4);
2818

    
2819
                if (off != 0x7) {
2820
                        vis_alignaddr_g0((void *)off_plus_1);
2821

    
2822
                        vis_ld64(dest[0], DST_0);
2823
                        vis_faligndata(TMP0, TMP2, REF_2);
2824

    
2825
                        vis_ld64_2(dest, stride, DST_2);
2826
                        vis_faligndata(TMP4, TMP6, REF_6);
2827

    
2828
                        vis_faligndata(TMP8, TMP10, REF_S2);
2829

    
2830
                        vis_faligndata(TMP12, TMP14, REF_S6);
2831
                } else {
2832
                        vis_ld64(dest[0], DST_0);
2833
                        vis_src1(TMP2, REF_2);
2834

    
2835
                        vis_ld64_2(dest, stride, DST_2);
2836
                        vis_src1(TMP6, REF_6);
2837

    
2838
                        vis_src1(TMP10, REF_S2);
2839

    
2840
                        vis_src1(TMP14, REF_S6);
2841
                }
2842

    
2843
                vis_pmerge(ZERO,     REF_0,     TMP0);
2844
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);
2845

    
2846
                vis_pmerge(ZERO,     REF_2,     TMP4);
2847
                vis_mul8x16au(REF_2_1, CONST_256, TMP6);
2848

    
2849
                vis_padd16(TMP0, CONST_3, TMP0);
2850
                vis_mul8x16al(DST_0,   CONST_512, TMP16);
2851

    
2852
                vis_padd16(TMP2, CONST_3, TMP2);
2853
                vis_mul8x16al(DST_1,   CONST_512, TMP18);
2854

    
2855
                vis_padd16(TMP0, TMP4, TMP0);
2856
                vis_mul8x16au(REF_4, CONST_256, TMP8);
2857

    
2858
                vis_padd16(TMP2, TMP6, TMP2);
2859
                vis_mul8x16au(REF_4_1, CONST_256, TMP10);
2860

    
2861
                vis_padd16(TMP0, TMP16, TMP0);
2862
                vis_mul8x16au(REF_6, CONST_256, TMP12);
2863

    
2864
                vis_padd16(TMP2, TMP18, TMP2);
2865
                vis_mul8x16au(REF_6_1, CONST_256, TMP14);
2866

    
2867
                vis_padd16(TMP8, CONST_3, TMP8);
2868
                vis_mul8x16al(DST_2, CONST_512, TMP16);
2869

    
2870
                vis_padd16(TMP8, TMP12, TMP8);
2871
                vis_mul8x16al(DST_3, CONST_512, TMP18);
2872

    
2873
                vis_padd16(TMP10, TMP14, TMP10);
2874
                vis_pack16(TMP0, DST_0);
2875

    
2876
                vis_pack16(TMP2, DST_1);
2877
                vis_st64(DST_0, dest[0]);
2878
                dest += stride;
2879
                vis_padd16(TMP10, CONST_3, TMP10);
2880

    
2881
                vis_ld64_2(dest, stride, DST_0);
2882
                vis_padd16(TMP8, TMP16, TMP8);
2883

    
2884
                vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
2885
                vis_padd16(TMP10, TMP18, TMP10);
2886
                vis_pack16(TMP8, DST_2);
2887

    
2888
                vis_pack16(TMP10, DST_3);
2889
                vis_st64(DST_2, dest[0]);
2890
                dest += stride;
2891

    
2892
                vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
2893
                vis_pmerge(ZERO,     REF_S0,     TMP0);
2894

    
2895
                vis_pmerge(ZERO,     REF_S2,     TMP24);
2896
                vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
2897

    
2898
                vis_padd16(TMP0, CONST_3, TMP0);
2899
                vis_mul8x16au(REF_S4, CONST_256, TMP8);
2900

    
2901
                vis_padd16(TMP2, CONST_3, TMP2);
2902
                vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
2903

    
2904
                vis_padd16(TMP0, TMP24, TMP0);
2905
                vis_mul8x16au(REF_S6, CONST_256, TMP12);
2906

    
2907
                vis_padd16(TMP2, TMP6, TMP2);
2908
                vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
2909

    
2910
                vis_padd16(TMP8, CONST_3, TMP8);
2911
                vis_mul8x16al(DST_0,   CONST_512, TMP16);
2912

    
2913
                vis_padd16(TMP10, CONST_3, TMP10);
2914
                vis_mul8x16al(DST_1,   CONST_512, TMP18);
2915

    
2916
                vis_padd16(TMP8, TMP12, TMP8);
2917
                vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
2918

    
2919
                vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
2920
                vis_padd16(TMP0, TMP16, TMP0);
2921

    
2922
                vis_padd16(TMP2, TMP18, TMP2);
2923
                vis_pack16(TMP0, DST_0);
2924

    
2925
                vis_padd16(TMP10, TMP14, TMP10);
2926
                vis_pack16(TMP2, DST_1);
2927
                vis_st64(DST_0, dest[0]);
2928
                dest += stride;
2929

    
2930
                vis_padd16(TMP8, TMP20, TMP8);
2931

    
2932
                vis_padd16(TMP10, TMP22, TMP10);
2933
                vis_pack16(TMP8, DST_2);
2934

    
2935
                vis_pack16(TMP10, DST_3);
2936
                vis_st64(DST_2, dest[0]);
2937
                dest += stride;
2938
        } while (--height);
2939
}
2940

    
2941
static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * _ref,
2942
                             const int stride, int height)
2943
{
2944
        uint8_t *ref = (uint8_t *) _ref;
2945

    
2946
        ref = vis_alignaddr(ref);
2947
        vis_ld64(ref[0], TMP0);
2948

    
2949
        vis_ld64_2(ref, 8, TMP2);
2950

    
2951
        vis_ld64_2(ref, 16, TMP4);
2952
        ref += stride;
2953

    
2954
        vis_ld64(ref[0], TMP6);
2955
        vis_faligndata(TMP0, TMP2, REF_0);
2956

    
2957
        vis_ld64_2(ref, 8, TMP8);
2958
        vis_faligndata(TMP2, TMP4, REF_4);
2959

    
2960
        vis_ld64_2(ref, 16, TMP10);
2961
        ref += stride;
2962

    
2963
        vis_ld64(constants_fe[0], MASK_fe);
2964
        vis_faligndata(TMP6, TMP8, REF_2);
2965

    
2966
        vis_ld64(constants_7f[0], MASK_7f);
2967
        vis_faligndata(TMP8, TMP10, REF_6);
2968

    
2969
        vis_ld64(constants128[0], CONST_128);
2970
        height = (height >> 1) - 1;
2971
        do {    /* 24 cycles */
2972
                vis_ld64(ref[0], TMP0);
2973
                vis_xor(REF_0, REF_2, TMP12);
2974

    
2975
                vis_ld64_2(ref, 8, TMP2);
2976
                vis_xor(REF_4, REF_6, TMP16);
2977

    
2978
                vis_ld64_2(ref, 16, TMP4);
2979
                ref += stride;
2980
                vis_and(REF_0, REF_2, TMP14);
2981

    
2982
                vis_ld64(ref[0], TMP6);
2983
                vis_and(REF_4, REF_6, TMP18);
2984

    
2985
                vis_ld64_2(ref, 8, TMP8);
2986
                vis_faligndata(TMP0, TMP2, REF_0);
2987

    
2988
                vis_ld64_2(ref, 16, TMP10);
2989
                ref += stride;
2990
                vis_faligndata(TMP2, TMP4, REF_4);
2991

    
2992
                vis_and(TMP12, MASK_fe, TMP12);
2993

    
2994
                vis_and(TMP16, MASK_fe, TMP16);
2995
                vis_mul8x16(CONST_128, TMP12, TMP12);
2996

    
2997
                vis_mul8x16(CONST_128, TMP16, TMP16);
2998
                vis_xor(REF_0, REF_2, TMP0);
2999

    
3000
                vis_xor(REF_4, REF_6, TMP2);
3001

    
3002
                vis_and(REF_0, REF_2, TMP20);
3003

    
3004
                vis_and(TMP12, MASK_7f, TMP12);
3005

    
3006
                vis_and(TMP16, MASK_7f, TMP16);
3007

    
3008
                vis_padd16(TMP14, TMP12, TMP12);
3009
                vis_st64(TMP12, dest[0]);
3010

    
3011
                vis_padd16(TMP18, TMP16, TMP16);
3012
                vis_st64_2(TMP16, dest, 8);
3013
                dest += stride;
3014

    
3015
                vis_and(REF_4, REF_6, TMP18);
3016

    
3017
                vis_and(TMP0, MASK_fe, TMP0);
3018

    
3019
                vis_and(TMP2, MASK_fe, TMP2);
3020
                vis_mul8x16(CONST_128, TMP0, TMP0);
3021

    
3022
                vis_faligndata(TMP6, TMP8, REF_2);
3023
                vis_mul8x16(CONST_128, TMP2, TMP2);
3024

    
3025
                vis_faligndata(TMP8, TMP10, REF_6);
3026

    
3027
                vis_and(TMP0, MASK_7f, TMP0);
3028

    
3029
                vis_and(TMP2, MASK_7f, TMP2);
3030

    
3031
                vis_padd16(TMP20, TMP0, TMP0);
3032
                vis_st64(TMP0, dest[0]);
3033

    
3034
                vis_padd16(TMP18, TMP2, TMP2);
3035
                vis_st64_2(TMP2, dest, 8);
3036
                dest += stride;
3037
        } while (--height);
3038

    
3039
        vis_ld64(ref[0], TMP0);
3040
        vis_xor(REF_0, REF_2, TMP12);
3041

    
3042
        vis_ld64_2(ref, 8, TMP2);
3043
        vis_xor(REF_4, REF_6, TMP16);
3044

    
3045
        vis_ld64_2(ref, 16, TMP4);
3046
        vis_and(REF_0, REF_2, TMP14);
3047

    
3048
        vis_and(REF_4, REF_6, TMP18);
3049

    
3050
        vis_faligndata(TMP0, TMP2, REF_0);
3051

    
3052
        vis_faligndata(TMP2, TMP4, REF_4);
3053

    
3054
        vis_and(TMP12, MASK_fe, TMP12);
3055

    
3056
        vis_and(TMP16, MASK_fe, TMP16);
3057
        vis_mul8x16(CONST_128, TMP12, TMP12);
3058

    
3059
        vis_mul8x16(CONST_128, TMP16, TMP16);
3060
        vis_xor(REF_0, REF_2, TMP0);
3061

    
3062
        vis_xor(REF_4, REF_6, TMP2);
3063

    
3064
        vis_and(REF_0, REF_2, TMP20);
3065

    
3066
        vis_and(TMP12, MASK_7f, TMP12);
3067

    
3068
        vis_and(TMP16, MASK_7f, TMP16);
3069

    
3070
        vis_padd16(TMP14, TMP12, TMP12);
3071
        vis_st64(TMP12, dest[0]);
3072

    
3073
        vis_padd16(TMP18, TMP16, TMP16);
3074
        vis_st64_2(TMP16, dest, 8);
3075
        dest += stride;
3076

    
3077
        vis_and(REF_4, REF_6, TMP18);
3078

    
3079
        vis_and(TMP0, MASK_fe, TMP0);
3080

    
3081
        vis_and(TMP2, MASK_fe, TMP2);
3082
        vis_mul8x16(CONST_128, TMP0, TMP0);
3083

    
3084
        vis_mul8x16(CONST_128, TMP2, TMP2);
3085

    
3086
        vis_and(TMP0, MASK_7f, TMP0);
3087

    
3088
        vis_and(TMP2, MASK_7f, TMP2);
3089

    
3090
        vis_padd16(TMP20, TMP0, TMP0);
3091
        vis_st64(TMP0, dest[0]);
3092

    
3093
        vis_padd16(TMP18, TMP2, TMP2);
3094
        vis_st64_2(TMP2, dest, 8);
3095
}
3096

    
3097
static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * _ref,
3098
                            const int stride, int height)
3099
{
3100
        uint8_t *ref = (uint8_t *) _ref;
3101

    
3102
        ref = vis_alignaddr(ref);
3103
        vis_ld64(ref[0], TMP0);
3104

    
3105
        vis_ld64_2(ref, 8, TMP2);
3106
        ref += stride;
3107

    
3108
        vis_ld64(ref[0], TMP4);
3109

    
3110
        vis_ld64_2(ref, 8, TMP6);
3111
        ref += stride;
3112

    
3113
        vis_ld64(constants_fe[0], MASK_fe);
3114
        vis_faligndata(TMP0, TMP2, REF_0);
3115

    
3116
        vis_ld64(constants_7f[0], MASK_7f);
3117
        vis_faligndata(TMP4, TMP6, REF_2);
3118

    
3119
        vis_ld64(constants128[0], CONST_128);
3120
        height = (height >> 1) - 1;
3121
        do {    /* 12 cycles */
3122
                vis_ld64(ref[0], TMP0);
3123
                vis_xor(REF_0, REF_2, TMP4);
3124

    
3125
                vis_ld64_2(ref, 8, TMP2);
3126
                ref += stride;
3127
                vis_and(TMP4, MASK_fe, TMP4);
3128

    
3129
                vis_and(REF_0, REF_2, TMP6);
3130
                vis_mul8x16(CONST_128, TMP4, TMP4);
3131

    
3132
                vis_faligndata(TMP0, TMP2, REF_0);
3133
                vis_ld64(ref[0], TMP0);
3134

    
3135
                vis_ld64_2(ref, 8, TMP2);
3136
                ref += stride;
3137
                vis_xor(REF_0, REF_2, TMP12);
3138

    
3139
                vis_and(TMP4, MASK_7f, TMP4);
3140

    
3141
                vis_and(TMP12, MASK_fe, TMP12);
3142

    
3143
                vis_mul8x16(CONST_128, TMP12, TMP12);
3144
                vis_and(REF_0, REF_2, TMP14);
3145

    
3146
                vis_padd16(TMP6, TMP4, DST_0);
3147
                vis_st64(DST_0, dest[0]);
3148
                dest += stride;
3149

    
3150
                vis_faligndata(TMP0, TMP2, REF_2);
3151

    
3152
                vis_and(TMP12, MASK_7f, TMP12);
3153

    
3154
                vis_padd16(TMP14, TMP12, DST_0);
3155
                vis_st64(DST_0, dest[0]);
3156
                dest += stride;
3157
        } while (--height);
3158

    
3159
        vis_ld64(ref[0], TMP0);
3160
        vis_xor(REF_0, REF_2, TMP4);
3161

    
3162
        vis_ld64_2(ref, 8, TMP2);
3163
        vis_and(TMP4, MASK_fe, TMP4);
3164

    
3165
        vis_and(REF_0, REF_2, TMP6);
3166
        vis_mul8x16(CONST_128, TMP4, TMP4);
3167

    
3168
        vis_faligndata(TMP0, TMP2, REF_0);
3169

    
3170
        vis_xor(REF_0, REF_2, TMP12);
3171

    
3172
        vis_and(TMP4, MASK_7f, TMP4);
3173

    
3174
        vis_and(TMP12, MASK_fe, TMP12);
3175

    
3176
        vis_mul8x16(CONST_128, TMP12, TMP12);
3177
        vis_and(REF_0, REF_2, TMP14);
3178

    
3179
        vis_padd16(TMP6, TMP4, DST_0);
3180
        vis_st64(DST_0, dest[0]);
3181
        dest += stride;
3182

    
3183
        vis_and(TMP12, MASK_7f, TMP12);
3184

    
3185
        vis_padd16(TMP14, TMP12, DST_0);
3186
        vis_st64(DST_0, dest[0]);
3187
}
3188

    
3189
static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * _ref,
3190
                             const int stride, int height)
3191
{
3192
        uint8_t *ref = (uint8_t *) _ref;
3193
        int stride_8 = stride + 8;
3194
        int stride_16 = stride + 16;
3195

    
3196
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
3197

    
3198
        ref = vis_alignaddr(ref);
3199

    
3200
        vis_ld64(ref[ 0], TMP0);
3201
        vis_fzero(ZERO);
3202

    
3203
        vis_ld64(ref[ 8], TMP2);
3204

    
3205
        vis_ld64(ref[16], TMP4);
3206

    
3207
        vis_ld64(constants3[0], CONST_3);
3208
        vis_faligndata(TMP0, TMP2, REF_2);
3209

    
3210
        vis_ld64(constants256_512[0], CONST_256);
3211
        vis_faligndata(TMP2, TMP4, REF_6);
3212
        height >>= 1;
3213

    
3214
        do {    /* 31 cycles */
3215
                vis_ld64_2(ref, stride, TMP0);
3216
                vis_pmerge(ZERO,       REF_2,     TMP12);
3217
                vis_mul8x16au(REF_2_1, CONST_256, TMP14);
3218

    
3219
                vis_ld64_2(ref, stride_8, TMP2);
3220
                vis_pmerge(ZERO,       REF_6,     TMP16);
3221
                vis_mul8x16au(REF_6_1, CONST_256, TMP18);
3222

    
3223
                vis_ld64_2(ref, stride_16, TMP4);
3224
                ref += stride;
3225

    
3226
                vis_ld64(dest[0], DST_0);
3227
                vis_faligndata(TMP0, TMP2, REF_0);
3228

    
3229
                vis_ld64_2(dest, 8, DST_2);
3230
                vis_faligndata(TMP2, TMP4, REF_4);
3231

    
3232
                vis_ld64_2(ref, stride, TMP6);
3233
                vis_pmerge(ZERO,     REF_0,     TMP0);
3234
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);
3235

    
3236
                vis_ld64_2(ref, stride_8, TMP8);
3237
                vis_pmerge(ZERO,     REF_4,     TMP4);
3238

    
3239
                vis_ld64_2(ref, stride_16, TMP10);
3240
                ref += stride;
3241

    
3242
                vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
3243
                vis_faligndata(TMP6, TMP8, REF_2);
3244
                vis_mul8x16au(REF_4_1, CONST_256, TMP6);
3245

    
3246
                vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
3247
                vis_faligndata(TMP8, TMP10, REF_6);
3248
                vis_mul8x16al(DST_0,   CONST_512, TMP20);
3249

    
3250
                vis_padd16(TMP0, CONST_3, TMP0);
3251
                vis_mul8x16al(DST_1,   CONST_512, TMP22);
3252

    
3253
                vis_padd16(TMP2, CONST_3, TMP2);
3254
                vis_mul8x16al(DST_2,   CONST_512, TMP24);
3255

    
3256
                vis_padd16(TMP4, CONST_3, TMP4);
3257
                vis_mul8x16al(DST_3,   CONST_512, TMP26);
3258

    
3259
                vis_padd16(TMP6, CONST_3, TMP6);
3260

    
3261
                vis_padd16(TMP12, TMP20, TMP12);
3262
                vis_mul8x16al(REF_S0,   CONST_512, TMP20);
3263

    
3264
                vis_padd16(TMP14, TMP22, TMP14);
3265
                vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
3266

    
3267
                vis_padd16(TMP16, TMP24, TMP16);
3268
                vis_mul8x16al(REF_S2,   CONST_512, TMP24);
3269

    
3270
                vis_padd16(TMP18, TMP26, TMP18);
3271
                vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
3272

    
3273
                vis_padd16(TMP12, TMP0, TMP12);
3274
                vis_mul8x16au(REF_2,   CONST_256, TMP28);
3275

    
3276
                vis_padd16(TMP14, TMP2, TMP14);
3277
                vis_mul8x16au(REF_2_1, CONST_256, TMP30);
3278

    
3279
                vis_padd16(TMP16, TMP4, TMP16);
3280
                vis_mul8x16au(REF_6,   CONST_256, REF_S4);
3281

    
3282
                vis_padd16(TMP18, TMP6, TMP18);
3283
                vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
3284

    
3285
                vis_pack16(TMP12, DST_0);
3286
                vis_padd16(TMP28, TMP0, TMP12);
3287

    
3288
                vis_pack16(TMP14, DST_1);
3289
                vis_st64(DST_0, dest[0]);
3290
                vis_padd16(TMP30, TMP2, TMP14);
3291

    
3292
                vis_pack16(TMP16, DST_2);
3293
                vis_padd16(REF_S4, TMP4, TMP16);
3294

    
3295
                vis_pack16(TMP18, DST_3);
3296
                vis_st64_2(DST_2, dest, 8);
3297
                dest += stride;
3298
                vis_padd16(REF_S6, TMP6, TMP18);
3299

    
3300
                vis_padd16(TMP12, TMP20, TMP12);
3301

    
3302
                vis_padd16(TMP14, TMP22, TMP14);
3303
                vis_pack16(TMP12, DST_0);
3304

    
3305
                vis_padd16(TMP16, TMP24, TMP16);
3306
                vis_pack16(TMP14, DST_1);
3307
                vis_st64(DST_0, dest[0]);
3308

    
3309
                vis_padd16(TMP18, TMP26, TMP18);
3310
                vis_pack16(TMP16, DST_2);
3311

    
3312
                vis_pack16(TMP18, DST_3);
3313
                vis_st64_2(DST_2, dest, 8);
3314
                dest += stride;
3315
        } while (--height);
3316
}
3317

    
3318
static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * _ref,
3319
                            const int stride, int height)
3320
{
3321
        uint8_t *ref = (uint8_t *) _ref;
3322
        int stride_8 = stride + 8;
3323

    
3324
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
3325

    
3326
        ref = vis_alignaddr(ref);
3327

    
3328
        vis_ld64(ref[ 0], TMP0);
3329
        vis_fzero(ZERO);
3330

    
3331
        vis_ld64(ref[ 8], TMP2);
3332

    
3333
        vis_ld64(constants3[0], CONST_3);
3334
        vis_faligndata(TMP0, TMP2, REF_2);
3335

    
3336
        vis_ld64(constants256_512[0], CONST_256);
3337

    
3338
        height >>= 1;
3339
        do {    /* 20 cycles */
3340
                vis_ld64_2(ref, stride, TMP0);
3341
                vis_pmerge(ZERO,       REF_2,     TMP8);
3342
                vis_mul8x16au(REF_2_1, CONST_256, TMP10);
3343

    
3344
                vis_ld64_2(ref, stride_8, TMP2);
3345
                ref += stride;
3346

    
3347
                vis_ld64(dest[0], DST_0);
3348

    
3349
                vis_ld64_2(dest, stride, DST_2);
3350
                vis_faligndata(TMP0, TMP2, REF_0);
3351

    
3352
                vis_ld64_2(ref, stride, TMP4);
3353
                vis_mul8x16al(DST_0,   CONST_512, TMP16);
3354
                vis_pmerge(ZERO,       REF_0,     TMP12);
3355

    
3356
                vis_ld64_2(ref, stride_8, TMP6);
3357
                ref += stride;
3358
                vis_mul8x16al(DST_1,   CONST_512, TMP18);
3359
                vis_pmerge(ZERO,       REF_0_1,   TMP14);
3360

    
3361
                vis_padd16(TMP12, CONST_3, TMP12);
3362
                vis_mul8x16al(DST_2,   CONST_512, TMP24);
3363

    
3364
                vis_padd16(TMP14, CONST_3, TMP14);
3365
                vis_mul8x16al(DST_3,   CONST_512, TMP26);
3366

    
3367
                vis_faligndata(TMP4, TMP6, REF_2);
3368

    
3369
                vis_padd16(TMP8, TMP12, TMP8);
3370

    
3371
                vis_padd16(TMP10, TMP14, TMP10);
3372
                vis_mul8x16au(REF_2,   CONST_256, TMP20);
3373

    
3374
                vis_padd16(TMP8, TMP16, TMP0);
3375
                vis_mul8x16au(REF_2_1, CONST_256, TMP22);
3376

    
3377
                vis_padd16(TMP10, TMP18, TMP2);
3378
                vis_pack16(TMP0, DST_0);
3379

    
3380
                vis_pack16(TMP2, DST_1);
3381
                vis_st64(DST_0, dest[0]);
3382
                dest += stride;
3383
                vis_padd16(TMP12, TMP20, TMP12);
3384

    
3385
                vis_padd16(TMP14, TMP22, TMP14);
3386

    
3387
                vis_padd16(TMP12, TMP24, TMP0);
3388

    
3389
                vis_padd16(TMP14, TMP26, TMP2);
3390
                vis_pack16(TMP0, DST_2);
3391

    
3392
                vis_pack16(TMP2, DST_3);
3393
                vis_st64(DST_2, dest[0]);
3394
                dest += stride;
3395
        } while (--height);
3396
}
3397

    
3398
static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
3399
                                       const int stride, int height)
3400
{
3401
        uint8_t *ref = (uint8_t *) _ref;
3402
        unsigned long off = (unsigned long) ref & 0x7;
3403
        unsigned long off_plus_1 = off + 1;
3404
        int stride_8 = stride + 8;
3405
        int stride_16 = stride + 16;
3406

    
3407
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
3408

    
3409
        ref = vis_alignaddr(ref);
3410

    
3411
        vis_ld64(ref[ 0], TMP0);
3412
        vis_fzero(ZERO);
3413

    
3414
        vis_ld64(ref[ 8], TMP2);
3415

    
3416
        vis_ld64(ref[16], TMP4);
3417

    
3418
        vis_ld64(constants1[0], CONST_1);
3419
        vis_faligndata(TMP0, TMP2, REF_S0);
3420

    
3421
        vis_ld64(constants256_512[0], CONST_256);
3422
        vis_faligndata(TMP2, TMP4, REF_S4);
3423

    
3424
        if (off != 0x7) {
3425
                vis_alignaddr_g0((void *)off_plus_1);
3426
                vis_faligndata(TMP0, TMP2, REF_S2);
3427
                vis_faligndata(TMP2, TMP4, REF_S6);
3428
        } else {
3429
                vis_src1(TMP2, REF_S2);
3430
                vis_src1(TMP4, REF_S6);
3431
        }
3432

    
3433
        height >>= 1;
3434
        do {
3435
                vis_ld64_2(ref, stride, TMP0);
3436
                vis_mul8x16au(REF_S0, CONST_256, TMP12);
3437
                vis_pmerge(ZERO,      REF_S0_1,  TMP14);
3438

    
3439
                vis_alignaddr_g0((void *)off);
3440

    
3441
                vis_ld64_2(ref, stride_8, TMP2);
3442
                vis_mul8x16au(REF_S2, CONST_256, TMP16);
3443
                vis_pmerge(ZERO,      REF_S2_1,  TMP18);
3444

    
3445
                vis_ld64_2(ref, stride_16, TMP4);
3446
                ref += stride;
3447
                vis_mul8x16au(REF_S4, CONST_256, TMP20);
3448
                vis_pmerge(ZERO,      REF_S4_1,  TMP22);
3449

    
3450
                vis_ld64_2(ref, stride, TMP6);
3451
                vis_mul8x16au(REF_S6, CONST_256, TMP24);
3452
                vis_pmerge(ZERO,      REF_S6_1,  TMP26);
3453

    
3454
                vis_ld64_2(ref, stride_8, TMP8);
3455
                vis_faligndata(TMP0, TMP2, REF_0);
3456

    
3457
                vis_ld64_2(ref, stride_16, TMP10);
3458
                ref += stride;
3459
                vis_faligndata(TMP2, TMP4, REF_4);
3460

    
3461
                vis_faligndata(TMP6, TMP8, REF_S0);
3462

    
3463
                vis_faligndata(TMP8, TMP10, REF_S4);
3464

    
3465
                if (off != 0x7) {
3466
                        vis_alignaddr_g0((void *)off_plus_1);
3467
                        vis_faligndata(TMP0, TMP2, REF_2);
3468
                        vis_faligndata(TMP2, TMP4, REF_6);
3469
                        vis_faligndata(TMP6, TMP8, REF_S2);
3470
                        vis_faligndata(TMP8, TMP10, REF_S6);
3471
                } else {
3472
                        vis_src1(TMP2, REF_2);
3473
                        vis_src1(TMP4, REF_6);
3474
                        vis_src1(TMP8, REF_S2);
3475
                        vis_src1(TMP10, REF_S6);
3476
                }
3477

    
3478
                vis_mul8x16au(REF_0, CONST_256, TMP0);
3479
                vis_pmerge(ZERO,      REF_0_1,  TMP2);
3480

    
3481
                vis_mul8x16au(REF_2, CONST_256, TMP4);
3482
                vis_pmerge(ZERO,      REF_2_1,  TMP6);
3483

    
3484
                vis_padd16(TMP0, CONST_2, TMP8);
3485
                vis_mul8x16au(REF_4, CONST_256, TMP0);
3486

    
3487
                vis_padd16(TMP2, CONST_1, TMP10);
3488
                vis_mul8x16au(REF_4_1, CONST_256, TMP2);
3489

    
3490
                vis_padd16(TMP8, TMP4, TMP8);
3491
                vis_mul8x16au(REF_6, CONST_256, TMP4);
3492

    
3493
                vis_padd16(TMP10, TMP6, TMP10);
3494
                vis_mul8x16au(REF_6_1, CONST_256, TMP6);
3495

    
3496
                vis_padd16(TMP12, TMP8, TMP12);
3497

    
3498
                vis_padd16(TMP14, TMP10, TMP14);
3499

    
3500
                vis_padd16(TMP12, TMP16, TMP12);
3501

    
3502
                vis_padd16(TMP14, TMP18, TMP14);
3503
                vis_pack16(TMP12, DST_0);
3504

    
3505
                vis_pack16(TMP14, DST_1);
3506
                vis_st64(DST_0, dest[0]);
3507
                vis_padd16(TMP0, CONST_1, TMP12);
3508

    
3509
                vis_mul8x16au(REF_S0, CONST_256, TMP0);
3510
                vis_padd16(TMP2, CONST_1, TMP14);
3511

    
3512
                vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
3513
                vis_padd16(TMP12, TMP4, TMP12);
3514

    
3515
                vis_mul8x16au(REF_S2, CONST_256, TMP4);
3516
                vis_padd16(TMP14, TMP6, TMP14);
3517

    
3518
                vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
3519
                vis_padd16(TMP20, TMP12, TMP20);
3520

    
3521
                vis_padd16(TMP22, TMP14, TMP22);
3522

    
3523
                vis_padd16(TMP20, TMP24, TMP20);
3524

    
3525
                vis_padd16(TMP22, TMP26, TMP22);
3526
                vis_pack16(TMP20, DST_2);
3527

    
3528
                vis_pack16(TMP22, DST_3);
3529
                vis_st64_2(DST_2, dest, 8);
3530
                dest += stride;
3531
                vis_padd16(TMP0, TMP4, TMP24);
3532

    
3533
                vis_mul8x16au(REF_S4, CONST_256, TMP0);
3534
                vis_padd16(TMP2, TMP6, TMP26);
3535

    
3536
                vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
3537
                vis_padd16(TMP24, TMP8, TMP24);
3538

    
3539
                vis_padd16(TMP26, TMP10, TMP26);
3540
                vis_pack16(TMP24, DST_0);
3541

    
3542
                vis_pack16(TMP26, DST_1);
3543
                vis_st64(DST_0, dest[0]);
3544
                vis_pmerge(ZERO, REF_S6, TMP4);
3545

    
3546
                vis_pmerge(ZERO,      REF_S6_1,  TMP6);
3547

    
3548
                vis_padd16(TMP0, TMP4, TMP0);
3549

    
3550
                vis_padd16(TMP2, TMP6, TMP2);
3551

    
3552
                vis_padd16(TMP0, TMP12, TMP0);
3553

    
3554
                vis_padd16(TMP2, TMP14, TMP2);
3555
                vis_pack16(TMP0, DST_2);
3556

    
3557
                vis_pack16(TMP2, DST_3);
3558
                vis_st64_2(DST_2, dest, 8);
3559
                dest += stride;
3560
        } while (--height);
3561
}
3562

    
3563
static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
3564
                                      const int stride, int height)
3565
{
3566
        uint8_t *ref = (uint8_t *) _ref;
3567
        unsigned long off = (unsigned long) ref & 0x7;
3568
        unsigned long off_plus_1 = off + 1;
3569
        int stride_8 = stride + 8;
3570

    
3571
        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
3572

    
3573
        ref = vis_alignaddr(ref);
3574

    
3575
        vis_ld64(ref[ 0], TMP0);
3576
        vis_fzero(ZERO);
3577

    
3578
        vis_ld64(ref[ 8], TMP2);
3579

    
3580
        vis_ld64(constants1[0], CONST_1);
3581

    
3582
        vis_ld64(constants256_512[0], CONST_256);
3583
        vis_faligndata(TMP0, TMP2, REF_S0);
3584

    
3585
        if (off != 0x7) {
3586
                vis_alignaddr_g0((void *)off_plus_1);
3587
                vis_faligndata(TMP0, TMP2, REF_S2);
3588
        } else {
3589
                vis_src1(TMP2, REF_S2);
3590
        }
3591

    
3592
        height >>= 1;
3593
        do {    /* 26 cycles */
3594
                vis_ld64_2(ref, stride, TMP0);
3595
                vis_mul8x16au(REF_S0,   CONST_256, TMP8);
3596
                vis_pmerge(ZERO,        REF_S2,    TMP12);
3597

    
3598
                vis_alignaddr_g0((void *)off);
3599

    
3600
                vis_ld64_2(ref, stride_8, TMP2);
3601
                ref += stride;
3602
                vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
3603
                vis_pmerge(ZERO,        REF_S2_1,  TMP14);
3604

    
3605
                vis_ld64_2(ref, stride, TMP4);
3606

    
3607
                vis_ld64_2(ref, stride_8, TMP6);
3608
                ref += stride;
3609
                vis_faligndata(TMP0, TMP2, REF_S4);
3610

    
3611
                vis_pmerge(ZERO, REF_S4, TMP18);
3612

    
3613
                vis_pmerge(ZERO, REF_S4_1, TMP20);
3614

    
3615
                vis_faligndata(TMP4, TMP6, REF_S0);
3616

    
3617
                if (off != 0x7) {
3618
                        vis_alignaddr_g0((void *)off_plus_1);
3619
                        vis_faligndata(TMP0, TMP2, REF_S6);
3620
                        vis_faligndata(TMP4, TMP6, REF_S2);
3621
                } else {
3622
                        vis_src1(TMP2, REF_S6);
3623
                        vis_src1(TMP6, REF_S2);
3624
                }
3625

    
3626
                vis_padd16(TMP18, CONST_1, TMP18);
3627
                vis_mul8x16au(REF_S6,   CONST_256, TMP22);
3628

    
3629
                vis_padd16(TMP20, CONST_1, TMP20);
3630
                vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
3631

    
3632
                vis_mul8x16au(REF_S0,   CONST_256, TMP26);
3633
                vis_pmerge(ZERO, REF_S0_1, TMP28);
3634

    
3635
                vis_mul8x16au(REF_S2,   CONST_256, TMP30);
3636
                vis_padd16(TMP18, TMP22, TMP18);
3637

    
3638
                vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
3639
                vis_padd16(TMP20, TMP24, TMP20);
3640

    
3641
                vis_padd16(TMP8,  TMP18, TMP8);
3642

    
3643
                vis_padd16(TMP10, TMP20, TMP10);
3644

    
3645
                vis_padd16(TMP8,  TMP12, TMP8);
3646

    
3647
                vis_padd16(TMP10, TMP14, TMP10);
3648
                vis_pack16(TMP8,  DST_0);
3649

    
3650
                vis_pack16(TMP10, DST_1);
3651
                vis_st64(DST_0, dest[0]);
3652
                dest += stride;
3653
                vis_padd16(TMP18, TMP26, TMP18);
3654

    
3655
                vis_padd16(TMP20, TMP28, TMP20);
3656

    
3657
                vis_padd16(TMP18, TMP30, TMP18);
3658

    
3659
                vis_padd16(TMP20, TMP32, TMP20);
3660
                vis_pack16(TMP18, DST_2);
3661

    
3662
                vis_pack16(TMP20, DST_3);
3663
                vis_st64(DST_2, dest[0]);
3664
                dest += stride;
3665
        } while (--height);
3666
}
3667

    
3668
static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
3669
                                       const int stride, int height)
3670
{
3671
        uint8_t *ref = (uint8_t *) _ref;
3672
        unsigned long off = (unsigned long) ref & 0x7;
3673
        unsigned long off_plus_1 = off + 1;
3674
        int stride_8 = stride + 8;
3675
        int stride_16 = stride + 16;
3676

    
3677
        vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
3678

    
3679
        ref = vis_alignaddr(ref);
3680

    
3681
        vis_ld64(ref[ 0], TMP0);
3682
        vis_fzero(ZERO);
3683

    
3684
        vis_ld64(ref[ 8], TMP2);
3685

    
3686
        vis_ld64(ref[16], TMP4);
3687

    
3688
        vis_ld64(constants6[0], CONST_6);
3689
        vis_faligndata(TMP0, TMP2, REF_S0);
3690

    
3691
        vis_ld64(constants256_1024[0], CONST_256);
3692
        vis_faligndata(TMP2, TMP4, REF_S4);
3693

    
3694
        if (off != 0x7) {
3695
                vis_alignaddr_g0((void *)off_plus_1);
3696
                vis_faligndata(TMP0, TMP2, REF_S2);
3697
                vis_faligndata(TMP2, TMP4, REF_S6);
3698
        } else {
3699
                vis_src1(TMP2, REF_S2);
3700
                vis_src1(TMP4, REF_S6);
3701
        }
3702

    
3703
        height >>= 1;
3704
        do {    /* 55 cycles */
3705
                vis_ld64_2(ref, stride, TMP0);
3706
                vis_mul8x16au(REF_S0, CONST_256, TMP12);
3707
                vis_pmerge(ZERO,      REF_S0_1,  TMP14);
3708

    
3709
                vis_alignaddr_g0((void *)off);
3710

    
3711
                vis_ld64_2(ref, stride_8, TMP2);
3712
                vis_mul8x16au(REF_S2, CONST_256, TMP16);
3713
                vis_pmerge(ZERO,      REF_S2_1,  TMP18);
3714

    
3715
                vis_ld64_2(ref, stride_16, TMP4);
3716
                ref += stride;
3717
                vis_mul8x16au(REF_S4, CONST_256, TMP20);
3718
                vis_pmerge(ZERO,      REF_S4_1,  TMP22);
3719

    
3720
                vis_ld64_2(ref, stride, TMP6);
3721
                vis_mul8x16au(REF_S6, CONST_256, TMP24);
3722
                vis_pmerge(ZERO,      REF_S6_1,  TMP26);
3723

    
3724
                vis_ld64_2(ref, stride_8, TMP8);
3725
                vis_faligndata(TMP0, TMP2, REF_0);
3726

    
3727
                vis_ld64_2(ref, stride_16, TMP10);
3728
                ref += stride;
3729
                vis_faligndata(TMP2, TMP4, REF_4);
3730

    
3731
                vis_ld64(dest[0], DST_0);
3732
                vis_faligndata(TMP6, TMP8, REF_S0);
3733

    
3734
                vis_ld64_2(dest, 8, DST_2);
3735
                vis_faligndata(TMP8, TMP10, REF_S4);
3736

    
3737
                if (off != 0x7) {
3738
                        vis_alignaddr_g0((void *)off_plus_1);
3739
                        vis_faligndata(TMP0, TMP2, REF_2);
3740
                        vis_faligndata(TMP2, TMP4, REF_6);
3741
                        vis_faligndata(TMP6, TMP8, REF_S2);
3742
                        vis_faligndata(TMP8, TMP10, REF_S6);
3743
                } else {
3744
                        vis_src1(TMP2, REF_2);
3745
                        vis_src1(TMP4, REF_6);
3746
                        vis_src1(TMP8, REF_S2);
3747
                        vis_src1(TMP10, REF_S6);
3748
                }
3749

    
3750
                vis_mul8x16al(DST_0,   CONST_1024, TMP30);
3751
                vis_pmerge(ZERO, REF_0, TMP0);
3752

    
3753
                vis_mul8x16al(DST_1,   CONST_1024, TMP32);
3754
                vis_pmerge(ZERO,      REF_0_1,  TMP2);
3755

    
3756
                vis_mul8x16au(REF_2, CONST_256, TMP4);
3757
                vis_pmerge(ZERO,      REF_2_1,  TMP6);
3758

    
3759
                vis_mul8x16al(DST_2,   CONST_1024, REF_0);
3760
                vis_padd16(TMP0, CONST_6, TMP0);
3761

    
3762
                vis_mul8x16al(DST_3,   CONST_1024, REF_2);
3763
                vis_padd16(TMP2, CONST_6, TMP2);
3764

    
3765
                vis_padd16(TMP0, TMP4, TMP0);
3766
                vis_mul8x16au(REF_4, CONST_256, TMP4);
3767

    
3768
                vis_padd16(TMP2, TMP6, TMP2);
3769
                vis_mul8x16au(REF_4_1, CONST_256, TMP6);
3770

    
3771
                vis_padd16(TMP12, TMP0, TMP12);
3772
                vis_mul8x16au(REF_6, CONST_256, TMP8);
3773

    
3774
                vis_padd16(TMP14, TMP2, TMP14);
3775
                vis_mul8x16au(REF_6_1, CONST_256, TMP10);
3776

    
3777
                vis_padd16(TMP12, TMP16, TMP12);
3778
                vis_mul8x16au(REF_S0, CONST_256, REF_4);
3779

    
3780
                vis_padd16(TMP14, TMP18, TMP14);
3781
                vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
3782

    
3783
                vis_padd16(TMP12, TMP30, TMP12);
3784

    
3785
                vis_padd16(TMP14, TMP32, TMP14);
3786
                vis_pack16(TMP12, DST_0);
3787

    
3788
                vis_pack16(TMP14, DST_1);
3789
                vis_st64(DST_0, dest[0]);
3790
                vis_padd16(TMP4, CONST_6, TMP4);
3791

    
3792
                vis_ld64_2(dest, stride, DST_0);
3793
                vis_padd16(TMP6, CONST_6, TMP6);
3794
                vis_mul8x16au(REF_S2, CONST_256, TMP12);
3795

    
3796
                vis_padd16(TMP4, TMP8, TMP4);
3797
                vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);
3798

    
3799
                vis_padd16(TMP6, TMP10, TMP6);
3800

    
3801
                vis_padd16(TMP20, TMP4, TMP20);
3802

    
3803
                vis_padd16(TMP22, TMP6, TMP22);
3804

    
3805
                vis_padd16(TMP20, TMP24, TMP20);
3806

    
3807
                vis_padd16(TMP22, TMP26, TMP22);
3808

    
3809
                vis_padd16(TMP20, REF_0, TMP20);
3810
                vis_mul8x16au(REF_S4, CONST_256, REF_0);
3811

    
3812
                vis_padd16(TMP22, REF_2, TMP22);
3813
                vis_pack16(TMP20, DST_2);
3814

    
3815
                vis_pack16(TMP22, DST_3);
3816
                vis_st64_2(DST_2, dest, 8);
3817
                dest += stride;
3818

    
3819
                vis_ld64_2(dest, 8, DST_2);
3820
                vis_mul8x16al(DST_0,   CONST_1024, TMP30);
3821
                vis_pmerge(ZERO,      REF_S4_1,  REF_2);
3822

    
3823
                vis_mul8x16al(DST_1,   CONST_1024, TMP32);
3824
                vis_padd16(REF_4, TMP0, TMP8);
3825

    
3826
                vis_mul8x16au(REF_S6, CONST_256, REF_4);
3827
                vis_padd16(REF_6, TMP2, TMP10);
3828

    
3829
                vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
3830
                vis_padd16(TMP8, TMP12, TMP8);
3831

    
3832
                vis_padd16(TMP10, TMP14, TMP10);
3833

    
3834
                vis_padd16(TMP8, TMP30, TMP8);
3835

    
3836
                vis_padd16(TMP10, TMP32, TMP10);
3837
                vis_pack16(TMP8, DST_0);
3838

    
3839
                vis_pack16(TMP10, DST_1);
3840
                vis_st64(DST_0, dest[0]);
3841

    
3842
                vis_padd16(REF_0, TMP4, REF_0);
3843

    
3844
                vis_mul8x16al(DST_2,   CONST_1024, TMP30);
3845
                vis_padd16(REF_2, TMP6, REF_2);
3846

    
3847
                vis_mul8x16al(DST_3,   CONST_1024, TMP32);
3848
                vis_padd16(REF_0, REF_4, REF_0);
3849

    
3850
                vis_padd16(REF_2, REF_6, REF_2);
3851

    
3852
                vis_padd16(REF_0, TMP30, REF_0);
3853

    
3854
                /* stall */
3855

    
3856
                vis_padd16(REF_2, TMP32, REF_2);
3857
                vis_pack16(REF_0, DST_2);
3858

    
3859
                vis_pack16(REF_2, DST_3);
3860
                vis_st64_2(DST_2, dest, 8);
3861
                dest += stride;
3862
        } while (--height);
3863
}
3864

    
3865
static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
3866
                                      const int stride, int height)
3867
{
3868
        uint8_t *ref = (uint8_t *) _ref;
3869
        unsigned long off = (unsigned long) ref & 0x7;
3870
        unsigned long off_plus_1 = off + 1;
3871
        int stride_8 = stride + 8;
3872

    
3873
        vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
3874

    
3875
        ref = vis_alignaddr(ref);
3876

    
3877
        vis_ld64(ref[0], TMP0);
3878
        vis_fzero(ZERO);
3879

    
3880
        vis_ld64_2(ref, 8, TMP2);
3881

    
3882
        vis_ld64(constants6[0], CONST_6);
3883

    
3884
        vis_ld64(constants256_1024[0], CONST_256);
3885
        vis_faligndata(TMP0, TMP2, REF_S0);
3886

    
3887
        if (off != 0x7) {
3888
                vis_alignaddr_g0((void *)off_plus_1);
3889
                vis_faligndata(TMP0, TMP2, REF_S2);
3890
        } else {
3891
                vis_src1(TMP2, REF_S2);
3892
        }
3893

    
3894
        height >>= 1;
3895
        do {    /* 31 cycles */
3896
                vis_ld64_2(ref, stride, TMP0);
3897
                vis_mul8x16au(REF_S0, CONST_256, TMP8);
3898
                vis_pmerge(ZERO,      REF_S0_1,  TMP10);
3899

    
3900
                vis_ld64_2(ref, stride_8, TMP2);
3901
                ref += stride;
3902
                vis_mul8x16au(REF_S2, CONST_256, TMP12);
3903
                vis_pmerge(ZERO,      REF_S2_1,  TMP14);
3904

    
3905
                vis_alignaddr_g0((void *)off);
3906

    
3907
                vis_ld64_2(ref, stride, TMP4);
3908
                vis_faligndata(TMP0, TMP2, REF_S4);
3909

    
3910
                vis_ld64_2(ref, stride_8, TMP6);
3911
                ref += stride;
3912

    
3913
                vis_ld64(dest[0], DST_0);
3914
                vis_faligndata(TMP4, TMP6, REF_S0);
3915

    
3916
                vis_ld64_2(dest, stride, DST_2);
3917

    
3918
                if (off != 0x7) {
3919
                        vis_alignaddr_g0((void *)off_plus_1);
3920
                        vis_faligndata(TMP0, TMP2, REF_S6);
3921
                        vis_faligndata(TMP4, TMP6, REF_S2);
3922
                } else {
3923
                        vis_src1(TMP2, REF_S6);
3924
                        vis_src1(TMP6, REF_S2);
3925
                }
3926

    
3927
                vis_mul8x16al(DST_0,   CONST_1024, TMP30);
3928
                vis_pmerge(ZERO, REF_S4, TMP22);
3929

    
3930
                vis_mul8x16al(DST_1,   CONST_1024, TMP32);
3931
                vis_pmerge(ZERO,      REF_S4_1,  TMP24);
3932

    
3933
                vis_mul8x16au(REF_S6, CONST_256, TMP26);
3934
                vis_pmerge(ZERO,      REF_S6_1,  TMP28);
3935

    
3936
                vis_mul8x16au(REF_S0, CONST_256, REF_S4);
3937
                vis_padd16(TMP22, CONST_6, TMP22);
3938

    
3939
                vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
3940
                vis_padd16(TMP24, CONST_6, TMP24);
3941

    
3942
                vis_mul8x16al(DST_2,   CONST_1024, REF_0);
3943
                vis_padd16(TMP22, TMP26, TMP22);
3944

    
3945
                vis_mul8x16al(DST_3,   CONST_1024, REF_2);
3946
                vis_padd16(TMP24, TMP28, TMP24);
3947

    
3948
                vis_mul8x16au(REF_S2, CONST_256, TMP26);
3949
                vis_padd16(TMP8, TMP22, TMP8);
3950

    
3951
                vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
3952
                vis_padd16(TMP10, TMP24, TMP10);
3953

    
3954
                vis_padd16(TMP8, TMP12, TMP8);
3955

    
3956
                vis_padd16(TMP10, TMP14, TMP10);
3957

    
3958
                vis_padd16(TMP8, TMP30, TMP8);
3959

    
3960
                vis_padd16(TMP10, TMP32, TMP10);
3961
                vis_pack16(TMP8, DST_0);
3962

    
3963
                vis_pack16(TMP10, DST_1);
3964
                vis_st64(DST_0, dest[0]);
3965
                dest += stride;
3966

    
3967
                vis_padd16(REF_S4, TMP22, TMP12);
3968

    
3969
                vis_padd16(REF_S6, TMP24, TMP14);
3970

    
3971
                vis_padd16(TMP12, TMP26, TMP12);
3972

    
3973
                vis_padd16(TMP14, TMP28, TMP14);
3974

    
3975
                vis_padd16(TMP12, REF_0, TMP12);
3976

    
3977
                vis_padd16(TMP14, REF_2, TMP14);
3978
                vis_pack16(TMP12, DST_2);
3979

    
3980
                vis_pack16(TMP14, DST_3);
3981
                vis_st64(DST_2, dest[0]);
3982
                dest += stride;
3983
        } while (--height);
3984
}
3985

    
3986
/* End of no rounding code */
3987

    
3988
#define ACCEL_SPARC_VIS 1
3989
#define ACCEL_SPARC_VIS2 2
3990

    
3991
static int vis_level ()
3992
{
3993
    int accel = 0;
3994
    accel |= ACCEL_SPARC_VIS;
3995
    accel |= ACCEL_SPARC_VIS2;
3996
    return accel;
3997
}
3998

    
3999
/* libavcodec initialization code */
4000
void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx)
4001
{
4002
  /* VIS-specific optimizations */
4003
  int accel = vis_level ();
4004

    
4005
  if (accel & ACCEL_SPARC_VIS) {
4006
      if(avctx->idct_algo==FF_IDCT_SIMPLEVIS){
4007
          c->idct_put = ff_simple_idct_put_vis;
4008
          c->idct_add = ff_simple_idct_add_vis;
4009
          c->idct     = ff_simple_idct_vis;
4010
          c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
4011
      }
4012

    
4013
      c->put_pixels_tab[0][0] = MC_put_o_16_vis;
4014
      c->put_pixels_tab[0][1] = MC_put_x_16_vis;
4015
      c->put_pixels_tab[0][2] = MC_put_y_16_vis;
4016
      c->put_pixels_tab[0][3] = MC_put_xy_16_vis;
4017

    
4018
      c->put_pixels_tab[1][0] = MC_put_o_8_vis;
4019
      c->put_pixels_tab[1][1] = MC_put_x_8_vis;
4020
      c->put_pixels_tab[1][2] = MC_put_y_8_vis;
4021
      c->put_pixels_tab[1][3] = MC_put_xy_8_vis;
4022

    
4023
      c->avg_pixels_tab[0][0] = MC_avg_o_16_vis;
4024
      c->avg_pixels_tab[0][1] = MC_avg_x_16_vis;
4025
      c->avg_pixels_tab[0][2] = MC_avg_y_16_vis;
4026
      c->avg_pixels_tab[0][3] = MC_avg_xy_16_vis;
4027

    
4028
      c->avg_pixels_tab[1][0] = MC_avg_o_8_vis;
4029
      c->avg_pixels_tab[1][1] = MC_avg_x_8_vis;
4030
      c->avg_pixels_tab[1][2] = MC_avg_y_8_vis;
4031
      c->avg_pixels_tab[1][3] = MC_avg_xy_8_vis;
4032

    
4033
      c->put_no_rnd_pixels_tab[0][0] = MC_put_no_round_o_16_vis;
4034
      c->put_no_rnd_pixels_tab[0][1] = MC_put_no_round_x_16_vis;
4035
      c->put_no_rnd_pixels_tab[0][2] = MC_put_no_round_y_16_vis;
4036
      c->put_no_rnd_pixels_tab[0][3] = MC_put_no_round_xy_16_vis;
4037

    
4038
      c->put_no_rnd_pixels_tab[1][0] = MC_put_no_round_o_8_vis;
4039
      c->put_no_rnd_pixels_tab[1][1] = MC_put_no_round_x_8_vis;
4040
      c->put_no_rnd_pixels_tab[1][2] = MC_put_no_round_y_8_vis;
4041
      c->put_no_rnd_pixels_tab[1][3] = MC_put_no_round_xy_8_vis;
4042

    
4043
      c->avg_no_rnd_pixels_tab[0][0] = MC_avg_no_round_o_16_vis;
4044
      c->avg_no_rnd_pixels_tab[0][1] = MC_avg_no_round_x_16_vis;
4045
      c->avg_no_rnd_pixels_tab[0][2] = MC_avg_no_round_y_16_vis;
4046
      c->avg_no_rnd_pixels_tab[0][3] = MC_avg_no_round_xy_16_vis;
4047

    
4048
      c->avg_no_rnd_pixels_tab[1][0] = MC_avg_no_round_o_8_vis;
4049
      c->avg_no_rnd_pixels_tab[1][1] = MC_avg_no_round_x_8_vis;
4050
      c->avg_no_rnd_pixels_tab[1][2] = MC_avg_no_round_y_8_vis;
4051
      c->avg_no_rnd_pixels_tab[1][3] = MC_avg_no_round_xy_8_vis;
4052
  }
4053
}