FFmpeg: libavcodec/sparc/dsputil

00001 /*
00002  * Copyright (C) 2003 David S. Miller <davem@redhat.com>
00003  *
00004  * This file is part of FFmpeg.
00005  *
00006  * FFmpeg is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * FFmpeg is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with FFmpeg; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019  */
00020 
00021 /* The *no_round* functions have been added by James A. Morrison, 2003,2004.
00022    The vis code from libmpeg2 was adapted for libavcodec by James A. Morrison.
00023  */
00024 
00025 #include "config.h"
00026 
00027 #include <inttypes.h>
00028 
00029 #include "libavcodec/dsputil.h"
00030 #include "dsputil_vis.h"
00031 
00032 #include "vis.h"
00033 
00034 /* The trick used in some of this file is the formula from the MMX
00035  * motion comp code, which is:
00036  *
00037  * (x+y+1)>>1 == (x|y)-((x^y)>>1)
00038  *
00039  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
00040  * We avoid overflows by masking before we do the shift, and we
00041  * implement the shift by multiplying by 1/2 using mul8x16.  So in
00042  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
00043  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
00044  * the value 0x80808080 is in f8):
00045  *
00046  *      fxor            f0,   f2, f10
00047  *      fand            f10,  f4, f10
00048  *      fmul8x16        f8,  f10, f10
00049  *      fand            f10,  f6, f10
00050  *      for             f0,   f2, f12
00051  *      fpsub16         f12, f10, f10
00052  */
00053 
00054 #define DUP4(x) {x, x, x, x}
00055 #define DUP8(x) {x, x, x, x, x, x, x, x}
00056 DECLARE_ALIGNED(8, static const int16_t, constants1)[] = DUP4 (1);
00057 DECLARE_ALIGNED(8, static const int16_t, constants2)[] = DUP4 (2);
00058 DECLARE_ALIGNED(8, static const int16_t, constants3)[] = DUP4 (3);
00059 DECLARE_ALIGNED(8, static const int16_t, constants6)[] = DUP4 (6);
00060 DECLARE_ALIGNED(8, static const int8_t, constants_fe)[] = DUP8 (0xfe);
00061 DECLARE_ALIGNED(8, static const int8_t, constants_7f)[] = DUP8 (0x7f);
00062 DECLARE_ALIGNED(8, static const int8_t, constants128)[] = DUP8 (128);
00063 DECLARE_ALIGNED(8, static const int16_t, constants256_512)[] =
00064         {256, 512, 256, 512};
00065 DECLARE_ALIGNED(8, static const int16_t, constants256_1024)[] =
00066         {256, 1024, 256, 1024};
00067 
00068 #define REF_0           0
00069 #define REF_0_1         1
00070 #define REF_2           2
00071 #define REF_2_1         3
00072 #define REF_4           4
00073 #define REF_4_1         5
00074 #define REF_6           6
00075 #define REF_6_1         7
00076 #define REF_S0          8
00077 #define REF_S0_1        9
00078 #define REF_S2          10
00079 #define REF_S2_1        11
00080 #define REF_S4          12
00081 #define REF_S4_1        13
00082 #define REF_S6          14
00083 #define REF_S6_1        15
00084 #define DST_0           16
00085 #define DST_1           17
00086 #define DST_2           18
00087 #define DST_3           19
00088 #define CONST_1         20
00089 #define CONST_2         20
00090 #define CONST_3         20
00091 #define CONST_6         20
00092 #define MASK_fe         20
00093 #define CONST_128       22
00094 #define CONST_256       22
00095 #define CONST_512       22
00096 #define CONST_1024      22
00097 #define TMP0            24
00098 #define TMP1            25
00099 #define TMP2            26
00100 #define TMP3            27
00101 #define TMP4            28
00102 #define TMP5            29
00103 #define ZERO            30
00104 #define MASK_7f         30
00105 
00106 #define TMP6            32
00107 #define TMP8            34
00108 #define TMP10           36
00109 #define TMP12           38
00110 #define TMP14           40
00111 #define TMP16           42
00112 #define TMP18           44
00113 #define TMP20           46
00114 #define TMP22           48
00115 #define TMP24           50
00116 #define TMP26           52
00117 #define TMP28           54
00118 #define TMP30           56
00119 #define TMP32           58
00120 
00121 static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * ref,
00122                              const int stride, int height)
00123 {
00124         ref = vis_alignaddr(ref);
00125         do {    /* 5 cycles */
00126                 vis_ld64(ref[0], TMP0);
00127 
00128                 vis_ld64_2(ref, 8, TMP2);
00129 
00130                 vis_ld64_2(ref, 16, TMP4);
00131                 ref += stride;
00132 
00133                 vis_faligndata(TMP0, TMP2, REF_0);
00134                 vis_st64(REF_0, dest[0]);
00135 
00136                 vis_faligndata(TMP2, TMP4, REF_2);
00137                 vis_st64_2(REF_2, dest, 8);
00138                 dest += stride;
00139         } while (--height);
00140 }
00141 
00142 static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * ref,
00143                             const int stride, int height)
00144 {
00145         ref = vis_alignaddr(ref);
00146         do {    /* 4 cycles */
00147                 vis_ld64(ref[0], TMP0);
00148 
00149                 vis_ld64(ref[8], TMP2);
00150                 ref += stride;
00151 
00152                 /* stall */
00153 
00154                 vis_faligndata(TMP0, TMP2, REF_0);
00155                 vis_st64(REF_0, dest[0]);
00156                 dest += stride;
00157         } while (--height);
00158 }
00159 
00160 
00161 static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * ref,
00162                              const int stride, int height)
00163 {
00164         int stride_8 = stride + 8;
00165 
00166         ref = vis_alignaddr(ref);
00167 
00168         vis_ld64(ref[0], TMP0);
00169 
00170         vis_ld64(ref[8], TMP2);
00171 
00172         vis_ld64(ref[16], TMP4);
00173 
00174         vis_ld64(dest[0], DST_0);
00175 
00176         vis_ld64(dest[8], DST_2);
00177 
00178         vis_ld64(constants_fe[0], MASK_fe);
00179         vis_faligndata(TMP0, TMP2, REF_0);
00180 
00181         vis_ld64(constants_7f[0], MASK_7f);
00182         vis_faligndata(TMP2, TMP4, REF_2);
00183 
00184         vis_ld64(constants128[0], CONST_128);
00185 
00186         ref += stride;
00187         height = (height >> 1) - 1;
00188 
00189         do {    /* 24 cycles */
00190                 vis_ld64(ref[0], TMP0);
00191                 vis_xor(DST_0, REF_0, TMP6);
00192 
00193                 vis_ld64_2(ref, 8, TMP2);
00194                 vis_and(TMP6, MASK_fe, TMP6);
00195 
00196                 vis_ld64_2(ref, 16, TMP4);
00197                 ref += stride;
00198                 vis_mul8x16(CONST_128, TMP6, TMP6);
00199                 vis_xor(DST_2, REF_2, TMP8);
00200 
00201                 vis_and(TMP8, MASK_fe, TMP8);
00202 
00203                 vis_or(DST_0, REF_0, TMP10);
00204                 vis_ld64_2(dest, stride, DST_0);
00205                 vis_mul8x16(CONST_128, TMP8, TMP8);
00206 
00207                 vis_or(DST_2, REF_2, TMP12);
00208                 vis_ld64_2(dest, stride_8, DST_2);
00209 
00210                 vis_ld64(ref[0], TMP14);
00211                 vis_and(TMP6, MASK_7f, TMP6);
00212 
00213                 vis_and(TMP8, MASK_7f, TMP8);
00214 
00215                 vis_psub16(TMP10, TMP6, TMP6);
00216                 vis_st64(TMP6, dest[0]);
00217 
00218                 vis_psub16(TMP12, TMP8, TMP8);
00219                 vis_st64_2(TMP8, dest, 8);
00220 
00221                 dest += stride;
00222                 vis_ld64_2(ref, 8, TMP16);
00223                 vis_faligndata(TMP0, TMP2, REF_0);
00224 
00225                 vis_ld64_2(ref, 16, TMP18);
00226                 vis_faligndata(TMP2, TMP4, REF_2);
00227                 ref += stride;
00228 
00229                 vis_xor(DST_0, REF_0, TMP20);
00230 
00231                 vis_and(TMP20, MASK_fe, TMP20);
00232 
00233                 vis_xor(DST_2, REF_2, TMP22);
00234                 vis_mul8x16(CONST_128, TMP20, TMP20);
00235 
00236                 vis_and(TMP22, MASK_fe, TMP22);
00237 
00238                 vis_or(DST_0, REF_0, TMP24);
00239                 vis_mul8x16(CONST_128, TMP22, TMP22);
00240 
00241                 vis_or(DST_2, REF_2, TMP26);
00242 
00243                 vis_ld64_2(dest, stride, DST_0);
00244                 vis_faligndata(TMP14, TMP16, REF_0);
00245 
00246                 vis_ld64_2(dest, stride_8, DST_2);
00247                 vis_faligndata(TMP16, TMP18, REF_2);
00248 
00249                 vis_and(TMP20, MASK_7f, TMP20);
00250 
00251                 vis_and(TMP22, MASK_7f, TMP22);
00252 
00253                 vis_psub16(TMP24, TMP20, TMP20);
00254                 vis_st64(TMP20, dest[0]);
00255 
00256                 vis_psub16(TMP26, TMP22, TMP22);
00257                 vis_st64_2(TMP22, dest, 8);
00258                 dest += stride;
00259         } while (--height);
00260 
00261         vis_ld64(ref[0], TMP0);
00262         vis_xor(DST_0, REF_0, TMP6);
00263 
00264         vis_ld64_2(ref, 8, TMP2);
00265         vis_and(TMP6, MASK_fe, TMP6);
00266 
00267         vis_ld64_2(ref, 16, TMP4);
00268         vis_mul8x16(CONST_128, TMP6, TMP6);
00269         vis_xor(DST_2, REF_2, TMP8);
00270 
00271         vis_and(TMP8, MASK_fe, TMP8);
00272 
00273         vis_or(DST_0, REF_0, TMP10);
00274         vis_ld64_2(dest, stride, DST_0);
00275         vis_mul8x16(CONST_128, TMP8, TMP8);
00276 
00277         vis_or(DST_2, REF_2, TMP12);
00278         vis_ld64_2(dest, stride_8, DST_2);
00279 
00280         vis_ld64(ref[0], TMP14);
00281         vis_and(TMP6, MASK_7f, TMP6);
00282 
00283         vis_and(TMP8, MASK_7f, TMP8);
00284 
00285         vis_psub16(TMP10, TMP6, TMP6);
00286         vis_st64(TMP6, dest[0]);
00287 
00288         vis_psub16(TMP12, TMP8, TMP8);
00289         vis_st64_2(TMP8, dest, 8);
00290 
00291         dest += stride;
00292         vis_faligndata(TMP0, TMP2, REF_0);
00293 
00294         vis_faligndata(TMP2, TMP4, REF_2);
00295 
00296         vis_xor(DST_0, REF_0, TMP20);
00297 
00298         vis_and(TMP20, MASK_fe, TMP20);
00299 
00300         vis_xor(DST_2, REF_2, TMP22);
00301         vis_mul8x16(CONST_128, TMP20, TMP20);
00302 
00303         vis_and(TMP22, MASK_fe, TMP22);
00304 
00305         vis_or(DST_0, REF_0, TMP24);
00306         vis_mul8x16(CONST_128, TMP22, TMP22);
00307 
00308         vis_or(DST_2, REF_2, TMP26);
00309 
00310         vis_and(TMP20, MASK_7f, TMP20);
00311 
00312         vis_and(TMP22, MASK_7f, TMP22);
00313 
00314         vis_psub16(TMP24, TMP20, TMP20);
00315         vis_st64(TMP20, dest[0]);
00316 
00317         vis_psub16(TMP26, TMP22, TMP22);
00318         vis_st64_2(TMP22, dest, 8);
00319 }
00320 
00321 static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * ref,
00322                             const int stride, int height)
00323 {
00324         ref = vis_alignaddr(ref);
00325 
00326         vis_ld64(ref[0], TMP0);
00327 
00328         vis_ld64(ref[8], TMP2);
00329 
00330         vis_ld64(dest[0], DST_0);
00331 
00332         vis_ld64(constants_fe[0], MASK_fe);
00333 
00334         vis_ld64(constants_7f[0], MASK_7f);
00335         vis_faligndata(TMP0, TMP2, REF_0);
00336 
00337         vis_ld64(constants128[0], CONST_128);
00338 
00339         ref += stride;
00340         height = (height >> 1) - 1;
00341 
00342         do {    /* 12 cycles */
00343                 vis_ld64(ref[0], TMP0);
00344                 vis_xor(DST_0, REF_0, TMP4);
00345 
00346                 vis_ld64(ref[8], TMP2);
00347                 vis_and(TMP4, MASK_fe, TMP4);
00348 
00349                 vis_or(DST_0, REF_0, TMP6);
00350                 vis_ld64_2(dest, stride, DST_0);
00351                 ref += stride;
00352                 vis_mul8x16(CONST_128, TMP4, TMP4);
00353 
00354                 vis_ld64(ref[0], TMP12);
00355                 vis_faligndata(TMP0, TMP2, REF_0);
00356 
00357                 vis_ld64(ref[8], TMP2);
00358                 vis_xor(DST_0, REF_0, TMP0);
00359                 ref += stride;
00360 
00361                 vis_and(TMP0, MASK_fe, TMP0);
00362 
00363                 vis_and(TMP4, MASK_7f, TMP4);
00364 
00365                 vis_psub16(TMP6, TMP4, TMP4);
00366                 vis_st64(TMP4, dest[0]);
00367                 dest += stride;
00368                 vis_mul8x16(CONST_128, TMP0, TMP0);
00369 
00370                 vis_or(DST_0, REF_0, TMP6);
00371                 vis_ld64_2(dest, stride, DST_0);
00372 
00373                 vis_faligndata(TMP12, TMP2, REF_0);
00374 
00375                 vis_and(TMP0, MASK_7f, TMP0);
00376 
00377                 vis_psub16(TMP6, TMP0, TMP4);
00378                 vis_st64(TMP4, dest[0]);
00379                 dest += stride;
00380         } while (--height);
00381 
00382         vis_ld64(ref[0], TMP0);
00383         vis_xor(DST_0, REF_0, TMP4);
00384 
00385         vis_ld64(ref[8], TMP2);
00386         vis_and(TMP4, MASK_fe, TMP4);
00387 
00388         vis_or(DST_0, REF_0, TMP6);
00389         vis_ld64_2(dest, stride, DST_0);
00390         vis_mul8x16(CONST_128, TMP4, TMP4);
00391 
00392         vis_faligndata(TMP0, TMP2, REF_0);
00393 
00394         vis_xor(DST_0, REF_0, TMP0);
00395 
00396         vis_and(TMP0, MASK_fe, TMP0);
00397 
00398         vis_and(TMP4, MASK_7f, TMP4);
00399 
00400         vis_psub16(TMP6, TMP4, TMP4);
00401         vis_st64(TMP4, dest[0]);
00402         dest += stride;
00403         vis_mul8x16(CONST_128, TMP0, TMP0);
00404 
00405         vis_or(DST_0, REF_0, TMP6);
00406 
00407         vis_and(TMP0, MASK_7f, TMP0);
00408 
00409         vis_psub16(TMP6, TMP0, TMP4);
00410         vis_st64(TMP4, dest[0]);
00411 }
00412 
00413 static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * ref,
00414                              const int stride, int height)
00415 {
00416         unsigned long off = (unsigned long) ref & 0x7;
00417         unsigned long off_plus_1 = off + 1;
00418 
00419         ref = vis_alignaddr(ref);
00420 
00421         vis_ld64(ref[0],    TMP0);
00422 
00423         vis_ld64_2(ref, 8,  TMP2);
00424 
00425         vis_ld64_2(ref, 16, TMP4);
00426 
00427         vis_ld64(constants_fe[0], MASK_fe);
00428 
00429         vis_ld64(constants_7f[0], MASK_7f);
00430         vis_faligndata(TMP0, TMP2, REF_0);
00431 
00432         vis_ld64(constants128[0], CONST_128);
00433         vis_faligndata(TMP2, TMP4, REF_4);
00434 
00435         if (off != 0x7) {
00436                 vis_alignaddr_g0((void *)off_plus_1);
00437                 vis_faligndata(TMP0, TMP2, REF_2);
00438                 vis_faligndata(TMP2, TMP4, REF_6);
00439         } else {
00440                 vis_src1(TMP2, REF_2);
00441                 vis_src1(TMP4, REF_6);
00442         }
00443 
00444         ref += stride;
00445         height = (height >> 1) - 1;
00446 
00447         do {    /* 34 cycles */
00448                 vis_ld64(ref[0],    TMP0);
00449                 vis_xor(REF_0, REF_2, TMP6);
00450 
00451                 vis_ld64_2(ref, 8,  TMP2);
00452                 vis_xor(REF_4, REF_6, TMP8);
00453 
00454                 vis_ld64_2(ref, 16, TMP4);
00455                 vis_and(TMP6, MASK_fe, TMP6);
00456                 ref += stride;
00457 
00458                 vis_ld64(ref[0],    TMP14);
00459                 vis_mul8x16(CONST_128, TMP6, TMP6);
00460                 vis_and(TMP8, MASK_fe, TMP8);
00461 
00462                 vis_ld64_2(ref, 8,  TMP16);
00463                 vis_mul8x16(CONST_128, TMP8, TMP8);
00464                 vis_or(REF_0, REF_2, TMP10);
00465 
00466                 vis_ld64_2(ref, 16, TMP18);
00467                 ref += stride;
00468                 vis_or(REF_4, REF_6, TMP12);
00469 
00470                 vis_alignaddr_g0((void *)off);
00471 
00472                 vis_faligndata(TMP0, TMP2, REF_0);
00473 
00474                 vis_faligndata(TMP2, TMP4, REF_4);
00475 
00476                 if (off != 0x7) {
00477                         vis_alignaddr_g0((void *)off_plus_1);
00478                         vis_faligndata(TMP0, TMP2, REF_2);
00479                         vis_faligndata(TMP2, TMP4, REF_6);
00480                 } else {
00481                         vis_src1(TMP2, REF_2);
00482                         vis_src1(TMP4, REF_6);
00483                 }
00484 
00485                 vis_and(TMP6, MASK_7f, TMP6);
00486 
00487                 vis_and(TMP8, MASK_7f, TMP8);
00488 
00489                 vis_psub16(TMP10, TMP6, TMP6);
00490                 vis_st64(TMP6, dest[0]);
00491 
00492                 vis_psub16(TMP12, TMP8, TMP8);
00493                 vis_st64_2(TMP8, dest, 8);
00494                 dest += stride;
00495 
00496                 vis_xor(REF_0, REF_2, TMP6);
00497 
00498                 vis_xor(REF_4, REF_6, TMP8);
00499 
00500                 vis_and(TMP6, MASK_fe, TMP6);
00501 
00502                 vis_mul8x16(CONST_128, TMP6, TMP6);
00503                 vis_and(TMP8, MASK_fe, TMP8);
00504 
00505                 vis_mul8x16(CONST_128, TMP8, TMP8);
00506                 vis_or(REF_0, REF_2, TMP10);
00507 
00508                 vis_or(REF_4, REF_6, TMP12);
00509 
00510                 vis_alignaddr_g0((void *)off);
00511 
00512                 vis_faligndata(TMP14, TMP16, REF_0);
00513 
00514                 vis_faligndata(TMP16, TMP18, REF_4);
00515 
00516                 if (off != 0x7) {
00517                         vis_alignaddr_g0((void *)off_plus_1);
00518                         vis_faligndata(TMP14, TMP16, REF_2);
00519                         vis_faligndata(TMP16, TMP18, REF_6);
00520                 } else {
00521                         vis_src1(TMP16, REF_2);
00522                         vis_src1(TMP18, REF_6);
00523                 }
00524 
00525                 vis_and(TMP6, MASK_7f, TMP6);
00526 
00527                 vis_and(TMP8, MASK_7f, TMP8);
00528 
00529                 vis_psub16(TMP10, TMP6, TMP6);
00530                 vis_st64(TMP6, dest[0]);
00531 
00532                 vis_psub16(TMP12, TMP8, TMP8);
00533                 vis_st64_2(TMP8, dest, 8);
00534                 dest += stride;
00535         } while (--height);
00536 
00537         vis_ld64(ref[0],    TMP0);
00538         vis_xor(REF_0, REF_2, TMP6);
00539 
00540         vis_ld64_2(ref, 8,  TMP2);
00541         vis_xor(REF_4, REF_6, TMP8);
00542 
00543         vis_ld64_2(ref, 16, TMP4);
00544         vis_and(TMP6, MASK_fe, TMP6);
00545 
00546         vis_mul8x16(CONST_128, TMP6, TMP6);
00547         vis_and(TMP8, MASK_fe, TMP8);
00548 
00549         vis_mul8x16(CONST_128, TMP8, TMP8);
00550         vis_or(REF_0, REF_2, TMP10);
00551 
00552         vis_or(REF_4, REF_6, TMP12);
00553 
00554         vis_alignaddr_g0((void *)off);
00555 
00556         vis_faligndata(TMP0, TMP2, REF_0);
00557 
00558         vis_faligndata(TMP2, TMP4, REF_4);
00559 
00560         if (off != 0x7) {
00561                 vis_alignaddr_g0((void *)off_plus_1);
00562                 vis_faligndata(TMP0, TMP2, REF_2);
00563                 vis_faligndata(TMP2, TMP4, REF_6);
00564         } else {
00565                 vis_src1(TMP2, REF_2);
00566                 vis_src1(TMP4, REF_6);
00567         }
00568 
00569         vis_and(TMP6, MASK_7f, TMP6);
00570 
00571         vis_and(TMP8, MASK_7f, TMP8);
00572 
00573         vis_psub16(TMP10, TMP6, TMP6);
00574         vis_st64(TMP6, dest[0]);
00575 
00576         vis_psub16(TMP12, TMP8, TMP8);
00577         vis_st64_2(TMP8, dest, 8);
00578         dest += stride;
00579 
00580         vis_xor(REF_0, REF_2, TMP6);
00581 
00582         vis_xor(REF_4, REF_6, TMP8);
00583 
00584         vis_and(TMP6, MASK_fe, TMP6);
00585 
00586         vis_mul8x16(CONST_128, TMP6, TMP6);
00587         vis_and(TMP8, MASK_fe, TMP8);
00588 
00589         vis_mul8x16(CONST_128, TMP8, TMP8);
00590         vis_or(REF_0, REF_2, TMP10);
00591 
00592         vis_or(REF_4, REF_6, TMP12);
00593 
00594         vis_and(TMP6, MASK_7f, TMP6);
00595 
00596         vis_and(TMP8, MASK_7f, TMP8);
00597 
00598         vis_psub16(TMP10, TMP6, TMP6);
00599         vis_st64(TMP6, dest[0]);
00600 
00601         vis_psub16(TMP12, TMP8, TMP8);
00602         vis_st64_2(TMP8, dest, 8);
00603 }
00604 
00605 static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * ref,
00606                             const int stride, int height)
00607 {
00608         unsigned long off = (unsigned long) ref & 0x7;
00609         unsigned long off_plus_1 = off + 1;
00610 
00611         ref = vis_alignaddr(ref);
00612 
00613         vis_ld64(ref[0], TMP0);
00614 
00615         vis_ld64(ref[8], TMP2);
00616 
00617         vis_ld64(constants_fe[0], MASK_fe);
00618 
00619         vis_ld64(constants_7f[0], MASK_7f);
00620 
00621         vis_ld64(constants128[0], CONST_128);
00622         vis_faligndata(TMP0, TMP2, REF_0);
00623 
00624         if (off != 0x7) {
00625                 vis_alignaddr_g0((void *)off_plus_1);
00626                 vis_faligndata(TMP0, TMP2, REF_2);
00627         } else {
00628                 vis_src1(TMP2, REF_2);
00629         }
00630 
00631         ref += stride;
00632         height = (height >> 1) - 1;
00633 
00634         do {    /* 20 cycles */
00635                 vis_ld64(ref[0], TMP0);
00636                 vis_xor(REF_0, REF_2, TMP4);
00637 
00638                 vis_ld64_2(ref, 8, TMP2);
00639                 vis_and(TMP4, MASK_fe, TMP4);
00640                 ref += stride;
00641 
00642                 vis_ld64(ref[0], TMP8);
00643                 vis_or(REF_0, REF_2, TMP6);
00644                 vis_mul8x16(CONST_128, TMP4, TMP4);
00645 
00646                 vis_alignaddr_g0((void *)off);
00647 
00648                 vis_ld64_2(ref, 8, TMP10);
00649                 ref += stride;
00650                 vis_faligndata(TMP0, TMP2, REF_0);
00651 
00652                 if (off != 0x7) {
00653                         vis_alignaddr_g0((void *)off_plus_1);
00654                         vis_faligndata(TMP0, TMP2, REF_2);
00655                 } else {
00656                         vis_src1(TMP2, REF_2);
00657                 }
00658 
00659                 vis_and(TMP4, MASK_7f, TMP4);
00660 
00661                 vis_psub16(TMP6, TMP4, DST_0);
00662                 vis_st64(DST_0, dest[0]);
00663                 dest += stride;
00664 
00665                 vis_xor(REF_0, REF_2, TMP12);
00666 
00667                 vis_and(TMP12, MASK_fe, TMP12);
00668 
00669                 vis_or(REF_0, REF_2, TMP14);
00670                 vis_mul8x16(CONST_128, TMP12, TMP12);
00671 
00672                 vis_alignaddr_g0((void *)off);
00673                 vis_faligndata(TMP8, TMP10, REF_0);
00674                 if (off != 0x7) {
00675                         vis_alignaddr_g0((void *)off_plus_1);
00676                         vis_faligndata(TMP8, TMP10, REF_2);
00677                 } else {
00678                         vis_src1(TMP10, REF_2);
00679                 }
00680 
00681                 vis_and(TMP12, MASK_7f, TMP12);
00682 
00683                 vis_psub16(TMP14, TMP12, DST_0);
00684                 vis_st64(DST_0, dest[0]);
00685                 dest += stride;
00686         } while (--height);
00687 
00688         vis_ld64(ref[0], TMP0);
00689         vis_xor(REF_0, REF_2, TMP4);
00690 
00691         vis_ld64_2(ref, 8, TMP2);
00692         vis_and(TMP4, MASK_fe, TMP4);
00693 
00694         vis_or(REF_0, REF_2, TMP6);
00695         vis_mul8x16(CONST_128, TMP4, TMP4);
00696 
00697         vis_alignaddr_g0((void *)off);
00698 
00699         vis_faligndata(TMP0, TMP2, REF_0);
00700 
00701         if (off != 0x7) {
00702                 vis_alignaddr_g0((void *)off_plus_1);
00703                 vis_faligndata(TMP0, TMP2, REF_2);
00704         } else {
00705                 vis_src1(TMP2, REF_2);
00706         }
00707 
00708         vis_and(TMP4, MASK_7f, TMP4);
00709 
00710         vis_psub16(TMP6, TMP4, DST_0);
00711         vis_st64(DST_0, dest[0]);
00712         dest += stride;
00713 
00714         vis_xor(REF_0, REF_2, TMP12);
00715 
00716         vis_and(TMP12, MASK_fe, TMP12);
00717 
00718         vis_or(REF_0, REF_2, TMP14);
00719         vis_mul8x16(CONST_128, TMP12, TMP12);
00720 
00721         vis_and(TMP12, MASK_7f, TMP12);
00722 
00723         vis_psub16(TMP14, TMP12, DST_0);
00724         vis_st64(DST_0, dest[0]);
00725         dest += stride;
00726 }
00727 
00728 static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * ref,
00729                              const int stride, int height)
00730 {
00731         unsigned long off = (unsigned long) ref & 0x7;
00732         unsigned long off_plus_1 = off + 1;
00733 
00734         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
00735 
00736         vis_ld64(constants3[0], CONST_3);
00737         vis_fzero(ZERO);
00738         vis_ld64(constants256_512[0], CONST_256);
00739 
00740         ref = vis_alignaddr(ref);
00741         do {    /* 26 cycles */
00742                 vis_ld64(ref[0], TMP0);
00743 
00744                 vis_ld64(ref[8], TMP2);
00745 
00746                 vis_alignaddr_g0((void *)off);
00747 
00748                 vis_ld64(ref[16], TMP4);
00749 
00750                 vis_ld64(dest[0], DST_0);
00751                 vis_faligndata(TMP0, TMP2, REF_0);
00752 
00753                 vis_ld64(dest[8], DST_2);
00754                 vis_faligndata(TMP2, TMP4, REF_4);
00755 
00756                 if (off != 0x7) {
00757                         vis_alignaddr_g0((void *)off_plus_1);
00758                         vis_faligndata(TMP0, TMP2, REF_2);
00759                         vis_faligndata(TMP2, TMP4, REF_6);
00760                 } else {
00761                         vis_src1(TMP2, REF_2);
00762                         vis_src1(TMP4, REF_6);
00763                 }
00764 
00765                 vis_mul8x16au(REF_0,   CONST_256, TMP0);
00766 
00767                 vis_pmerge(ZERO,     REF_2,     TMP4);
00768                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
00769 
00770                 vis_pmerge(ZERO, REF_2_1, TMP6);
00771 
00772                 vis_padd16(TMP0, TMP4, TMP0);
00773 
00774                 vis_mul8x16al(DST_0,   CONST_512, TMP4);
00775                 vis_padd16(TMP2, TMP6, TMP2);
00776 
00777                 vis_mul8x16al(DST_1,   CONST_512, TMP6);
00778 
00779                 vis_mul8x16au(REF_6,   CONST_256, TMP12);
00780 
00781                 vis_padd16(TMP0, TMP4, TMP0);
00782                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
00783 
00784                 vis_padd16(TMP2, TMP6, TMP2);
00785                 vis_mul8x16au(REF_4,   CONST_256, TMP16);
00786 
00787                 vis_padd16(TMP0, CONST_3, TMP8);
00788                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);
00789 
00790                 vis_padd16(TMP2, CONST_3, TMP10);
00791                 vis_pack16(TMP8, DST_0);
00792 
00793                 vis_pack16(TMP10, DST_1);
00794                 vis_padd16(TMP16, TMP12, TMP0);
00795 
00796                 vis_st64(DST_0, dest[0]);
00797                 vis_mul8x16al(DST_2,   CONST_512, TMP4);
00798                 vis_padd16(TMP18, TMP14, TMP2);
00799 
00800                 vis_mul8x16al(DST_3,   CONST_512, TMP6);
00801                 vis_padd16(TMP0, CONST_3, TMP0);
00802 
00803                 vis_padd16(TMP2, CONST_3, TMP2);
00804 
00805                 vis_padd16(TMP0, TMP4, TMP0);
00806 
00807                 vis_padd16(TMP2, TMP6, TMP2);
00808                 vis_pack16(TMP0, DST_2);
00809 
00810                 vis_pack16(TMP2, DST_3);
00811                 vis_st64(DST_2, dest[8]);
00812 
00813                 ref += stride;
00814                 dest += stride;
00815         } while (--height);
00816 }
00817 
00818 static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * ref,
00819                             const int stride, int height)
00820 {
00821         unsigned long off = (unsigned long) ref & 0x7;
00822         unsigned long off_plus_1 = off + 1;
00823         int stride_times_2 = stride << 1;
00824 
00825         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
00826 
00827         vis_ld64(constants3[0], CONST_3);
00828         vis_fzero(ZERO);
00829         vis_ld64(constants256_512[0], CONST_256);
00830 
00831         ref = vis_alignaddr(ref);
00832         height >>= 2;
00833         do {    /* 47 cycles */
00834                 vis_ld64(ref[0],   TMP0);
00835 
00836                 vis_ld64_2(ref, 8, TMP2);
00837                 ref += stride;
00838 
00839                 vis_alignaddr_g0((void *)off);
00840 
00841                 vis_ld64(ref[0],   TMP4);
00842                 vis_faligndata(TMP0, TMP2, REF_0);
00843 
00844                 vis_ld64_2(ref, 8, TMP6);
00845                 ref += stride;
00846 
00847                 vis_ld64(ref[0],   TMP8);
00848 
00849                 vis_ld64_2(ref, 8, TMP10);
00850                 ref += stride;
00851                 vis_faligndata(TMP4, TMP6, REF_4);
00852 
00853                 vis_ld64(ref[0],   TMP12);
00854 
00855                 vis_ld64_2(ref, 8, TMP14);
00856                 ref += stride;
00857                 vis_faligndata(TMP8, TMP10, REF_S0);
00858 
00859                 vis_faligndata(TMP12, TMP14, REF_S4);
00860 
00861                 if (off != 0x7) {
00862                         vis_alignaddr_g0((void *)off_plus_1);
00863 
00864                         vis_ld64(dest[0], DST_0);
00865                         vis_faligndata(TMP0, TMP2, REF_2);
00866 
00867                         vis_ld64_2(dest, stride, DST_2);
00868                         vis_faligndata(TMP4, TMP6, REF_6);
00869 
00870                         vis_faligndata(TMP8, TMP10, REF_S2);
00871 
00872                         vis_faligndata(TMP12, TMP14, REF_S6);
00873                 } else {
00874                         vis_ld64(dest[0], DST_0);
00875                         vis_src1(TMP2, REF_2);
00876 
00877                         vis_ld64_2(dest, stride, DST_2);
00878                         vis_src1(TMP6, REF_6);
00879 
00880                         vis_src1(TMP10, REF_S2);
00881 
00882                         vis_src1(TMP14, REF_S6);
00883                 }
00884 
00885                 vis_pmerge(ZERO,     REF_0,     TMP0);
00886                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
00887 
00888                 vis_pmerge(ZERO,     REF_2,     TMP4);
00889                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);
00890 
00891                 vis_padd16(TMP0, CONST_3, TMP0);
00892                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
00893 
00894                 vis_padd16(TMP2, CONST_3, TMP2);
00895                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
00896 
00897                 vis_padd16(TMP0, TMP4, TMP0);
00898                 vis_mul8x16au(REF_4, CONST_256, TMP8);
00899 
00900                 vis_padd16(TMP2, TMP6, TMP2);
00901                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);
00902 
00903                 vis_padd16(TMP0, TMP16, TMP0);
00904                 vis_mul8x16au(REF_6, CONST_256, TMP12);
00905 
00906                 vis_padd16(TMP2, TMP18, TMP2);
00907                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
00908 
00909                 vis_padd16(TMP8, CONST_3, TMP8);
00910                 vis_mul8x16al(DST_2, CONST_512, TMP16);
00911 
00912                 vis_padd16(TMP8, TMP12, TMP8);
00913                 vis_mul8x16al(DST_3, CONST_512, TMP18);
00914 
00915                 vis_padd16(TMP10, TMP14, TMP10);
00916                 vis_pack16(TMP0, DST_0);
00917 
00918                 vis_pack16(TMP2, DST_1);
00919                 vis_st64(DST_0, dest[0]);
00920                 dest += stride;
00921                 vis_padd16(TMP10, CONST_3, TMP10);
00922 
00923                 vis_ld64_2(dest, stride, DST_0);
00924                 vis_padd16(TMP8, TMP16, TMP8);
00925 
00926                 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
00927                 vis_padd16(TMP10, TMP18, TMP10);
00928                 vis_pack16(TMP8, DST_2);
00929 
00930                 vis_pack16(TMP10, DST_3);
00931                 vis_st64(DST_2, dest[0]);
00932                 dest += stride;
00933 
00934                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
00935                 vis_pmerge(ZERO,     REF_S0,     TMP0);
00936 
00937                 vis_pmerge(ZERO,     REF_S2,     TMP24);
00938                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
00939 
00940                 vis_padd16(TMP0, CONST_3, TMP0);
00941                 vis_mul8x16au(REF_S4, CONST_256, TMP8);
00942 
00943                 vis_padd16(TMP2, CONST_3, TMP2);
00944                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
00945 
00946                 vis_padd16(TMP0, TMP24, TMP0);
00947                 vis_mul8x16au(REF_S6, CONST_256, TMP12);
00948 
00949                 vis_padd16(TMP2, TMP6, TMP2);
00950                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
00951 
00952                 vis_padd16(TMP8, CONST_3, TMP8);
00953                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
00954 
00955                 vis_padd16(TMP10, CONST_3, TMP10);
00956                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
00957 
00958                 vis_padd16(TMP8, TMP12, TMP8);
00959                 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
00960 
00961                 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
00962                 vis_padd16(TMP0, TMP16, TMP0);
00963 
00964                 vis_padd16(TMP2, TMP18, TMP2);
00965                 vis_pack16(TMP0, DST_0);
00966 
00967                 vis_padd16(TMP10, TMP14, TMP10);
00968                 vis_pack16(TMP2, DST_1);
00969                 vis_st64(DST_0, dest[0]);
00970                 dest += stride;
00971 
00972                 vis_padd16(TMP8, TMP20, TMP8);
00973 
00974                 vis_padd16(TMP10, TMP22, TMP10);
00975                 vis_pack16(TMP8, DST_2);
00976 
00977                 vis_pack16(TMP10, DST_3);
00978                 vis_st64(DST_2, dest[0]);
00979                 dest += stride;
00980         } while (--height);
00981 }
00982 
00983 static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * ref,
00984                              const int stride, int height)
00985 {
00986         ref = vis_alignaddr(ref);
00987         vis_ld64(ref[0], TMP0);
00988 
00989         vis_ld64_2(ref, 8, TMP2);
00990 
00991         vis_ld64_2(ref, 16, TMP4);
00992         ref += stride;
00993 
00994         vis_ld64(ref[0], TMP6);
00995         vis_faligndata(TMP0, TMP2, REF_0);
00996 
00997         vis_ld64_2(ref, 8, TMP8);
00998         vis_faligndata(TMP2, TMP4, REF_4);
00999 
01000         vis_ld64_2(ref, 16, TMP10);
01001         ref += stride;
01002 
01003         vis_ld64(constants_fe[0], MASK_fe);
01004         vis_faligndata(TMP6, TMP8, REF_2);
01005 
01006         vis_ld64(constants_7f[0], MASK_7f);
01007         vis_faligndata(TMP8, TMP10, REF_6);
01008 
01009         vis_ld64(constants128[0], CONST_128);
01010         height = (height >> 1) - 1;
01011         do {    /* 24 cycles */
01012                 vis_ld64(ref[0], TMP0);
01013                 vis_xor(REF_0, REF_2, TMP12);
01014 
01015                 vis_ld64_2(ref, 8, TMP2);
01016                 vis_xor(REF_4, REF_6, TMP16);
01017 
01018                 vis_ld64_2(ref, 16, TMP4);
01019                 ref += stride;
01020                 vis_or(REF_0, REF_2, TMP14);
01021 
01022                 vis_ld64(ref[0], TMP6);
01023                 vis_or(REF_4, REF_6, TMP18);
01024 
01025                 vis_ld64_2(ref, 8, TMP8);
01026                 vis_faligndata(TMP0, TMP2, REF_0);
01027 
01028                 vis_ld64_2(ref, 16, TMP10);
01029                 ref += stride;
01030                 vis_faligndata(TMP2, TMP4, REF_4);
01031 
01032                 vis_and(TMP12, MASK_fe, TMP12);
01033 
01034                 vis_and(TMP16, MASK_fe, TMP16);
01035                 vis_mul8x16(CONST_128, TMP12, TMP12);
01036 
01037                 vis_mul8x16(CONST_128, TMP16, TMP16);
01038                 vis_xor(REF_0, REF_2, TMP0);
01039 
01040                 vis_xor(REF_4, REF_6, TMP2);
01041 
01042                 vis_or(REF_0, REF_2, TMP20);
01043 
01044                 vis_and(TMP12, MASK_7f, TMP12);
01045 
01046                 vis_and(TMP16, MASK_7f, TMP16);
01047 
01048                 vis_psub16(TMP14, TMP12, TMP12);
01049                 vis_st64(TMP12, dest[0]);
01050 
01051                 vis_psub16(TMP18, TMP16, TMP16);
01052                 vis_st64_2(TMP16, dest, 8);
01053                 dest += stride;
01054 
01055                 vis_or(REF_4, REF_6, TMP18);
01056 
01057                 vis_and(TMP0, MASK_fe, TMP0);
01058 
01059                 vis_and(TMP2, MASK_fe, TMP2);
01060                 vis_mul8x16(CONST_128, TMP0, TMP0);
01061 
01062                 vis_faligndata(TMP6, TMP8, REF_2);
01063                 vis_mul8x16(CONST_128, TMP2, TMP2);
01064 
01065                 vis_faligndata(TMP8, TMP10, REF_6);
01066 
01067                 vis_and(TMP0, MASK_7f, TMP0);
01068 
01069                 vis_and(TMP2, MASK_7f, TMP2);
01070 
01071                 vis_psub16(TMP20, TMP0, TMP0);
01072                 vis_st64(TMP0, dest[0]);
01073 
01074                 vis_psub16(TMP18, TMP2, TMP2);
01075                 vis_st64_2(TMP2, dest, 8);
01076                 dest += stride;
01077         } while (--height);
01078 
01079         vis_ld64(ref[0], TMP0);
01080         vis_xor(REF_0, REF_2, TMP12);
01081 
01082         vis_ld64_2(ref, 8, TMP2);
01083         vis_xor(REF_4, REF_6, TMP16);
01084 
01085         vis_ld64_2(ref, 16, TMP4);
01086         vis_or(REF_0, REF_2, TMP14);
01087 
01088         vis_or(REF_4, REF_6, TMP18);
01089 
01090         vis_faligndata(TMP0, TMP2, REF_0);
01091 
01092         vis_faligndata(TMP2, TMP4, REF_4);
01093 
01094         vis_and(TMP12, MASK_fe, TMP12);
01095 
01096         vis_and(TMP16, MASK_fe, TMP16);
01097         vis_mul8x16(CONST_128, TMP12, TMP12);
01098 
01099         vis_mul8x16(CONST_128, TMP16, TMP16);
01100         vis_xor(REF_0, REF_2, TMP0);
01101 
01102         vis_xor(REF_4, REF_6, TMP2);
01103 
01104         vis_or(REF_0, REF_2, TMP20);
01105 
01106         vis_and(TMP12, MASK_7f, TMP12);
01107 
01108         vis_and(TMP16, MASK_7f, TMP16);
01109 
01110         vis_psub16(TMP14, TMP12, TMP12);
01111         vis_st64(TMP12, dest[0]);
01112 
01113         vis_psub16(TMP18, TMP16, TMP16);
01114         vis_st64_2(TMP16, dest, 8);
01115         dest += stride;
01116 
01117         vis_or(REF_4, REF_6, TMP18);
01118 
01119         vis_and(TMP0, MASK_fe, TMP0);
01120 
01121         vis_and(TMP2, MASK_fe, TMP2);
01122         vis_mul8x16(CONST_128, TMP0, TMP0);
01123 
01124         vis_mul8x16(CONST_128, TMP2, TMP2);
01125 
01126         vis_and(TMP0, MASK_7f, TMP0);
01127 
01128         vis_and(TMP2, MASK_7f, TMP2);
01129 
01130         vis_psub16(TMP20, TMP0, TMP0);
01131         vis_st64(TMP0, dest[0]);
01132 
01133         vis_psub16(TMP18, TMP2, TMP2);
01134         vis_st64_2(TMP2, dest, 8);
01135 }
01136 
01137 static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * ref,
01138                             const int stride, int height)
01139 {
01140         ref = vis_alignaddr(ref);
01141         vis_ld64(ref[0], TMP0);
01142 
01143         vis_ld64_2(ref, 8, TMP2);
01144         ref += stride;
01145 
01146         vis_ld64(ref[0], TMP4);
01147 
01148         vis_ld64_2(ref, 8, TMP6);
01149         ref += stride;
01150 
01151         vis_ld64(constants_fe[0], MASK_fe);
01152         vis_faligndata(TMP0, TMP2, REF_0);
01153 
01154         vis_ld64(constants_7f[0], MASK_7f);
01155         vis_faligndata(TMP4, TMP6, REF_2);
01156 
01157         vis_ld64(constants128[0], CONST_128);
01158         height = (height >> 1) - 1;
01159         do {    /* 12 cycles */
01160                 vis_ld64(ref[0], TMP0);
01161                 vis_xor(REF_0, REF_2, TMP4);
01162 
01163                 vis_ld64_2(ref, 8, TMP2);
01164                 ref += stride;
01165                 vis_and(TMP4, MASK_fe, TMP4);
01166 
01167                 vis_or(REF_0, REF_2, TMP6);
01168                 vis_mul8x16(CONST_128, TMP4, TMP4);
01169 
01170                 vis_faligndata(TMP0, TMP2, REF_0);
01171                 vis_ld64(ref[0], TMP0);
01172 
01173                 vis_ld64_2(ref, 8, TMP2);
01174                 ref += stride;
01175                 vis_xor(REF_0, REF_2, TMP12);
01176 
01177                 vis_and(TMP4, MASK_7f, TMP4);
01178 
01179                 vis_and(TMP12, MASK_fe, TMP12);
01180 
01181                 vis_mul8x16(CONST_128, TMP12, TMP12);
01182                 vis_or(REF_0, REF_2, TMP14);
01183 
01184                 vis_psub16(TMP6, TMP4, DST_0);
01185                 vis_st64(DST_0, dest[0]);
01186                 dest += stride;
01187 
01188                 vis_faligndata(TMP0, TMP2, REF_2);
01189 
01190                 vis_and(TMP12, MASK_7f, TMP12);
01191 
01192                 vis_psub16(TMP14, TMP12, DST_0);
01193                 vis_st64(DST_0, dest[0]);
01194                 dest += stride;
01195         } while (--height);
01196 
01197         vis_ld64(ref[0], TMP0);
01198         vis_xor(REF_0, REF_2, TMP4);
01199 
01200         vis_ld64_2(ref, 8, TMP2);
01201         vis_and(TMP4, MASK_fe, TMP4);
01202 
01203         vis_or(REF_0, REF_2, TMP6);
01204         vis_mul8x16(CONST_128, TMP4, TMP4);
01205 
01206         vis_faligndata(TMP0, TMP2, REF_0);
01207 
01208         vis_xor(REF_0, REF_2, TMP12);
01209 
01210         vis_and(TMP4, MASK_7f, TMP4);
01211 
01212         vis_and(TMP12, MASK_fe, TMP12);
01213 
01214         vis_mul8x16(CONST_128, TMP12, TMP12);
01215         vis_or(REF_0, REF_2, TMP14);
01216 
01217         vis_psub16(TMP6, TMP4, DST_0);
01218         vis_st64(DST_0, dest[0]);
01219         dest += stride;
01220 
01221         vis_and(TMP12, MASK_7f, TMP12);
01222 
01223         vis_psub16(TMP14, TMP12, DST_0);
01224         vis_st64(DST_0, dest[0]);
01225 }
01226 
01227 static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * ref,
01228                              const int stride, int height)
01229 {
01230         int stride_8 = stride + 8;
01231         int stride_16 = stride + 16;
01232 
01233         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01234 
01235         ref = vis_alignaddr(ref);
01236 
01237         vis_ld64(ref[ 0], TMP0);
01238         vis_fzero(ZERO);
01239 
01240         vis_ld64(ref[ 8], TMP2);
01241 
01242         vis_ld64(ref[16], TMP4);
01243 
01244         vis_ld64(constants3[0], CONST_3);
01245         vis_faligndata(TMP0, TMP2, REF_2);
01246 
01247         vis_ld64(constants256_512[0], CONST_256);
01248         vis_faligndata(TMP2, TMP4, REF_6);
01249         height >>= 1;
01250 
01251         do {    /* 31 cycles */
01252                 vis_ld64_2(ref, stride, TMP0);
01253                 vis_pmerge(ZERO,       REF_2,     TMP12);
01254                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);
01255 
01256                 vis_ld64_2(ref, stride_8, TMP2);
01257                 vis_pmerge(ZERO,       REF_6,     TMP16);
01258                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);
01259 
01260                 vis_ld64_2(ref, stride_16, TMP4);
01261                 ref += stride;
01262 
01263                 vis_ld64(dest[0], DST_0);
01264                 vis_faligndata(TMP0, TMP2, REF_0);
01265 
01266                 vis_ld64_2(dest, 8, DST_2);
01267                 vis_faligndata(TMP2, TMP4, REF_4);
01268 
01269                 vis_ld64_2(ref, stride, TMP6);
01270                 vis_pmerge(ZERO,     REF_0,     TMP0);
01271                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
01272 
01273                 vis_ld64_2(ref, stride_8, TMP8);
01274                 vis_pmerge(ZERO,     REF_4,     TMP4);
01275 
01276                 vis_ld64_2(ref, stride_16, TMP10);
01277                 ref += stride;
01278 
01279                 vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
01280                 vis_faligndata(TMP6, TMP8, REF_2);
01281                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
01282 
01283                 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
01284                 vis_faligndata(TMP8, TMP10, REF_6);
01285                 vis_mul8x16al(DST_0,   CONST_512, TMP20);
01286 
01287                 vis_padd16(TMP0, CONST_3, TMP0);
01288                 vis_mul8x16al(DST_1,   CONST_512, TMP22);
01289 
01290                 vis_padd16(TMP2, CONST_3, TMP2);
01291                 vis_mul8x16al(DST_2,   CONST_512, TMP24);
01292 
01293                 vis_padd16(TMP4, CONST_3, TMP4);
01294                 vis_mul8x16al(DST_3,   CONST_512, TMP26);
01295 
01296                 vis_padd16(TMP6, CONST_3, TMP6);
01297 
01298                 vis_padd16(TMP12, TMP20, TMP12);
01299                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);
01300 
01301                 vis_padd16(TMP14, TMP22, TMP14);
01302                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
01303 
01304                 vis_padd16(TMP16, TMP24, TMP16);
01305                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);
01306 
01307                 vis_padd16(TMP18, TMP26, TMP18);
01308                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
01309 
01310                 vis_padd16(TMP12, TMP0, TMP12);
01311                 vis_mul8x16au(REF_2,   CONST_256, TMP28);
01312 
01313                 vis_padd16(TMP14, TMP2, TMP14);
01314                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);
01315 
01316                 vis_padd16(TMP16, TMP4, TMP16);
01317                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);
01318 
01319                 vis_padd16(TMP18, TMP6, TMP18);
01320                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
01321 
01322                 vis_pack16(TMP12, DST_0);
01323                 vis_padd16(TMP28, TMP0, TMP12);
01324 
01325                 vis_pack16(TMP14, DST_1);
01326                 vis_st64(DST_0, dest[0]);
01327                 vis_padd16(TMP30, TMP2, TMP14);
01328 
01329                 vis_pack16(TMP16, DST_2);
01330                 vis_padd16(REF_S4, TMP4, TMP16);
01331 
01332                 vis_pack16(TMP18, DST_3);
01333                 vis_st64_2(DST_2, dest, 8);
01334                 dest += stride;
01335                 vis_padd16(REF_S6, TMP6, TMP18);
01336 
01337                 vis_padd16(TMP12, TMP20, TMP12);
01338 
01339                 vis_padd16(TMP14, TMP22, TMP14);
01340                 vis_pack16(TMP12, DST_0);
01341 
01342                 vis_padd16(TMP16, TMP24, TMP16);
01343                 vis_pack16(TMP14, DST_1);
01344                 vis_st64(DST_0, dest[0]);
01345 
01346                 vis_padd16(TMP18, TMP26, TMP18);
01347                 vis_pack16(TMP16, DST_2);
01348 
01349                 vis_pack16(TMP18, DST_3);
01350                 vis_st64_2(DST_2, dest, 8);
01351                 dest += stride;
01352         } while (--height);
01353 }
01354 
01355 static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * ref,
01356                             const int stride, int height)
01357 {
01358         int stride_8 = stride + 8;
01359 
01360         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01361 
01362         ref = vis_alignaddr(ref);
01363 
01364         vis_ld64(ref[ 0], TMP0);
01365         vis_fzero(ZERO);
01366 
01367         vis_ld64(ref[ 8], TMP2);
01368 
01369         vis_ld64(constants3[0], CONST_3);
01370         vis_faligndata(TMP0, TMP2, REF_2);
01371 
01372         vis_ld64(constants256_512[0], CONST_256);
01373 
01374         height >>= 1;
01375         do {    /* 20 cycles */
01376                 vis_ld64_2(ref, stride, TMP0);
01377                 vis_pmerge(ZERO,       REF_2,     TMP8);
01378                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);
01379 
01380                 vis_ld64_2(ref, stride_8, TMP2);
01381                 ref += stride;
01382 
01383                 vis_ld64(dest[0], DST_0);
01384 
01385                 vis_ld64_2(dest, stride, DST_2);
01386                 vis_faligndata(TMP0, TMP2, REF_0);
01387 
01388                 vis_ld64_2(ref, stride, TMP4);
01389                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
01390                 vis_pmerge(ZERO,       REF_0,     TMP12);
01391 
01392                 vis_ld64_2(ref, stride_8, TMP6);
01393                 ref += stride;
01394                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
01395                 vis_pmerge(ZERO,       REF_0_1,   TMP14);
01396 
01397                 vis_padd16(TMP12, CONST_3, TMP12);
01398                 vis_mul8x16al(DST_2,   CONST_512, TMP24);
01399 
01400                 vis_padd16(TMP14, CONST_3, TMP14);
01401                 vis_mul8x16al(DST_3,   CONST_512, TMP26);
01402 
01403                 vis_faligndata(TMP4, TMP6, REF_2);
01404 
01405                 vis_padd16(TMP8, TMP12, TMP8);
01406 
01407                 vis_padd16(TMP10, TMP14, TMP10);
01408                 vis_mul8x16au(REF_2,   CONST_256, TMP20);
01409 
01410                 vis_padd16(TMP8, TMP16, TMP0);
01411                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);
01412 
01413                 vis_padd16(TMP10, TMP18, TMP2);
01414                 vis_pack16(TMP0, DST_0);
01415 
01416                 vis_pack16(TMP2, DST_1);
01417                 vis_st64(DST_0, dest[0]);
01418                 dest += stride;
01419                 vis_padd16(TMP12, TMP20, TMP12);
01420 
01421                 vis_padd16(TMP14, TMP22, TMP14);
01422 
01423                 vis_padd16(TMP12, TMP24, TMP0);
01424 
01425                 vis_padd16(TMP14, TMP26, TMP2);
01426                 vis_pack16(TMP0, DST_2);
01427 
01428                 vis_pack16(TMP2, DST_3);
01429                 vis_st64(DST_2, dest[0]);
01430                 dest += stride;
01431         } while (--height);
01432 }
01433 
01434 static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * ref,
01435                               const int stride, int height)
01436 {
01437         unsigned long off = (unsigned long) ref & 0x7;
01438         unsigned long off_plus_1 = off + 1;
01439         int stride_8 = stride + 8;
01440         int stride_16 = stride + 16;
01441 
01442         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01443 
01444         ref = vis_alignaddr(ref);
01445 
01446         vis_ld64(ref[ 0], TMP0);
01447         vis_fzero(ZERO);
01448 
01449         vis_ld64(ref[ 8], TMP2);
01450 
01451         vis_ld64(ref[16], TMP4);
01452 
01453         vis_ld64(constants2[0], CONST_2);
01454         vis_faligndata(TMP0, TMP2, REF_S0);
01455 
01456         vis_ld64(constants256_512[0], CONST_256);
01457         vis_faligndata(TMP2, TMP4, REF_S4);
01458 
01459         if (off != 0x7) {
01460                 vis_alignaddr_g0((void *)off_plus_1);
01461                 vis_faligndata(TMP0, TMP2, REF_S2);
01462                 vis_faligndata(TMP2, TMP4, REF_S6);
01463         } else {
01464                 vis_src1(TMP2, REF_S2);
01465                 vis_src1(TMP4, REF_S6);
01466         }
01467 
01468         height >>= 1;
01469         do {
01470                 vis_ld64_2(ref, stride, TMP0);
01471                 vis_mul8x16au(REF_S0, CONST_256, TMP12);
01472                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);
01473 
01474                 vis_alignaddr_g0((void *)off);
01475 
01476                 vis_ld64_2(ref, stride_8, TMP2);
01477                 vis_mul8x16au(REF_S2, CONST_256, TMP16);
01478                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);
01479 
01480                 vis_ld64_2(ref, stride_16, TMP4);
01481                 ref += stride;
01482                 vis_mul8x16au(REF_S4, CONST_256, TMP20);
01483                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);
01484 
01485                 vis_ld64_2(ref, stride, TMP6);
01486                 vis_mul8x16au(REF_S6, CONST_256, TMP24);
01487                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);
01488 
01489                 vis_ld64_2(ref, stride_8, TMP8);
01490                 vis_faligndata(TMP0, TMP2, REF_0);
01491 
01492                 vis_ld64_2(ref, stride_16, TMP10);
01493                 ref += stride;
01494                 vis_faligndata(TMP2, TMP4, REF_4);
01495 
01496                 vis_faligndata(TMP6, TMP8, REF_S0);
01497 
01498                 vis_faligndata(TMP8, TMP10, REF_S4);
01499 
01500                 if (off != 0x7) {
01501                         vis_alignaddr_g0((void *)off_plus_1);
01502                         vis_faligndata(TMP0, TMP2, REF_2);
01503                         vis_faligndata(TMP2, TMP4, REF_6);
01504                         vis_faligndata(TMP6, TMP8, REF_S2);
01505                         vis_faligndata(TMP8, TMP10, REF_S6);
01506                 } else {
01507                         vis_src1(TMP2, REF_2);
01508                         vis_src1(TMP4, REF_6);
01509                         vis_src1(TMP8, REF_S2);
01510                         vis_src1(TMP10, REF_S6);
01511                 }
01512 
01513                 vis_mul8x16au(REF_0, CONST_256, TMP0);
01514                 vis_pmerge(ZERO,      REF_0_1,  TMP2);
01515 
01516                 vis_mul8x16au(REF_2, CONST_256, TMP4);
01517                 vis_pmerge(ZERO,      REF_2_1,  TMP6);
01518 
01519                 vis_padd16(TMP0, CONST_2, TMP8);
01520                 vis_mul8x16au(REF_4, CONST_256, TMP0);
01521 
01522                 vis_padd16(TMP2, CONST_2, TMP10);
01523                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);
01524 
01525                 vis_padd16(TMP8, TMP4, TMP8);
01526                 vis_mul8x16au(REF_6, CONST_256, TMP4);
01527 
01528                 vis_padd16(TMP10, TMP6, TMP10);
01529                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);
01530 
01531                 vis_padd16(TMP12, TMP8, TMP12);
01532 
01533                 vis_padd16(TMP14, TMP10, TMP14);
01534 
01535                 vis_padd16(TMP12, TMP16, TMP12);
01536 
01537                 vis_padd16(TMP14, TMP18, TMP14);
01538                 vis_pack16(TMP12, DST_0);
01539 
01540                 vis_pack16(TMP14, DST_1);
01541                 vis_st64(DST_0, dest[0]);
01542                 vis_padd16(TMP0, CONST_2, TMP12);
01543 
01544                 vis_mul8x16au(REF_S0, CONST_256, TMP0);
01545                 vis_padd16(TMP2, CONST_2, TMP14);
01546 
01547                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
01548                 vis_padd16(TMP12, TMP4, TMP12);
01549 
01550                 vis_mul8x16au(REF_S2, CONST_256, TMP4);
01551                 vis_padd16(TMP14, TMP6, TMP14);
01552 
01553                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
01554                 vis_padd16(TMP20, TMP12, TMP20);
01555 
01556                 vis_padd16(TMP22, TMP14, TMP22);
01557 
01558                 vis_padd16(TMP20, TMP24, TMP20);
01559 
01560                 vis_padd16(TMP22, TMP26, TMP22);
01561                 vis_pack16(TMP20, DST_2);
01562 
01563                 vis_pack16(TMP22, DST_3);
01564                 vis_st64_2(DST_2, dest, 8);
01565                 dest += stride;
01566                 vis_padd16(TMP0, TMP4, TMP24);
01567 
01568                 vis_mul8x16au(REF_S4, CONST_256, TMP0);
01569                 vis_padd16(TMP2, TMP6, TMP26);
01570 
01571                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
01572                 vis_padd16(TMP24, TMP8, TMP24);
01573 
01574                 vis_padd16(TMP26, TMP10, TMP26);
01575                 vis_pack16(TMP24, DST_0);
01576 
01577                 vis_pack16(TMP26, DST_1);
01578                 vis_st64(DST_0, dest[0]);
01579                 vis_pmerge(ZERO, REF_S6, TMP4);
01580 
01581                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);
01582 
01583                 vis_padd16(TMP0, TMP4, TMP0);
01584 
01585                 vis_padd16(TMP2, TMP6, TMP2);
01586 
01587                 vis_padd16(TMP0, TMP12, TMP0);
01588 
01589                 vis_padd16(TMP2, TMP14, TMP2);
01590                 vis_pack16(TMP0, DST_2);
01591 
01592                 vis_pack16(TMP2, DST_3);
01593                 vis_st64_2(DST_2, dest, 8);
01594                 dest += stride;
01595         } while (--height);
01596 }
01597 
01598 static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * ref,
01599                              const int stride, int height)
01600 {
01601         unsigned long off = (unsigned long) ref & 0x7;
01602         unsigned long off_plus_1 = off + 1;
01603         int stride_8 = stride + 8;
01604 
01605         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01606 
01607         ref = vis_alignaddr(ref);
01608 
01609         vis_ld64(ref[ 0], TMP0);
01610         vis_fzero(ZERO);
01611 
01612         vis_ld64(ref[ 8], TMP2);
01613 
01614         vis_ld64(constants2[0], CONST_2);
01615 
01616         vis_ld64(constants256_512[0], CONST_256);
01617         vis_faligndata(TMP0, TMP2, REF_S0);
01618 
01619         if (off != 0x7) {
01620                 vis_alignaddr_g0((void *)off_plus_1);
01621                 vis_faligndata(TMP0, TMP2, REF_S2);
01622         } else {
01623                 vis_src1(TMP2, REF_S2);
01624         }
01625 
01626         height >>= 1;
01627         do {    /* 26 cycles */
01628                 vis_ld64_2(ref, stride, TMP0);
01629                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);
01630                 vis_pmerge(ZERO,        REF_S2,    TMP12);
01631 
01632                 vis_alignaddr_g0((void *)off);
01633 
01634                 vis_ld64_2(ref, stride_8, TMP2);
01635                 ref += stride;
01636                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
01637                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);
01638 
01639                 vis_ld64_2(ref, stride, TMP4);
01640 
01641                 vis_ld64_2(ref, stride_8, TMP6);
01642                 ref += stride;
01643                 vis_faligndata(TMP0, TMP2, REF_S4);
01644 
01645                 vis_pmerge(ZERO, REF_S4, TMP18);
01646 
01647                 vis_pmerge(ZERO, REF_S4_1, TMP20);
01648 
01649                 vis_faligndata(TMP4, TMP6, REF_S0);
01650 
01651                 if (off != 0x7) {
01652                         vis_alignaddr_g0((void *)off_plus_1);
01653                         vis_faligndata(TMP0, TMP2, REF_S6);
01654                         vis_faligndata(TMP4, TMP6, REF_S2);
01655                 } else {
01656                         vis_src1(TMP2, REF_S6);
01657                         vis_src1(TMP6, REF_S2);
01658                 }
01659 
01660                 vis_padd16(TMP18, CONST_2, TMP18);
01661                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);
01662 
01663                 vis_padd16(TMP20, CONST_2, TMP20);
01664                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
01665 
01666                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);
01667                 vis_pmerge(ZERO, REF_S0_1, TMP28);
01668 
01669                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);
01670                 vis_padd16(TMP18, TMP22, TMP18);
01671 
01672                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
01673                 vis_padd16(TMP20, TMP24, TMP20);
01674 
01675                 vis_padd16(TMP8,  TMP18, TMP8);
01676 
01677                 vis_padd16(TMP10, TMP20, TMP10);
01678 
01679                 vis_padd16(TMP8,  TMP12, TMP8);
01680 
01681                 vis_padd16(TMP10, TMP14, TMP10);
01682                 vis_pack16(TMP8,  DST_0);
01683 
01684                 vis_pack16(TMP10, DST_1);
01685                 vis_st64(DST_0, dest[0]);
01686                 dest += stride;
01687                 vis_padd16(TMP18, TMP26, TMP18);
01688 
01689                 vis_padd16(TMP20, TMP28, TMP20);
01690 
01691                 vis_padd16(TMP18, TMP30, TMP18);
01692 
01693                 vis_padd16(TMP20, TMP32, TMP20);
01694                 vis_pack16(TMP18, DST_2);
01695 
01696                 vis_pack16(TMP20, DST_3);
01697                 vis_st64(DST_2, dest[0]);
01698                 dest += stride;
01699         } while (--height);
01700 }
01701 
01702 static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * ref,
01703                               const int stride, int height)
01704 {
01705         unsigned long off = (unsigned long) ref & 0x7;
01706         unsigned long off_plus_1 = off + 1;
01707         int stride_8 = stride + 8;
01708         int stride_16 = stride + 16;
01709 
01710         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
01711 
01712         ref = vis_alignaddr(ref);
01713 
01714         vis_ld64(ref[ 0], TMP0);
01715         vis_fzero(ZERO);
01716 
01717         vis_ld64(ref[ 8], TMP2);
01718 
01719         vis_ld64(ref[16], TMP4);
01720 
01721         vis_ld64(constants6[0], CONST_6);
01722         vis_faligndata(TMP0, TMP2, REF_S0);
01723 
01724         vis_ld64(constants256_1024[0], CONST_256);
01725         vis_faligndata(TMP2, TMP4, REF_S4);
01726 
01727         if (off != 0x7) {
01728                 vis_alignaddr_g0((void *)off_plus_1);
01729                 vis_faligndata(TMP0, TMP2, REF_S2);
01730                 vis_faligndata(TMP2, TMP4, REF_S6);
01731         } else {
01732                 vis_src1(TMP2, REF_S2);
01733                 vis_src1(TMP4, REF_S6);
01734         }
01735 
01736         height >>= 1;
01737         do {    /* 55 cycles */
01738                 vis_ld64_2(ref, stride, TMP0);
01739                 vis_mul8x16au(REF_S0, CONST_256, TMP12);
01740                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);
01741 
01742                 vis_alignaddr_g0((void *)off);
01743 
01744                 vis_ld64_2(ref, stride_8, TMP2);
01745                 vis_mul8x16au(REF_S2, CONST_256, TMP16);
01746                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);
01747 
01748                 vis_ld64_2(ref, stride_16, TMP4);
01749                 ref += stride;
01750                 vis_mul8x16au(REF_S4, CONST_256, TMP20);
01751                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);
01752 
01753                 vis_ld64_2(ref, stride, TMP6);
01754                 vis_mul8x16au(REF_S6, CONST_256, TMP24);
01755                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);
01756 
01757                 vis_ld64_2(ref, stride_8, TMP8);
01758                 vis_faligndata(TMP0, TMP2, REF_0);
01759 
01760                 vis_ld64_2(ref, stride_16, TMP10);
01761                 ref += stride;
01762                 vis_faligndata(TMP2, TMP4, REF_4);
01763 
01764                 vis_ld64(dest[0], DST_0);
01765                 vis_faligndata(TMP6, TMP8, REF_S0);
01766 
01767                 vis_ld64_2(dest, 8, DST_2);
01768                 vis_faligndata(TMP8, TMP10, REF_S4);
01769 
01770                 if (off != 0x7) {
01771                         vis_alignaddr_g0((void *)off_plus_1);
01772                         vis_faligndata(TMP0, TMP2, REF_2);
01773                         vis_faligndata(TMP2, TMP4, REF_6);
01774                         vis_faligndata(TMP6, TMP8, REF_S2);
01775                         vis_faligndata(TMP8, TMP10, REF_S6);
01776                 } else {
01777                         vis_src1(TMP2, REF_2);
01778                         vis_src1(TMP4, REF_6);
01779                         vis_src1(TMP8, REF_S2);
01780                         vis_src1(TMP10, REF_S6);
01781                 }
01782 
01783                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
01784                 vis_pmerge(ZERO, REF_0, TMP0);
01785 
01786                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
01787                 vis_pmerge(ZERO,      REF_0_1,  TMP2);
01788 
01789                 vis_mul8x16au(REF_2, CONST_256, TMP4);
01790                 vis_pmerge(ZERO,      REF_2_1,  TMP6);
01791 
01792                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);
01793                 vis_padd16(TMP0, CONST_6, TMP0);
01794 
01795                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);
01796                 vis_padd16(TMP2, CONST_6, TMP2);
01797 
01798                 vis_padd16(TMP0, TMP4, TMP0);
01799                 vis_mul8x16au(REF_4, CONST_256, TMP4);
01800 
01801                 vis_padd16(TMP2, TMP6, TMP2);
01802                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
01803 
01804                 vis_padd16(TMP12, TMP0, TMP12);
01805                 vis_mul8x16au(REF_6, CONST_256, TMP8);
01806 
01807                 vis_padd16(TMP14, TMP2, TMP14);
01808                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);
01809 
01810                 vis_padd16(TMP12, TMP16, TMP12);
01811                 vis_mul8x16au(REF_S0, CONST_256, REF_4);
01812 
01813                 vis_padd16(TMP14, TMP18, TMP14);
01814                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
01815 
01816                 vis_padd16(TMP12, TMP30, TMP12);
01817 
01818                 vis_padd16(TMP14, TMP32, TMP14);
01819                 vis_pack16(TMP12, DST_0);
01820 
01821                 vis_pack16(TMP14, DST_1);
01822                 vis_st64(DST_0, dest[0]);
01823                 vis_padd16(TMP4, CONST_6, TMP4);
01824 
01825                 vis_ld64_2(dest, stride, DST_0);
01826                 vis_padd16(TMP6, CONST_6, TMP6);
01827                 vis_mul8x16au(REF_S2, CONST_256, TMP12);
01828 
01829                 vis_padd16(TMP4, TMP8, TMP4);
01830                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);
01831 
01832                 vis_padd16(TMP6, TMP10, TMP6);
01833 
01834                 vis_padd16(TMP20, TMP4, TMP20);
01835 
01836                 vis_padd16(TMP22, TMP6, TMP22);
01837 
01838                 vis_padd16(TMP20, TMP24, TMP20);
01839 
01840                 vis_padd16(TMP22, TMP26, TMP22);
01841 
01842                 vis_padd16(TMP20, REF_0, TMP20);
01843                 vis_mul8x16au(REF_S4, CONST_256, REF_0);
01844 
01845                 vis_padd16(TMP22, REF_2, TMP22);
01846                 vis_pack16(TMP20, DST_2);
01847 
01848                 vis_pack16(TMP22, DST_3);
01849                 vis_st64_2(DST_2, dest, 8);
01850                 dest += stride;
01851 
01852                 vis_ld64_2(dest, 8, DST_2);
01853                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
01854                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);
01855 
01856                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
01857                 vis_padd16(REF_4, TMP0, TMP8);
01858 
01859                 vis_mul8x16au(REF_S6, CONST_256, REF_4);
01860                 vis_padd16(REF_6, TMP2, TMP10);
01861 
01862                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
01863                 vis_padd16(TMP8, TMP12, TMP8);
01864 
01865                 vis_padd16(TMP10, TMP14, TMP10);
01866 
01867                 vis_padd16(TMP8, TMP30, TMP8);
01868 
01869                 vis_padd16(TMP10, TMP32, TMP10);
01870                 vis_pack16(TMP8, DST_0);
01871 
01872                 vis_pack16(TMP10, DST_1);
01873                 vis_st64(DST_0, dest[0]);
01874 
01875                 vis_padd16(REF_0, TMP4, REF_0);
01876 
01877                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);
01878                 vis_padd16(REF_2, TMP6, REF_2);
01879 
01880                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);
01881                 vis_padd16(REF_0, REF_4, REF_0);
01882 
01883                 vis_padd16(REF_2, REF_6, REF_2);
01884 
01885                 vis_padd16(REF_0, TMP30, REF_0);
01886 
01887                 /* stall */
01888 
01889                 vis_padd16(REF_2, TMP32, REF_2);
01890                 vis_pack16(REF_0, DST_2);
01891 
01892                 vis_pack16(REF_2, DST_3);
01893                 vis_st64_2(DST_2, dest, 8);
01894                 dest += stride;
01895         } while (--height);
01896 }
01897 
01898 static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * ref,
01899                              const int stride, int height)
01900 {
01901         unsigned long off = (unsigned long) ref & 0x7;
01902         unsigned long off_plus_1 = off + 1;
01903         int stride_8 = stride + 8;
01904 
01905         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
01906 
01907         ref = vis_alignaddr(ref);
01908 
01909         vis_ld64(ref[0], TMP0);
01910         vis_fzero(ZERO);
01911 
01912         vis_ld64_2(ref, 8, TMP2);
01913 
01914         vis_ld64(constants6[0], CONST_6);
01915 
01916         vis_ld64(constants256_1024[0], CONST_256);
01917         vis_faligndata(TMP0, TMP2, REF_S0);
01918 
01919         if (off != 0x7) {
01920                 vis_alignaddr_g0((void *)off_plus_1);
01921                 vis_faligndata(TMP0, TMP2, REF_S2);
01922         } else {
01923                 vis_src1(TMP2, REF_S2);
01924         }
01925 
01926         height >>= 1;
01927         do {    /* 31 cycles */
01928                 vis_ld64_2(ref, stride, TMP0);
01929                 vis_mul8x16au(REF_S0, CONST_256, TMP8);
01930                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);
01931 
01932                 vis_ld64_2(ref, stride_8, TMP2);
01933                 ref += stride;
01934                 vis_mul8x16au(REF_S2, CONST_256, TMP12);
01935                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);
01936 
01937                 vis_alignaddr_g0((void *)off);
01938 
01939                 vis_ld64_2(ref, stride, TMP4);
01940                 vis_faligndata(TMP0, TMP2, REF_S4);
01941 
01942                 vis_ld64_2(ref, stride_8, TMP6);
01943                 ref += stride;
01944 
01945                 vis_ld64(dest[0], DST_0);
01946                 vis_faligndata(TMP4, TMP6, REF_S0);
01947 
01948                 vis_ld64_2(dest, stride, DST_2);
01949 
01950                 if (off != 0x7) {
01951                         vis_alignaddr_g0((void *)off_plus_1);
01952                         vis_faligndata(TMP0, TMP2, REF_S6);
01953                         vis_faligndata(TMP4, TMP6, REF_S2);
01954                 } else {
01955                         vis_src1(TMP2, REF_S6);
01956                         vis_src1(TMP6, REF_S2);
01957                 }
01958 
01959                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
01960                 vis_pmerge(ZERO, REF_S4, TMP22);
01961 
01962                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
01963                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);
01964 
01965                 vis_mul8x16au(REF_S6, CONST_256, TMP26);
01966                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);
01967 
01968                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);
01969                 vis_padd16(TMP22, CONST_6, TMP22);
01970 
01971                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
01972                 vis_padd16(TMP24, CONST_6, TMP24);
01973 
01974                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);
01975                 vis_padd16(TMP22, TMP26, TMP22);
01976 
01977                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);
01978                 vis_padd16(TMP24, TMP28, TMP24);
01979 
01980                 vis_mul8x16au(REF_S2, CONST_256, TMP26);
01981                 vis_padd16(TMP8, TMP22, TMP8);
01982 
01983                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
01984                 vis_padd16(TMP10, TMP24, TMP10);
01985 
01986                 vis_padd16(TMP8, TMP12, TMP8);
01987 
01988                 vis_padd16(TMP10, TMP14, TMP10);
01989 
01990                 vis_padd16(TMP8, TMP30, TMP8);
01991 
01992                 vis_padd16(TMP10, TMP32, TMP10);
01993                 vis_pack16(TMP8, DST_0);
01994 
01995                 vis_pack16(TMP10, DST_1);
01996                 vis_st64(DST_0, dest[0]);
01997                 dest += stride;
01998 
01999                 vis_padd16(REF_S4, TMP22, TMP12);
02000 
02001                 vis_padd16(REF_S6, TMP24, TMP14);
02002 
02003                 vis_padd16(TMP12, TMP26, TMP12);
02004 
02005                 vis_padd16(TMP14, TMP28, TMP14);
02006 
02007                 vis_padd16(TMP12, REF_0, TMP12);
02008 
02009                 vis_padd16(TMP14, REF_2, TMP14);
02010                 vis_pack16(TMP12, DST_2);
02011 
02012                 vis_pack16(TMP14, DST_3);
02013                 vis_st64(DST_2, dest[0]);
02014                 dest += stride;
02015         } while (--height);
02016 }
02017 
02018 /* End of rounding code */
02019 
02020 /* Start of no rounding code */
02021 /* The trick used in some of this file is the formula from the MMX
02022  * motion comp code, which is:
02023  *
02024  * (x+y)>>1 == (x&y)+((x^y)>>1)
02025  *
02026  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
02027  * We avoid overflows by masking before we do the shift, and we
02028  * implement the shift by multiplying by 1/2 using mul8x16.  So in
02029  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
02030  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
02031  * the value 0x80808080 is in f8):
02032  *
02033  *      fxor            f0,   f2, f10
02034  *      fand            f10,  f4, f10
02035  *      fmul8x16        f8,  f10, f10
02036  *      fand            f10,  f6, f10
02037  *      fand            f0,   f2, f12
02038  *      fpadd16         f12, f10, f10
02039  */
02040 
02041 static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,
02042                                       const int stride, int height)
02043 {
02044         ref = vis_alignaddr(ref);
02045         do {    /* 5 cycles */
02046                 vis_ld64(ref[0], TMP0);
02047 
02048                 vis_ld64_2(ref, 8, TMP2);
02049 
02050                 vis_ld64_2(ref, 16, TMP4);
02051                 ref += stride;
02052 
02053                 vis_faligndata(TMP0, TMP2, REF_0);
02054                 vis_st64(REF_0, dest[0]);
02055 
02056                 vis_faligndata(TMP2, TMP4, REF_2);
02057                 vis_st64_2(REF_2, dest, 8);
02058                 dest += stride;
02059         } while (--height);
02060 }
02061 
02062 static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,
02063                             const int stride, int height)
02064 {
02065         ref = vis_alignaddr(ref);
02066         do {    /* 4 cycles */
02067                 vis_ld64(ref[0], TMP0);
02068 
02069                 vis_ld64(ref[8], TMP2);
02070                 ref += stride;
02071 
02072                 /* stall */
02073 
02074                 vis_faligndata(TMP0, TMP2, REF_0);
02075                 vis_st64(REF_0, dest[0]);
02076                 dest += stride;
02077         } while (--height);
02078 }
02079 
02080 
02081 static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,
02082                              const int stride, int height)
02083 {
02084         int stride_8 = stride + 8;
02085 
02086         ref = vis_alignaddr(ref);
02087 
02088         vis_ld64(ref[0], TMP0);
02089 
02090         vis_ld64(ref[8], TMP2);
02091 
02092         vis_ld64(ref[16], TMP4);
02093 
02094         vis_ld64(dest[0], DST_0);
02095 
02096         vis_ld64(dest[8], DST_2);
02097 
02098         vis_ld64(constants_fe[0], MASK_fe);
02099         vis_faligndata(TMP0, TMP2, REF_0);
02100 
02101         vis_ld64(constants_7f[0], MASK_7f);
02102         vis_faligndata(TMP2, TMP4, REF_2);
02103 
02104         vis_ld64(constants128[0], CONST_128);
02105 
02106         ref += stride;
02107         height = (height >> 1) - 1;
02108 
02109         do {    /* 24 cycles */
02110                 vis_ld64(ref[0], TMP0);
02111                 vis_xor(DST_0, REF_0, TMP6);
02112 
02113                 vis_ld64_2(ref, 8, TMP2);
02114                 vis_and(TMP6, MASK_fe, TMP6);
02115 
02116                 vis_ld64_2(ref, 16, TMP4);
02117                 ref += stride;
02118                 vis_mul8x16(CONST_128, TMP6, TMP6);
02119                 vis_xor(DST_2, REF_2, TMP8);
02120 
02121                 vis_and(TMP8, MASK_fe, TMP8);
02122 
02123                 vis_and(DST_0, REF_0, TMP10);
02124                 vis_ld64_2(dest, stride, DST_0);
02125                 vis_mul8x16(CONST_128, TMP8, TMP8);
02126 
02127                 vis_and(DST_2, REF_2, TMP12);
02128                 vis_ld64_2(dest, stride_8, DST_2);
02129 
02130                 vis_ld64(ref[0], TMP14);
02131                 vis_and(TMP6, MASK_7f, TMP6);
02132 
02133                 vis_and(TMP8, MASK_7f, TMP8);
02134 
02135                 vis_padd16(TMP10, TMP6, TMP6);
02136                 vis_st64(TMP6, dest[0]);
02137 
02138                 vis_padd16(TMP12, TMP8, TMP8);
02139                 vis_st64_2(TMP8, dest, 8);
02140 
02141                 dest += stride;
02142                 vis_ld64_2(ref, 8, TMP16);
02143                 vis_faligndata(TMP0, TMP2, REF_0);
02144 
02145                 vis_ld64_2(ref, 16, TMP18);
02146                 vis_faligndata(TMP2, TMP4, REF_2);
02147                 ref += stride;
02148 
02149                 vis_xor(DST_0, REF_0, TMP20);
02150 
02151                 vis_and(TMP20, MASK_fe, TMP20);
02152 
02153                 vis_xor(DST_2, REF_2, TMP22);
02154                 vis_mul8x16(CONST_128, TMP20, TMP20);
02155 
02156                 vis_and(TMP22, MASK_fe, TMP22);
02157 
02158                 vis_and(DST_0, REF_0, TMP24);
02159                 vis_mul8x16(CONST_128, TMP22, TMP22);
02160 
02161                 vis_and(DST_2, REF_2, TMP26);
02162 
02163                 vis_ld64_2(dest, stride, DST_0);
02164                 vis_faligndata(TMP14, TMP16, REF_0);
02165 
02166                 vis_ld64_2(dest, stride_8, DST_2);
02167                 vis_faligndata(TMP16, TMP18, REF_2);
02168 
02169                 vis_and(TMP20, MASK_7f, TMP20);
02170 
02171                 vis_and(TMP22, MASK_7f, TMP22);
02172 
02173                 vis_padd16(TMP24, TMP20, TMP20);
02174                 vis_st64(TMP20, dest[0]);
02175 
02176                 vis_padd16(TMP26, TMP22, TMP22);
02177                 vis_st64_2(TMP22, dest, 8);
02178                 dest += stride;
02179         } while (--height);
02180 
02181         vis_ld64(ref[0], TMP0);
02182         vis_xor(DST_0, REF_0, TMP6);
02183 
02184         vis_ld64_2(ref, 8, TMP2);
02185         vis_and(TMP6, MASK_fe, TMP6);
02186 
02187         vis_ld64_2(ref, 16, TMP4);
02188         vis_mul8x16(CONST_128, TMP6, TMP6);
02189         vis_xor(DST_2, REF_2, TMP8);
02190 
02191         vis_and(TMP8, MASK_fe, TMP8);
02192 
02193         vis_and(DST_0, REF_0, TMP10);
02194         vis_ld64_2(dest, stride, DST_0);
02195         vis_mul8x16(CONST_128, TMP8, TMP8);
02196 
02197         vis_and(DST_2, REF_2, TMP12);
02198         vis_ld64_2(dest, stride_8, DST_2);
02199 
02200         vis_ld64(ref[0], TMP14);
02201         vis_and(TMP6, MASK_7f, TMP6);
02202 
02203         vis_and(TMP8, MASK_7f, TMP8);
02204 
02205         vis_padd16(TMP10, TMP6, TMP6);
02206         vis_st64(TMP6, dest[0]);
02207 
02208         vis_padd16(TMP12, TMP8, TMP8);
02209         vis_st64_2(TMP8, dest, 8);
02210 
02211         dest += stride;
02212         vis_faligndata(TMP0, TMP2, REF_0);
02213 
02214         vis_faligndata(TMP2, TMP4, REF_2);
02215 
02216         vis_xor(DST_0, REF_0, TMP20);
02217 
02218         vis_and(TMP20, MASK_fe, TMP20);
02219 
02220         vis_xor(DST_2, REF_2, TMP22);
02221         vis_mul8x16(CONST_128, TMP20, TMP20);
02222 
02223         vis_and(TMP22, MASK_fe, TMP22);
02224 
02225         vis_and(DST_0, REF_0, TMP24);
02226         vis_mul8x16(CONST_128, TMP22, TMP22);
02227 
02228         vis_and(DST_2, REF_2, TMP26);
02229 
02230         vis_and(TMP20, MASK_7f, TMP20);
02231 
02232         vis_and(TMP22, MASK_7f, TMP22);
02233 
02234         vis_padd16(TMP24, TMP20, TMP20);
02235         vis_st64(TMP20, dest[0]);
02236 
02237         vis_padd16(TMP26, TMP22, TMP22);
02238         vis_st64_2(TMP22, dest, 8);
02239 }
02240 
02241 static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,
02242                             const int stride, int height)
02243 {
02244         ref = vis_alignaddr(ref);
02245 
02246         vis_ld64(ref[0], TMP0);
02247 
02248         vis_ld64(ref[8], TMP2);
02249 
02250         vis_ld64(dest[0], DST_0);
02251 
02252         vis_ld64(constants_fe[0], MASK_fe);
02253 
02254         vis_ld64(constants_7f[0], MASK_7f);
02255         vis_faligndata(TMP0, TMP2, REF_0);
02256 
02257         vis_ld64(constants128[0], CONST_128);
02258 
02259         ref += stride;
02260         height = (height >> 1) - 1;
02261 
02262         do {    /* 12 cycles */
02263                 vis_ld64(ref[0], TMP0);
02264                 vis_xor(DST_0, REF_0, TMP4);
02265 
02266                 vis_ld64(ref[8], TMP2);
02267                 vis_and(TMP4, MASK_fe, TMP4);
02268 
02269                 vis_and(DST_0, REF_0, TMP6);
02270                 vis_ld64_2(dest, stride, DST_0);
02271                 ref += stride;
02272                 vis_mul8x16(CONST_128, TMP4, TMP4);
02273 
02274                 vis_ld64(ref[0], TMP12);
02275                 vis_faligndata(TMP0, TMP2, REF_0);
02276 
02277                 vis_ld64(ref[8], TMP2);
02278                 vis_xor(DST_0, REF_0, TMP0);
02279                 ref += stride;
02280 
02281                 vis_and(TMP0, MASK_fe, TMP0);
02282 
02283                 vis_and(TMP4, MASK_7f, TMP4);
02284 
02285                 vis_padd16(TMP6, TMP4, TMP4);
02286                 vis_st64(TMP4, dest[0]);
02287                 dest += stride;
02288                 vis_mul8x16(CONST_128, TMP0, TMP0);
02289 
02290                 vis_and(DST_0, REF_0, TMP6);
02291                 vis_ld64_2(dest, stride, DST_0);
02292 
02293                 vis_faligndata(TMP12, TMP2, REF_0);
02294 
02295                 vis_and(TMP0, MASK_7f, TMP0);
02296 
02297                 vis_padd16(TMP6, TMP0, TMP4);
02298                 vis_st64(TMP4, dest[0]);
02299                 dest += stride;
02300         } while (--height);
02301 
02302         vis_ld64(ref[0], TMP0);
02303         vis_xor(DST_0, REF_0, TMP4);
02304 
02305         vis_ld64(ref[8], TMP2);
02306         vis_and(TMP4, MASK_fe, TMP4);
02307 
02308         vis_and(DST_0, REF_0, TMP6);
02309         vis_ld64_2(dest, stride, DST_0);
02310         vis_mul8x16(CONST_128, TMP4, TMP4);
02311 
02312         vis_faligndata(TMP0, TMP2, REF_0);
02313 
02314         vis_xor(DST_0, REF_0, TMP0);
02315 
02316         vis_and(TMP0, MASK_fe, TMP0);
02317 
02318         vis_and(TMP4, MASK_7f, TMP4);
02319 
02320         vis_padd16(TMP6, TMP4, TMP4);
02321         vis_st64(TMP4, dest[0]);
02322         dest += stride;
02323         vis_mul8x16(CONST_128, TMP0, TMP0);
02324 
02325         vis_and(DST_0, REF_0, TMP6);
02326 
02327         vis_and(TMP0, MASK_7f, TMP0);
02328 
02329         vis_padd16(TMP6, TMP0, TMP4);
02330         vis_st64(TMP4, dest[0]);
02331 }
02332 
02333 static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,
02334                              const int stride, int height)
02335 {
02336         unsigned long off = (unsigned long) ref & 0x7;
02337         unsigned long off_plus_1 = off + 1;
02338 
02339         ref = vis_alignaddr(ref);
02340 
02341         vis_ld64(ref[0],    TMP0);
02342 
02343         vis_ld64_2(ref, 8,  TMP2);
02344 
02345         vis_ld64_2(ref, 16, TMP4);
02346 
02347         vis_ld64(constants_fe[0], MASK_fe);
02348 
02349         vis_ld64(constants_7f[0], MASK_7f);
02350         vis_faligndata(TMP0, TMP2, REF_0);
02351 
02352         vis_ld64(constants128[0], CONST_128);
02353         vis_faligndata(TMP2, TMP4, REF_4);
02354 
02355         if (off != 0x7) {
02356                 vis_alignaddr_g0((void *)off_plus_1);
02357                 vis_faligndata(TMP0, TMP2, REF_2);
02358                 vis_faligndata(TMP2, TMP4, REF_6);
02359         } else {
02360                 vis_src1(TMP2, REF_2);
02361                 vis_src1(TMP4, REF_6);
02362         }
02363 
02364         ref += stride;
02365         height = (height >> 1) - 1;
02366 
02367         do {    /* 34 cycles */
02368                 vis_ld64(ref[0],    TMP0);
02369                 vis_xor(REF_0, REF_2, TMP6);
02370 
02371                 vis_ld64_2(ref, 8,  TMP2);
02372                 vis_xor(REF_4, REF_6, TMP8);
02373 
02374                 vis_ld64_2(ref, 16, TMP4);
02375                 vis_and(TMP6, MASK_fe, TMP6);
02376                 ref += stride;
02377 
02378                 vis_ld64(ref[0],    TMP14);
02379                 vis_mul8x16(CONST_128, TMP6, TMP6);
02380                 vis_and(TMP8, MASK_fe, TMP8);
02381 
02382                 vis_ld64_2(ref, 8,  TMP16);
02383                 vis_mul8x16(CONST_128, TMP8, TMP8);
02384                 vis_and(REF_0, REF_2, TMP10);
02385 
02386                 vis_ld64_2(ref, 16, TMP18);
02387                 ref += stride;
02388                 vis_and(REF_4, REF_6, TMP12);
02389 
02390                 vis_alignaddr_g0((void *)off);
02391 
02392                 vis_faligndata(TMP0, TMP2, REF_0);
02393 
02394                 vis_faligndata(TMP2, TMP4, REF_4);
02395 
02396                 if (off != 0x7) {
02397                         vis_alignaddr_g0((void *)off_plus_1);
02398                         vis_faligndata(TMP0, TMP2, REF_2);
02399                         vis_faligndata(TMP2, TMP4, REF_6);
02400                 } else {
02401                         vis_src1(TMP2, REF_2);
02402                         vis_src1(TMP4, REF_6);
02403                 }
02404 
02405                 vis_and(TMP6, MASK_7f, TMP6);
02406 
02407                 vis_and(TMP8, MASK_7f, TMP8);
02408 
02409                 vis_padd16(TMP10, TMP6, TMP6);
02410                 vis_st64(TMP6, dest[0]);
02411 
02412                 vis_padd16(TMP12, TMP8, TMP8);
02413                 vis_st64_2(TMP8, dest, 8);
02414                 dest += stride;
02415 
02416                 vis_xor(REF_0, REF_2, TMP6);
02417 
02418                 vis_xor(REF_4, REF_6, TMP8);
02419 
02420                 vis_and(TMP6, MASK_fe, TMP6);
02421 
02422                 vis_mul8x16(CONST_128, TMP6, TMP6);
02423                 vis_and(TMP8, MASK_fe, TMP8);
02424 
02425                 vis_mul8x16(CONST_128, TMP8, TMP8);
02426                 vis_and(REF_0, REF_2, TMP10);
02427 
02428                 vis_and(REF_4, REF_6, TMP12);
02429 
02430                 vis_alignaddr_g0((void *)off);
02431 
02432                 vis_faligndata(TMP14, TMP16, REF_0);
02433 
02434                 vis_faligndata(TMP16, TMP18, REF_4);
02435 
02436                 if (off != 0x7) {
02437                         vis_alignaddr_g0((void *)off_plus_1);
02438                         vis_faligndata(TMP14, TMP16, REF_2);
02439                         vis_faligndata(TMP16, TMP18, REF_6);
02440                 } else {
02441                         vis_src1(TMP16, REF_2);
02442                         vis_src1(TMP18, REF_6);
02443                 }
02444 
02445                 vis_and(TMP6, MASK_7f, TMP6);
02446 
02447                 vis_and(TMP8, MASK_7f, TMP8);
02448 
02449                 vis_padd16(TMP10, TMP6, TMP6);
02450                 vis_st64(TMP6, dest[0]);
02451 
02452                 vis_padd16(TMP12, TMP8, TMP8);
02453                 vis_st64_2(TMP8, dest, 8);
02454                 dest += stride;
02455         } while (--height);
02456 
02457         vis_ld64(ref[0],    TMP0);
02458         vis_xor(REF_0, REF_2, TMP6);
02459 
02460         vis_ld64_2(ref, 8,  TMP2);
02461         vis_xor(REF_4, REF_6, TMP8);
02462 
02463         vis_ld64_2(ref, 16, TMP4);
02464         vis_and(TMP6, MASK_fe, TMP6);
02465 
02466         vis_mul8x16(CONST_128, TMP6, TMP6);
02467         vis_and(TMP8, MASK_fe, TMP8);
02468 
02469         vis_mul8x16(CONST_128, TMP8, TMP8);
02470         vis_and(REF_0, REF_2, TMP10);
02471 
02472         vis_and(REF_4, REF_6, TMP12);
02473 
02474         vis_alignaddr_g0((void *)off);
02475 
02476         vis_faligndata(TMP0, TMP2, REF_0);
02477 
02478         vis_faligndata(TMP2, TMP4, REF_4);
02479 
02480         if (off != 0x7) {
02481                 vis_alignaddr_g0((void *)off_plus_1);
02482                 vis_faligndata(TMP0, TMP2, REF_2);
02483                 vis_faligndata(TMP2, TMP4, REF_6);
02484         } else {
02485                 vis_src1(TMP2, REF_2);
02486                 vis_src1(TMP4, REF_6);
02487         }
02488 
02489         vis_and(TMP6, MASK_7f, TMP6);
02490 
02491         vis_and(TMP8, MASK_7f, TMP8);
02492 
02493         vis_padd16(TMP10, TMP6, TMP6);
02494         vis_st64(TMP6, dest[0]);
02495 
02496         vis_padd16(TMP12, TMP8, TMP8);
02497         vis_st64_2(TMP8, dest, 8);
02498         dest += stride;
02499 
02500         vis_xor(REF_0, REF_2, TMP6);
02501 
02502         vis_xor(REF_4, REF_6, TMP8);
02503 
02504         vis_and(TMP6, MASK_fe, TMP6);
02505 
02506         vis_mul8x16(CONST_128, TMP6, TMP6);
02507         vis_and(TMP8, MASK_fe, TMP8);
02508 
02509         vis_mul8x16(CONST_128, TMP8, TMP8);
02510         vis_and(REF_0, REF_2, TMP10);
02511 
02512         vis_and(REF_4, REF_6, TMP12);
02513 
02514         vis_and(TMP6, MASK_7f, TMP6);
02515 
02516         vis_and(TMP8, MASK_7f, TMP8);
02517 
02518         vis_padd16(TMP10, TMP6, TMP6);
02519         vis_st64(TMP6, dest[0]);
02520 
02521         vis_padd16(TMP12, TMP8, TMP8);
02522         vis_st64_2(TMP8, dest, 8);
02523 }
02524 
02525 static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,
02526                             const int stride, int height)
02527 {
02528         unsigned long off = (unsigned long) ref & 0x7;
02529         unsigned long off_plus_1 = off + 1;
02530 
02531         ref = vis_alignaddr(ref);
02532 
02533         vis_ld64(ref[0], TMP0);
02534 
02535         vis_ld64(ref[8], TMP2);
02536 
02537         vis_ld64(constants_fe[0], MASK_fe);
02538 
02539         vis_ld64(constants_7f[0], MASK_7f);
02540 
02541         vis_ld64(constants128[0], CONST_128);
02542         vis_faligndata(TMP0, TMP2, REF_0);
02543 
02544         if (off != 0x7) {
02545                 vis_alignaddr_g0((void *)off_plus_1);
02546                 vis_faligndata(TMP0, TMP2, REF_2);
02547         } else {
02548                 vis_src1(TMP2, REF_2);
02549         }
02550 
02551         ref += stride;
02552         height = (height >> 1) - 1;
02553 
02554         do {    /* 20 cycles */
02555                 vis_ld64(ref[0], TMP0);
02556                 vis_xor(REF_0, REF_2, TMP4);
02557 
02558                 vis_ld64_2(ref, 8, TMP2);
02559                 vis_and(TMP4, MASK_fe, TMP4);
02560                 ref += stride;
02561 
02562                 vis_ld64(ref[0], TMP8);
02563                 vis_and(REF_0, REF_2, TMP6);
02564                 vis_mul8x16(CONST_128, TMP4, TMP4);
02565 
02566                 vis_alignaddr_g0((void *)off);
02567 
02568                 vis_ld64_2(ref, 8, TMP10);
02569                 ref += stride;
02570                 vis_faligndata(TMP0, TMP2, REF_0);
02571 
02572                 if (off != 0x7) {
02573                         vis_alignaddr_g0((void *)off_plus_1);
02574                         vis_faligndata(TMP0, TMP2, REF_2);
02575                 } else {
02576                         vis_src1(TMP2, REF_2);
02577                 }
02578 
02579                 vis_and(TMP4, MASK_7f, TMP4);
02580 
02581                 vis_padd16(TMP6, TMP4, DST_0);
02582                 vis_st64(DST_0, dest[0]);
02583                 dest += stride;
02584 
02585                 vis_xor(REF_0, REF_2, TMP12);
02586 
02587                 vis_and(TMP12, MASK_fe, TMP12);
02588 
02589                 vis_and(REF_0, REF_2, TMP14);
02590                 vis_mul8x16(CONST_128, TMP12, TMP12);
02591 
02592                 vis_alignaddr_g0((void *)off);
02593                 vis_faligndata(TMP8, TMP10, REF_0);
02594                 if (off != 0x7) {
02595                         vis_alignaddr_g0((void *)off_plus_1);
02596                         vis_faligndata(TMP8, TMP10, REF_2);
02597                 } else {
02598                         vis_src1(TMP10, REF_2);
02599                 }
02600 
02601                 vis_and(TMP12, MASK_7f, TMP12);
02602 
02603                 vis_padd16(TMP14, TMP12, DST_0);
02604                 vis_st64(DST_0, dest[0]);
02605                 dest += stride;
02606         } while (--height);
02607 
02608         vis_ld64(ref[0], TMP0);
02609         vis_xor(REF_0, REF_2, TMP4);
02610 
02611         vis_ld64_2(ref, 8, TMP2);
02612         vis_and(TMP4, MASK_fe, TMP4);
02613 
02614         vis_and(REF_0, REF_2, TMP6);
02615         vis_mul8x16(CONST_128, TMP4, TMP4);
02616 
02617         vis_alignaddr_g0((void *)off);
02618 
02619         vis_faligndata(TMP0, TMP2, REF_0);
02620 
02621         if (off != 0x7) {
02622                 vis_alignaddr_g0((void *)off_plus_1);
02623                 vis_faligndata(TMP0, TMP2, REF_2);
02624         } else {
02625                 vis_src1(TMP2, REF_2);
02626         }
02627 
02628         vis_and(TMP4, MASK_7f, TMP4);
02629 
02630         vis_padd16(TMP6, TMP4, DST_0);
02631         vis_st64(DST_0, dest[0]);
02632         dest += stride;
02633 
02634         vis_xor(REF_0, REF_2, TMP12);
02635 
02636         vis_and(TMP12, MASK_fe, TMP12);
02637 
02638         vis_and(REF_0, REF_2, TMP14);
02639         vis_mul8x16(CONST_128, TMP12, TMP12);
02640 
02641         vis_and(TMP12, MASK_7f, TMP12);
02642 
02643         vis_padd16(TMP14, TMP12, DST_0);
02644         vis_st64(DST_0, dest[0]);
02645         dest += stride;
02646 }
02647 
02648 static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,
02649                              const int stride, int height)
02650 {
02651         unsigned long off = (unsigned long) ref & 0x7;
02652         unsigned long off_plus_1 = off + 1;
02653 
02654         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
02655 
02656         vis_ld64(constants3[0], CONST_3);
02657         vis_fzero(ZERO);
02658         vis_ld64(constants256_512[0], CONST_256);
02659 
02660         ref = vis_alignaddr(ref);
02661         do {    /* 26 cycles */
02662                 vis_ld64(ref[0], TMP0);
02663 
02664                 vis_ld64(ref[8], TMP2);
02665 
02666                 vis_alignaddr_g0((void *)off);
02667 
02668                 vis_ld64(ref[16], TMP4);
02669 
02670                 vis_ld64(dest[0], DST_0);
02671                 vis_faligndata(TMP0, TMP2, REF_0);
02672 
02673                 vis_ld64(dest[8], DST_2);
02674                 vis_faligndata(TMP2, TMP4, REF_4);
02675 
02676                 if (off != 0x7) {
02677                         vis_alignaddr_g0((void *)off_plus_1);
02678                         vis_faligndata(TMP0, TMP2, REF_2);
02679                         vis_faligndata(TMP2, TMP4, REF_6);
02680                 } else {
02681                         vis_src1(TMP2, REF_2);
02682                         vis_src1(TMP4, REF_6);
02683                 }
02684 
02685                 vis_mul8x16au(REF_0,   CONST_256, TMP0);
02686 
02687                 vis_pmerge(ZERO,     REF_2,     TMP4);
02688                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
02689 
02690                 vis_pmerge(ZERO, REF_2_1, TMP6);
02691 
02692                 vis_padd16(TMP0, TMP4, TMP0);
02693 
02694                 vis_mul8x16al(DST_0,   CONST_512, TMP4);
02695                 vis_padd16(TMP2, TMP6, TMP2);
02696 
02697                 vis_mul8x16al(DST_1,   CONST_512, TMP6);
02698 
02699                 vis_mul8x16au(REF_6,   CONST_256, TMP12);
02700 
02701                 vis_padd16(TMP0, TMP4, TMP0);
02702                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
02703 
02704                 vis_padd16(TMP2, TMP6, TMP2);
02705                 vis_mul8x16au(REF_4,   CONST_256, TMP16);
02706 
02707                 vis_padd16(TMP0, CONST_3, TMP8);
02708                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);
02709 
02710                 vis_padd16(TMP2, CONST_3, TMP10);
02711                 vis_pack16(TMP8, DST_0);
02712 
02713                 vis_pack16(TMP10, DST_1);
02714                 vis_padd16(TMP16, TMP12, TMP0);
02715 
02716                 vis_st64(DST_0, dest[0]);
02717                 vis_mul8x16al(DST_2,   CONST_512, TMP4);
02718                 vis_padd16(TMP18, TMP14, TMP2);
02719 
02720                 vis_mul8x16al(DST_3,   CONST_512, TMP6);
02721                 vis_padd16(TMP0, CONST_3, TMP0);
02722 
02723                 vis_padd16(TMP2, CONST_3, TMP2);
02724 
02725                 vis_padd16(TMP0, TMP4, TMP0);
02726 
02727                 vis_padd16(TMP2, TMP6, TMP2);
02728                 vis_pack16(TMP0, DST_2);
02729 
02730                 vis_pack16(TMP2, DST_3);
02731                 vis_st64(DST_2, dest[8]);
02732 
02733                 ref += stride;
02734                 dest += stride;
02735         } while (--height);
02736 }
02737 
02738 static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,
02739                             const int stride, int height)
02740 {
02741         unsigned long off = (unsigned long) ref & 0x7;
02742         unsigned long off_plus_1 = off + 1;
02743         int stride_times_2 = stride << 1;
02744 
02745         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
02746 
02747         vis_ld64(constants3[0], CONST_3);
02748         vis_fzero(ZERO);
02749         vis_ld64(constants256_512[0], CONST_256);
02750 
02751         ref = vis_alignaddr(ref);
02752         height >>= 2;
02753         do {    /* 47 cycles */
02754                 vis_ld64(ref[0],   TMP0);
02755 
02756                 vis_ld64_2(ref, 8, TMP2);
02757                 ref += stride;
02758 
02759                 vis_alignaddr_g0((void *)off);
02760 
02761                 vis_ld64(ref[0],   TMP4);
02762                 vis_faligndata(TMP0, TMP2, REF_0);
02763 
02764                 vis_ld64_2(ref, 8, TMP6);
02765                 ref += stride;
02766 
02767                 vis_ld64(ref[0],   TMP8);
02768 
02769                 vis_ld64_2(ref, 8, TMP10);
02770                 ref += stride;
02771                 vis_faligndata(TMP4, TMP6, REF_4);
02772 
02773                 vis_ld64(ref[0],   TMP12);
02774 
02775                 vis_ld64_2(ref, 8, TMP14);
02776                 ref += stride;
02777                 vis_faligndata(TMP8, TMP10, REF_S0);
02778 
02779                 vis_faligndata(TMP12, TMP14, REF_S4);
02780 
02781                 if (off != 0x7) {
02782                         vis_alignaddr_g0((void *)off_plus_1);
02783 
02784                         vis_ld64(dest[0], DST_0);
02785                         vis_faligndata(TMP0, TMP2, REF_2);
02786 
02787                         vis_ld64_2(dest, stride, DST_2);
02788                         vis_faligndata(TMP4, TMP6, REF_6);
02789 
02790                         vis_faligndata(TMP8, TMP10, REF_S2);
02791 
02792                         vis_faligndata(TMP12, TMP14, REF_S6);
02793                 } else {
02794                         vis_ld64(dest[0], DST_0);
02795                         vis_src1(TMP2, REF_2);
02796 
02797                         vis_ld64_2(dest, stride, DST_2);
02798                         vis_src1(TMP6, REF_6);
02799 
02800                         vis_src1(TMP10, REF_S2);
02801 
02802                         vis_src1(TMP14, REF_S6);
02803                 }
02804 
02805                 vis_pmerge(ZERO,     REF_0,     TMP0);
02806                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
02807 
02808                 vis_pmerge(ZERO,     REF_2,     TMP4);
02809                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);
02810 
02811                 vis_padd16(TMP0, CONST_3, TMP0);
02812                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
02813 
02814                 vis_padd16(TMP2, CONST_3, TMP2);
02815                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
02816 
02817                 vis_padd16(TMP0, TMP4, TMP0);
02818                 vis_mul8x16au(REF_4, CONST_256, TMP8);
02819 
02820                 vis_padd16(TMP2, TMP6, TMP2);
02821                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);
02822 
02823                 vis_padd16(TMP0, TMP16, TMP0);
02824                 vis_mul8x16au(REF_6, CONST_256, TMP12);
02825 
02826                 vis_padd16(TMP2, TMP18, TMP2);
02827                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
02828 
02829                 vis_padd16(TMP8, CONST_3, TMP8);
02830                 vis_mul8x16al(DST_2, CONST_512, TMP16);
02831 
02832                 vis_padd16(TMP8, TMP12, TMP8);
02833                 vis_mul8x16al(DST_3, CONST_512, TMP18);
02834 
02835                 vis_padd16(TMP10, TMP14, TMP10);
02836                 vis_pack16(TMP0, DST_0);
02837 
02838                 vis_pack16(TMP2, DST_1);
02839                 vis_st64(DST_0, dest[0]);
02840                 dest += stride;
02841                 vis_padd16(TMP10, CONST_3, TMP10);
02842 
02843                 vis_ld64_2(dest, stride, DST_0);
02844                 vis_padd16(TMP8, TMP16, TMP8);
02845 
02846                 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
02847                 vis_padd16(TMP10, TMP18, TMP10);
02848                 vis_pack16(TMP8, DST_2);
02849 
02850                 vis_pack16(TMP10, DST_3);
02851                 vis_st64(DST_2, dest[0]);
02852                 dest += stride;
02853 
02854                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
02855                 vis_pmerge(ZERO,     REF_S0,     TMP0);
02856 
02857                 vis_pmerge(ZERO,     REF_S2,     TMP24);
02858                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
02859 
02860                 vis_padd16(TMP0, CONST_3, TMP0);
02861                 vis_mul8x16au(REF_S4, CONST_256, TMP8);
02862 
02863                 vis_padd16(TMP2, CONST_3, TMP2);
02864                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
02865 
02866                 vis_padd16(TMP0, TMP24, TMP0);
02867                 vis_mul8x16au(REF_S6, CONST_256, TMP12);
02868 
02869                 vis_padd16(TMP2, TMP6, TMP2);
02870                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
02871 
02872                 vis_padd16(TMP8, CONST_3, TMP8);
02873                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
02874 
02875                 vis_padd16(TMP10, CONST_3, TMP10);
02876                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
02877 
02878                 vis_padd16(TMP8, TMP12, TMP8);
02879                 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
02880 
02881                 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
02882                 vis_padd16(TMP0, TMP16, TMP0);
02883 
02884                 vis_padd16(TMP2, TMP18, TMP2);
02885                 vis_pack16(TMP0, DST_0);
02886 
02887                 vis_padd16(TMP10, TMP14, TMP10);
02888                 vis_pack16(TMP2, DST_1);
02889                 vis_st64(DST_0, dest[0]);
02890                 dest += stride;
02891 
02892                 vis_padd16(TMP8, TMP20, TMP8);
02893 
02894                 vis_padd16(TMP10, TMP22, TMP10);
02895                 vis_pack16(TMP8, DST_2);
02896 
02897                 vis_pack16(TMP10, DST_3);
02898                 vis_st64(DST_2, dest[0]);
02899                 dest += stride;
02900         } while (--height);
02901 }
02902 
02903 static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref,
02904                              const int stride, int height)
02905 {
02906         ref = vis_alignaddr(ref);
02907         vis_ld64(ref[0], TMP0);
02908 
02909         vis_ld64_2(ref, 8, TMP2);
02910 
02911         vis_ld64_2(ref, 16, TMP4);
02912         ref += stride;
02913 
02914         vis_ld64(ref[0], TMP6);
02915         vis_faligndata(TMP0, TMP2, REF_0);
02916 
02917         vis_ld64_2(ref, 8, TMP8);
02918         vis_faligndata(TMP2, TMP4, REF_4);
02919 
02920         vis_ld64_2(ref, 16, TMP10);
02921         ref += stride;
02922 
02923         vis_ld64(constants_fe[0], MASK_fe);
02924         vis_faligndata(TMP6, TMP8, REF_2);
02925 
02926         vis_ld64(constants_7f[0], MASK_7f);
02927         vis_faligndata(TMP8, TMP10, REF_6);
02928 
02929         vis_ld64(constants128[0], CONST_128);
02930         height = (height >> 1) - 1;
02931         do {    /* 24 cycles */
02932                 vis_ld64(ref[0], TMP0);
02933                 vis_xor(REF_0, REF_2, TMP12);
02934 
02935                 vis_ld64_2(ref, 8, TMP2);
02936                 vis_xor(REF_4, REF_6, TMP16);
02937 
02938                 vis_ld64_2(ref, 16, TMP4);
02939                 ref += stride;
02940                 vis_and(REF_0, REF_2, TMP14);
02941 
02942                 vis_ld64(ref[0], TMP6);
02943                 vis_and(REF_4, REF_6, TMP18);
02944 
02945                 vis_ld64_2(ref, 8, TMP8);
02946                 vis_faligndata(TMP0, TMP2, REF_0);
02947 
02948                 vis_ld64_2(ref, 16, TMP10);
02949                 ref += stride;
02950                 vis_faligndata(TMP2, TMP4, REF_4);
02951 
02952                 vis_and(TMP12, MASK_fe, TMP12);
02953 
02954                 vis_and(TMP16, MASK_fe, TMP16);
02955                 vis_mul8x16(CONST_128, TMP12, TMP12);
02956 
02957                 vis_mul8x16(CONST_128, TMP16, TMP16);
02958                 vis_xor(REF_0, REF_2, TMP0);
02959 
02960                 vis_xor(REF_4, REF_6, TMP2);
02961 
02962                 vis_and(REF_0, REF_2, TMP20);
02963 
02964                 vis_and(TMP12, MASK_7f, TMP12);
02965 
02966                 vis_and(TMP16, MASK_7f, TMP16);
02967 
02968                 vis_padd16(TMP14, TMP12, TMP12);
02969                 vis_st64(TMP12, dest[0]);
02970 
02971                 vis_padd16(TMP18, TMP16, TMP16);
02972                 vis_st64_2(TMP16, dest, 8);
02973                 dest += stride;
02974 
02975                 vis_and(REF_4, REF_6, TMP18);
02976 
02977                 vis_and(TMP0, MASK_fe, TMP0);
02978 
02979                 vis_and(TMP2, MASK_fe, TMP2);
02980                 vis_mul8x16(CONST_128, TMP0, TMP0);
02981 
02982                 vis_faligndata(TMP6, TMP8, REF_2);
02983                 vis_mul8x16(CONST_128, TMP2, TMP2);
02984 
02985                 vis_faligndata(TMP8, TMP10, REF_6);
02986 
02987                 vis_and(TMP0, MASK_7f, TMP0);
02988 
02989                 vis_and(TMP2, MASK_7f, TMP2);
02990 
02991                 vis_padd16(TMP20, TMP0, TMP0);
02992                 vis_st64(TMP0, dest[0]);
02993 
02994                 vis_padd16(TMP18, TMP2, TMP2);
02995                 vis_st64_2(TMP2, dest, 8);
02996                 dest += stride;
02997         } while (--height);
02998 
02999         vis_ld64(ref[0], TMP0);
03000         vis_xor(REF_0, REF_2, TMP12);
03001 
03002         vis_ld64_2(ref, 8, TMP2);
03003         vis_xor(REF_4, REF_6, TMP16);
03004 
03005         vis_ld64_2(ref, 16, TMP4);
03006         vis_and(REF_0, REF_2, TMP14);
03007 
03008         vis_and(REF_4, REF_6, TMP18);
03009 
03010         vis_faligndata(TMP0, TMP2, REF_0);
03011 
03012         vis_faligndata(TMP2, TMP4, REF_4);
03013 
03014         vis_and(TMP12, MASK_fe, TMP12);
03015 
03016         vis_and(TMP16, MASK_fe, TMP16);
03017         vis_mul8x16(CONST_128, TMP12, TMP12);
03018 
03019         vis_mul8x16(CONST_128, TMP16, TMP16);
03020         vis_xor(REF_0, REF_2, TMP0);
03021 
03022         vis_xor(REF_4, REF_6, TMP2);
03023 
03024         vis_and(REF_0, REF_2, TMP20);
03025 
03026         vis_and(TMP12, MASK_7f, TMP12);
03027 
03028         vis_and(TMP16, MASK_7f, TMP16);
03029 
03030         vis_padd16(TMP14, TMP12, TMP12);
03031         vis_st64(TMP12, dest[0]);
03032 
03033         vis_padd16(TMP18, TMP16, TMP16);
03034         vis_st64_2(TMP16, dest, 8);
03035         dest += stride;
03036 
03037         vis_and(REF_4, REF_6, TMP18);
03038 
03039         vis_and(TMP0, MASK_fe, TMP0);
03040 
03041         vis_and(TMP2, MASK_fe, TMP2);
03042         vis_mul8x16(CONST_128, TMP0, TMP0);
03043 
03044         vis_mul8x16(CONST_128, TMP2, TMP2);
03045 
03046         vis_and(TMP0, MASK_7f, TMP0);
03047 
03048         vis_and(TMP2, MASK_7f, TMP2);
03049 
03050         vis_padd16(TMP20, TMP0, TMP0);
03051         vis_st64(TMP0, dest[0]);
03052 
03053         vis_padd16(TMP18, TMP2, TMP2);
03054         vis_st64_2(TMP2, dest, 8);
03055 }
03056 
03057 static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref,
03058                             const int stride, int height)
03059 {
03060         ref = vis_alignaddr(ref);
03061         vis_ld64(ref[0], TMP0);
03062 
03063         vis_ld64_2(ref, 8, TMP2);
03064         ref += stride;
03065 
03066         vis_ld64(ref[0], TMP4);
03067 
03068         vis_ld64_2(ref, 8, TMP6);
03069         ref += stride;
03070 
03071         vis_ld64(constants_fe[0], MASK_fe);
03072         vis_faligndata(TMP0, TMP2, REF_0);
03073 
03074         vis_ld64(constants_7f[0], MASK_7f);
03075         vis_faligndata(TMP4, TMP6, REF_2);
03076 
03077         vis_ld64(constants128[0], CONST_128);
03078         height = (height >> 1) - 1;
03079         do {    /* 12 cycles */
03080                 vis_ld64(ref[0], TMP0);
03081                 vis_xor(REF_0, REF_2, TMP4);
03082 
03083                 vis_ld64_2(ref, 8, TMP2);
03084                 ref += stride;
03085                 vis_and(TMP4, MASK_fe, TMP4);
03086 
03087                 vis_and(REF_0, REF_2, TMP6);
03088                 vis_mul8x16(CONST_128, TMP4, TMP4);
03089 
03090                 vis_faligndata(TMP0, TMP2, REF_0);
03091                 vis_ld64(ref[0], TMP0);
03092 
03093                 vis_ld64_2(ref, 8, TMP2);
03094                 ref += stride;
03095                 vis_xor(REF_0, REF_2, TMP12);
03096 
03097                 vis_and(TMP4, MASK_7f, TMP4);
03098 
03099                 vis_and(TMP12, MASK_fe, TMP12);
03100 
03101                 vis_mul8x16(CONST_128, TMP12, TMP12);
03102                 vis_and(REF_0, REF_2, TMP14);
03103 
03104                 vis_padd16(TMP6, TMP4, DST_0);
03105                 vis_st64(DST_0, dest[0]);
03106                 dest += stride;
03107 
03108                 vis_faligndata(TMP0, TMP2, REF_2);
03109 
03110                 vis_and(TMP12, MASK_7f, TMP12);
03111 
03112                 vis_padd16(TMP14, TMP12, DST_0);
03113                 vis_st64(DST_0, dest[0]);
03114                 dest += stride;
03115         } while (--height);
03116 
03117         vis_ld64(ref[0], TMP0);
03118         vis_xor(REF_0, REF_2, TMP4);
03119 
03120         vis_ld64_2(ref, 8, TMP2);
03121         vis_and(TMP4, MASK_fe, TMP4);
03122 
03123         vis_and(REF_0, REF_2, TMP6);
03124         vis_mul8x16(CONST_128, TMP4, TMP4);
03125 
03126         vis_faligndata(TMP0, TMP2, REF_0);
03127 
03128         vis_xor(REF_0, REF_2, TMP12);
03129 
03130         vis_and(TMP4, MASK_7f, TMP4);
03131 
03132         vis_and(TMP12, MASK_fe, TMP12);
03133 
03134         vis_mul8x16(CONST_128, TMP12, TMP12);
03135         vis_and(REF_0, REF_2, TMP14);
03136 
03137         vis_padd16(TMP6, TMP4, DST_0);
03138         vis_st64(DST_0, dest[0]);
03139         dest += stride;
03140 
03141         vis_and(TMP12, MASK_7f, TMP12);
03142 
03143         vis_padd16(TMP14, TMP12, DST_0);
03144         vis_st64(DST_0, dest[0]);
03145 }
03146 
03147 static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref,
03148                              const int stride, int height)
03149 {
03150         int stride_8 = stride + 8;
03151         int stride_16 = stride + 16;
03152 
03153         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
03154 
03155         ref = vis_alignaddr(ref);
03156 
03157         vis_ld64(ref[ 0], TMP0);
03158         vis_fzero(ZERO);
03159 
03160         vis_ld64(ref[ 8], TMP2);
03161 
03162         vis_ld64(ref[16], TMP4);
03163 
03164         vis_ld64(constants3[0], CONST_3);
03165         vis_faligndata(TMP0, TMP2, REF_2);
03166 
03167         vis_ld64(constants256_512[0], CONST_256);
03168         vis_faligndata(TMP2, TMP4, REF_6);
03169         height >>= 1;
03170 
03171         do {    /* 31 cycles */
03172                 vis_ld64_2(ref, stride, TMP0);
03173                 vis_pmerge(ZERO,       REF_2,     TMP12);
03174                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);
03175 
03176                 vis_ld64_2(ref, stride_8, TMP2);
03177                 vis_pmerge(ZERO,       REF_6,     TMP16);
03178                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);
03179 
03180                 vis_ld64_2(ref, stride_16, TMP4);
03181                 ref += stride;
03182 
03183                 vis_ld64(dest[0], DST_0);
03184                 vis_faligndata(TMP0, TMP2, REF_0);
03185 
03186                 vis_ld64_2(dest, 8, DST_2);
03187                 vis_faligndata(TMP2, TMP4, REF_4);
03188 
03189                 vis_ld64_2(ref, stride, TMP6);
03190                 vis_pmerge(ZERO,     REF_0,     TMP0);
03191                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
03192 
03193                 vis_ld64_2(ref, stride_8, TMP8);
03194                 vis_pmerge(ZERO,     REF_4,     TMP4);
03195 
03196                 vis_ld64_2(ref, stride_16, TMP10);
03197                 ref += stride;
03198 
03199                 vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
03200                 vis_faligndata(TMP6, TMP8, REF_2);
03201                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
03202 
03203                 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
03204                 vis_faligndata(TMP8, TMP10, REF_6);
03205                 vis_mul8x16al(DST_0,   CONST_512, TMP20);
03206 
03207                 vis_padd16(TMP0, CONST_3, TMP0);
03208                 vis_mul8x16al(DST_1,   CONST_512, TMP22);
03209 
03210                 vis_padd16(TMP2, CONST_3, TMP2);
03211                 vis_mul8x16al(DST_2,   CONST_512, TMP24);
03212 
03213                 vis_padd16(TMP4, CONST_3, TMP4);
03214                 vis_mul8x16al(DST_3,   CONST_512, TMP26);
03215 
03216                 vis_padd16(TMP6, CONST_3, TMP6);
03217 
03218                 vis_padd16(TMP12, TMP20, TMP12);
03219                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);
03220 
03221                 vis_padd16(TMP14, TMP22, TMP14);
03222                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
03223 
03224                 vis_padd16(TMP16, TMP24, TMP16);
03225                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);
03226 
03227                 vis_padd16(TMP18, TMP26, TMP18);
03228                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
03229 
03230                 vis_padd16(TMP12, TMP0, TMP12);
03231                 vis_mul8x16au(REF_2,   CONST_256, TMP28);
03232 
03233                 vis_padd16(TMP14, TMP2, TMP14);
03234                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);
03235 
03236                 vis_padd16(TMP16, TMP4, TMP16);
03237                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);
03238 
03239                 vis_padd16(TMP18, TMP6, TMP18);
03240                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
03241 
03242                 vis_pack16(TMP12, DST_0);
03243                 vis_padd16(TMP28, TMP0, TMP12);
03244 
03245                 vis_pack16(TMP14, DST_1);
03246                 vis_st64(DST_0, dest[0]);
03247                 vis_padd16(TMP30, TMP2, TMP14);
03248 
03249                 vis_pack16(TMP16, DST_2);
03250                 vis_padd16(REF_S4, TMP4, TMP16);
03251 
03252                 vis_pack16(TMP18, DST_3);
03253                 vis_st64_2(DST_2, dest, 8);
03254                 dest += stride;
03255                 vis_padd16(REF_S6, TMP6, TMP18);
03256 
03257                 vis_padd16(TMP12, TMP20, TMP12);
03258 
03259                 vis_padd16(TMP14, TMP22, TMP14);
03260                 vis_pack16(TMP12, DST_0);
03261 
03262                 vis_padd16(TMP16, TMP24, TMP16);
03263                 vis_pack16(TMP14, DST_1);
03264                 vis_st64(DST_0, dest[0]);
03265 
03266                 vis_padd16(TMP18, TMP26, TMP18);
03267                 vis_pack16(TMP16, DST_2);
03268 
03269                 vis_pack16(TMP18, DST_3);
03270                 vis_st64_2(DST_2, dest, 8);
03271                 dest += stride;
03272         } while (--height);
03273 }
03274 
03275 static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref,
03276                             const int stride, int height)
03277 {
03278         int stride_8 = stride + 8;
03279 
03280         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
03281 
03282         ref = vis_alignaddr(ref);
03283 
03284         vis_ld64(ref[ 0], TMP0);
03285         vis_fzero(ZERO);
03286 
03287         vis_ld64(ref[ 8], TMP2);
03288 
03289         vis_ld64(constants3[0], CONST_3);
03290         vis_faligndata(TMP0, TMP2, REF_2);
03291 
03292         vis_ld64(constants256_512[0], CONST_256);
03293 
03294         height >>= 1;
03295         do {    /* 20 cycles */
03296                 vis_ld64_2(ref, stride, TMP0);
03297                 vis_pmerge(ZERO,       REF_2,     TMP8);
03298                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);
03299 
03300                 vis_ld64_2(ref, stride_8, TMP2);
03301                 ref += stride;
03302 
03303                 vis_ld64(dest[0], DST_0);
03304 
03305                 vis_ld64_2(dest, stride, DST_2);
03306                 vis_faligndata(TMP0, TMP2, REF_0);
03307 
03308                 vis_ld64_2(ref, stride, TMP4);
03309                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
03310                 vis_pmerge(ZERO,       REF_0,     TMP12);
03311 
03312                 vis_ld64_2(ref, stride_8, TMP6);
03313                 ref += stride;
03314                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
03315                 vis_pmerge(ZERO,       REF_0_1,   TMP14);
03316 
03317                 vis_padd16(TMP12, CONST_3, TMP12);
03318                 vis_mul8x16al(DST_2,   CONST_512, TMP24);
03319 
03320                 vis_padd16(TMP14, CONST_3, TMP14);
03321                 vis_mul8x16al(DST_3,   CONST_512, TMP26);
03322 
03323                 vis_faligndata(TMP4, TMP6, REF_2);
03324 
03325                 vis_padd16(TMP8, TMP12, TMP8);
03326 
03327                 vis_padd16(TMP10, TMP14, TMP10);
03328                 vis_mul8x16au(REF_2,   CONST_256, TMP20);
03329 
03330                 vis_padd16(TMP8, TMP16, TMP0);
03331                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);
03332 
03333                 vis_padd16(TMP10, TMP18, TMP2);
03334                 vis_pack16(TMP0, DST_0);
03335 
03336                 vis_pack16(TMP2, DST_1);
03337                 vis_st64(DST_0, dest[0]);
03338                 dest += stride;
03339                 vis_padd16(TMP12, TMP20, TMP12);
03340 
03341                 vis_padd16(TMP14, TMP22, TMP14);
03342 
03343                 vis_padd16(TMP12, TMP24, TMP0);
03344 
03345                 vis_padd16(TMP14, TMP26, TMP2);
03346                 vis_pack16(TMP0, DST_2);
03347 
03348                 vis_pack16(TMP2, DST_3);
03349                 vis_st64(DST_2, dest[0]);
03350                 dest += stride;
03351         } while (--height);
03352 }
03353 
03354 static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref,
03355                                        const int stride, int height)
03356 {
03357         unsigned long off = (unsigned long) ref & 0x7;
03358         unsigned long off_plus_1 = off + 1;
03359         int stride_8 = stride + 8;
03360         int stride_16 = stride + 16;
03361 
03362         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
03363 
03364         ref = vis_alignaddr(ref);
03365 
03366         vis_ld64(ref[ 0], TMP0);
03367         vis_fzero(ZERO);
03368 
03369         vis_ld64(ref[ 8], TMP2);
03370 
03371         vis_ld64(ref[16], TMP4);
03372 
03373         vis_ld64(constants1[0], CONST_1);
03374         vis_faligndata(TMP0, TMP2, REF_S0);
03375 
03376         vis_ld64(constants256_512[0], CONST_256);
03377         vis_faligndata(TMP2, TMP4, REF_S4);
03378 
03379         if (off != 0x7) {
03380                 vis_alignaddr_g0((void *)off_plus_1);
03381                 vis_faligndata(TMP0, TMP2, REF_S2);
03382                 vis_faligndata(TMP2, TMP4, REF_S6);
03383         } else {
03384                 vis_src1(TMP2, REF_S2);
03385                 vis_src1(TMP4, REF_S6);
03386         }
03387 
03388         height >>= 1;
03389         do {
03390                 vis_ld64_2(ref, stride, TMP0);
03391                 vis_mul8x16au(REF_S0, CONST_256, TMP12);
03392                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);
03393 
03394                 vis_alignaddr_g0((void *)off);
03395 
03396                 vis_ld64_2(ref, stride_8, TMP2);
03397                 vis_mul8x16au(REF_S2, CONST_256, TMP16);
03398                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);
03399 
03400                 vis_ld64_2(ref, stride_16, TMP4);
03401                 ref += stride;
03402                 vis_mul8x16au(REF_S4, CONST_256, TMP20);
03403                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);
03404 
03405                 vis_ld64_2(ref, stride, TMP6);
03406                 vis_mul8x16au(REF_S6, CONST_256, TMP24);
03407                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);
03408 
03409                 vis_ld64_2(ref, stride_8, TMP8);
03410                 vis_faligndata(TMP0, TMP2, REF_0);
03411 
03412                 vis_ld64_2(ref, stride_16, TMP10);
03413                 ref += stride;
03414                 vis_faligndata(TMP2, TMP4, REF_4);
03415 
03416                 vis_faligndata(TMP6, TMP8, REF_S0);
03417 
03418                 vis_faligndata(TMP8, TMP10, REF_S4);
03419 
03420                 if (off != 0x7) {
03421                         vis_alignaddr_g0((void *)off_plus_1);
03422                         vis_faligndata(TMP0, TMP2, REF_2);
03423                         vis_faligndata(TMP2, TMP4, REF_6);
03424                         vis_faligndata(TMP6, TMP8, REF_S2);
03425                         vis_faligndata(TMP8, TMP10, REF_S6);
03426                 } else {
03427                         vis_src1(TMP2, REF_2);
03428                         vis_src1(TMP4, REF_6);
03429                         vis_src1(TMP8, REF_S2);
03430                         vis_src1(TMP10, REF_S6);
03431                 }
03432 
03433                 vis_mul8x16au(REF_0, CONST_256, TMP0);
03434                 vis_pmerge(ZERO,      REF_0_1,  TMP2);
03435 
03436                 vis_mul8x16au(REF_2, CONST_256, TMP4);
03437                 vis_pmerge(ZERO,      REF_2_1,  TMP6);
03438 
03439                 vis_padd16(TMP0, CONST_2, TMP8);
03440                 vis_mul8x16au(REF_4, CONST_256, TMP0);
03441 
03442                 vis_padd16(TMP2, CONST_1, TMP10);
03443                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);
03444 
03445                 vis_padd16(TMP8, TMP4, TMP8);
03446                 vis_mul8x16au(REF_6, CONST_256, TMP4);
03447 
03448                 vis_padd16(TMP10, TMP6, TMP10);
03449                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);
03450 
03451                 vis_padd16(TMP12, TMP8, TMP12);
03452 
03453                 vis_padd16(TMP14, TMP10, TMP14);
03454 
03455                 vis_padd16(TMP12, TMP16, TMP12);
03456 
03457                 vis_padd16(TMP14, TMP18, TMP14);
03458                 vis_pack16(TMP12, DST_0);
03459 
03460                 vis_pack16(TMP14, DST_1);
03461                 vis_st64(DST_0, dest[0]);
03462                 vis_padd16(TMP0, CONST_1, TMP12);
03463 
03464                 vis_mul8x16au(REF_S0, CONST_256, TMP0);
03465                 vis_padd16(TMP2, CONST_1, TMP14);
03466 
03467                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
03468                 vis_padd16(TMP12, TMP4, TMP12);
03469 
03470                 vis_mul8x16au(REF_S2, CONST_256, TMP4);
03471                 vis_padd16(TMP14, TMP6, TMP14);
03472 
03473                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
03474                 vis_padd16(TMP20, TMP12, TMP20);
03475 
03476                 vis_padd16(TMP22, TMP14, TMP22);
03477 
03478                 vis_padd16(TMP20, TMP24, TMP20);
03479 
03480                 vis_padd16(TMP22, TMP26, TMP22);
03481                 vis_pack16(TMP20, DST_2);
03482 
03483                 vis_pack16(TMP22, DST_3);
03484                 vis_st64_2(DST_2, dest, 8);
03485                 dest += stride;
03486                 vis_padd16(TMP0, TMP4, TMP24);
03487 
03488                 vis_mul8x16au(REF_S4, CONST_256, TMP0);
03489                 vis_padd16(TMP2, TMP6, TMP26);
03490 
03491                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
03492                 vis_padd16(TMP24, TMP8, TMP24);
03493 
03494                 vis_padd16(TMP26, TMP10, TMP26);
03495                 vis_pack16(TMP24, DST_0);
03496 
03497                 vis_pack16(TMP26, DST_1);
03498                 vis_st64(DST_0, dest[0]);
03499                 vis_pmerge(ZERO, REF_S6, TMP4);
03500 
03501                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);
03502 
03503                 vis_padd16(TMP0, TMP4, TMP0);
03504 
03505                 vis_padd16(TMP2, TMP6, TMP2);
03506 
03507                 vis_padd16(TMP0, TMP12, TMP0);
03508 
03509                 vis_padd16(TMP2, TMP14, TMP2);
03510                 vis_pack16(TMP0, DST_2);
03511 
03512                 vis_pack16(TMP2, DST_3);
03513                 vis_st64_2(DST_2, dest, 8);
03514                 dest += stride;
03515         } while (--height);
03516 }
03517 
03518 static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref,
03519                                       const int stride, int height)
03520 {
03521         unsigned long off = (unsigned long) ref & 0x7;
03522         unsigned long off_plus_1 = off + 1;
03523         int stride_8 = stride + 8;
03524 
03525         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
03526 
03527         ref = vis_alignaddr(ref);
03528 
03529         vis_ld64(ref[ 0], TMP0);
03530         vis_fzero(ZERO);
03531 
03532         vis_ld64(ref[ 8], TMP2);
03533 
03534         vis_ld64(constants1[0], CONST_1);
03535 
03536         vis_ld64(constants256_512[0], CONST_256);
03537         vis_faligndata(TMP0, TMP2, REF_S0);
03538 
03539         if (off != 0x7) {
03540                 vis_alignaddr_g0((void *)off_plus_1);
03541                 vis_faligndata(TMP0, TMP2, REF_S2);
03542         } else {
03543                 vis_src1(TMP2, REF_S2);
03544         }
03545 
03546         height >>= 1;
03547         do {    /* 26 cycles */
03548                 vis_ld64_2(ref, stride, TMP0);
03549                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);
03550                 vis_pmerge(ZERO,        REF_S2,    TMP12);
03551 
03552                 vis_alignaddr_g0((void *)off);
03553 
03554                 vis_ld64_2(ref, stride_8, TMP2);
03555                 ref += stride;
03556                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
03557                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);
03558 
03559                 vis_ld64_2(ref, stride, TMP4);
03560 
03561                 vis_ld64_2(ref, stride_8, TMP6);
03562                 ref += stride;
03563                 vis_faligndata(TMP0, TMP2, REF_S4);
03564 
03565                 vis_pmerge(ZERO, REF_S4, TMP18);
03566 
03567                 vis_pmerge(ZERO, REF_S4_1, TMP20);
03568 
03569                 vis_faligndata(TMP4, TMP6, REF_S0);
03570 
03571                 if (off != 0x7) {
03572                         vis_alignaddr_g0((void *)off_plus_1);
03573                         vis_faligndata(TMP0, TMP2, REF_S6);
03574                         vis_faligndata(TMP4, TMP6, REF_S2);
03575                 } else {
03576                         vis_src1(TMP2, REF_S6);
03577                         vis_src1(TMP6, REF_S2);
03578                 }
03579 
03580                 vis_padd16(TMP18, CONST_1, TMP18);
03581                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);
03582 
03583                 vis_padd16(TMP20, CONST_1, TMP20);
03584                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
03585 
03586                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);
03587                 vis_pmerge(ZERO, REF_S0_1, TMP28);
03588 
03589                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);
03590                 vis_padd16(TMP18, TMP22, TMP18);
03591 
03592                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
03593                 vis_padd16(TMP20, TMP24, TMP20);
03594 
03595                 vis_padd16(TMP8,  TMP18, TMP8);
03596 
03597                 vis_padd16(TMP10, TMP20, TMP10);
03598 
03599                 vis_padd16(TMP8,  TMP12, TMP8);
03600 
03601                 vis_padd16(TMP10, TMP14, TMP10);
03602                 vis_pack16(TMP8,  DST_0);
03603 
03604                 vis_pack16(TMP10, DST_1);
03605                 vis_st64(DST_0, dest[0]);
03606                 dest += stride;
03607                 vis_padd16(TMP18, TMP26, TMP18);
03608 
03609                 vis_padd16(TMP20, TMP28, TMP20);
03610 
03611                 vis_padd16(TMP18, TMP30, TMP18);
03612 
03613                 vis_padd16(TMP20, TMP32, TMP20);
03614                 vis_pack16(TMP18, DST_2);
03615 
03616                 vis_pack16(TMP20, DST_3);
03617                 vis_st64(DST_2, dest[0]);
03618                 dest += stride;
03619         } while (--height);
03620 }
03621 
03622 static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref,
03623                                        const int stride, int height)
03624 {
03625         unsigned long off = (unsigned long) ref & 0x7;
03626         unsigned long off_plus_1 = off + 1;
03627         int stride_8 = stride + 8;
03628         int stride_16 = stride + 16;
03629 
03630         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
03631 
03632         ref = vis_alignaddr(ref);
03633 
03634         vis_ld64(ref[ 0], TMP0);
03635         vis_fzero(ZERO);
03636 
03637         vis_ld64(ref[ 8], TMP2);
03638 
03639         vis_ld64(ref[16], TMP4);
03640 
03641         vis_ld64(constants6[0], CONST_6);
03642         vis_faligndata(TMP0, TMP2, REF_S0);
03643 
03644         vis_ld64(constants256_1024[0], CONST_256);
03645         vis_faligndata(TMP2, TMP4, REF_S4);
03646 
03647         if (off != 0x7) {
03648                 vis_alignaddr_g0((void *)off_plus_1);
03649                 vis_faligndata(TMP0, TMP2, REF_S2);
03650                 vis_faligndata(TMP2, TMP4, REF_S6);
03651         } else {
03652                 vis_src1(TMP2, REF_S2);
03653                 vis_src1(TMP4, REF_S6);
03654         }
03655 
03656         height >>= 1;
03657         do {    /* 55 cycles */
03658                 vis_ld64_2(ref, stride, TMP0);
03659                 vis_mul8x16au(REF_S0, CONST_256, TMP12);
03660                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);
03661 
03662                 vis_alignaddr_g0((void *)off);
03663 
03664                 vis_ld64_2(ref, stride_8, TMP2);
03665                 vis_mul8x16au(REF_S2, CONST_256, TMP16);
03666                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);
03667 
03668                 vis_ld64_2(ref, stride_16, TMP4);
03669                 ref += stride;
03670                 vis_mul8x16au(REF_S4, CONST_256, TMP20);
03671                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);
03672 
03673                 vis_ld64_2(ref, stride, TMP6);
03674                 vis_mul8x16au(REF_S6, CONST_256, TMP24);
03675                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);
03676 
03677                 vis_ld64_2(ref, stride_8, TMP8);
03678                 vis_faligndata(TMP0, TMP2, REF_0);
03679 
03680                 vis_ld64_2(ref, stride_16, TMP10);
03681                 ref += stride;
03682                 vis_faligndata(TMP2, TMP4, REF_4);
03683 
03684                 vis_ld64(dest[0], DST_0);
03685                 vis_faligndata(TMP6, TMP8, REF_S0);
03686 
03687                 vis_ld64_2(dest, 8, DST_2);
03688                 vis_faligndata(TMP8, TMP10, REF_S4);
03689 
03690                 if (off != 0x7) {
03691                         vis_alignaddr_g0((void *)off_plus_1);
03692                         vis_faligndata(TMP0, TMP2, REF_2);
03693                         vis_faligndata(TMP2, TMP4, REF_6);
03694                         vis_faligndata(TMP6, TMP8, REF_S2);
03695                         vis_faligndata(TMP8, TMP10, REF_S6);
03696                 } else {
03697                         vis_src1(TMP2, REF_2);
03698                         vis_src1(TMP4, REF_6);
03699                         vis_src1(TMP8, REF_S2);
03700                         vis_src1(TMP10, REF_S6);
03701                 }
03702 
03703                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
03704                 vis_pmerge(ZERO, REF_0, TMP0);
03705 
03706                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
03707                 vis_pmerge(ZERO,      REF_0_1,  TMP2);
03708 
03709                 vis_mul8x16au(REF_2, CONST_256, TMP4);
03710                 vis_pmerge(ZERO,      REF_2_1,  TMP6);
03711 
03712                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);
03713                 vis_padd16(TMP0, CONST_6, TMP0);
03714 
03715                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);
03716                 vis_padd16(TMP2, CONST_6, TMP2);
03717 
03718                 vis_padd16(TMP0, TMP4, TMP0);
03719                 vis_mul8x16au(REF_4, CONST_256, TMP4);
03720 
03721                 vis_padd16(TMP2, TMP6, TMP2);
03722                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
03723 
03724                 vis_padd16(TMP12, TMP0, TMP12);
03725                 vis_mul8x16au(REF_6, CONST_256, TMP8);
03726 
03727                 vis_padd16(TMP14, TMP2, TMP14);
03728                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);
03729 
03730                 vis_padd16(TMP12, TMP16, TMP12);
03731                 vis_mul8x16au(REF_S0, CONST_256, REF_4);
03732 
03733                 vis_padd16(TMP14, TMP18, TMP14);
03734                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
03735 
03736                 vis_padd16(TMP12, TMP30, TMP12);
03737 
03738                 vis_padd16(TMP14, TMP32, TMP14);
03739                 vis_pack16(TMP12, DST_0);
03740 
03741                 vis_pack16(TMP14, DST_1);
03742                 vis_st64(DST_0, dest[0]);
03743                 vis_padd16(TMP4, CONST_6, TMP4);
03744 
03745                 vis_ld64_2(dest, stride, DST_0);
03746                 vis_padd16(TMP6, CONST_6, TMP6);
03747                 vis_mul8x16au(REF_S2, CONST_256, TMP12);
03748 
03749                 vis_padd16(TMP4, TMP8, TMP4);
03750                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);
03751 
03752                 vis_padd16(TMP6, TMP10, TMP6);
03753 
03754                 vis_padd16(TMP20, TMP4, TMP20);
03755 
03756                 vis_padd16(TMP22, TMP6, TMP22);
03757 
03758                 vis_padd16(TMP20, TMP24, TMP20);
03759 
03760                 vis_padd16(TMP22, TMP26, TMP22);
03761 
03762                 vis_padd16(TMP20, REF_0, TMP20);
03763                 vis_mul8x16au(REF_S4, CONST_256, REF_0);
03764 
03765                 vis_padd16(TMP22, REF_2, TMP22);
03766                 vis_pack16(TMP20, DST_2);
03767 
03768                 vis_pack16(TMP22, DST_3);
03769                 vis_st64_2(DST_2, dest, 8);
03770                 dest += stride;
03771 
03772                 vis_ld64_2(dest, 8, DST_2);
03773                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
03774                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);
03775 
03776                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
03777                 vis_padd16(REF_4, TMP0, TMP8);
03778 
03779                 vis_mul8x16au(REF_S6, CONST_256, REF_4);
03780                 vis_padd16(REF_6, TMP2, TMP10);
03781 
03782                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
03783                 vis_padd16(TMP8, TMP12, TMP8);
03784 
03785                 vis_padd16(TMP10, TMP14, TMP10);
03786 
03787                 vis_padd16(TMP8, TMP30, TMP8);
03788 
03789                 vis_padd16(TMP10, TMP32, TMP10);
03790                 vis_pack16(TMP8, DST_0);
03791 
03792                 vis_pack16(TMP10, DST_1);
03793                 vis_st64(DST_0, dest[0]);
03794 
03795                 vis_padd16(REF_0, TMP4, REF_0);
03796 
03797                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);
03798                 vis_padd16(REF_2, TMP6, REF_2);
03799 
03800                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);
03801                 vis_padd16(REF_0, REF_4, REF_0);
03802 
03803                 vis_padd16(REF_2, REF_6, REF_2);
03804 
03805                 vis_padd16(REF_0, TMP30, REF_0);
03806 
03807                 /* stall */
03808 
03809                 vis_padd16(REF_2, TMP32, REF_2);
03810                 vis_pack16(REF_0, DST_2);
03811 
03812                 vis_pack16(REF_2, DST_3);
03813                 vis_st64_2(DST_2, dest, 8);
03814                 dest += stride;
03815         } while (--height);
03816 }
03817 
03818 static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref,
03819                                       const int stride, int height)
03820 {
03821         unsigned long off = (unsigned long) ref & 0x7;
03822         unsigned long off_plus_1 = off + 1;
03823         int stride_8 = stride + 8;
03824 
03825         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
03826 
03827         ref = vis_alignaddr(ref);
03828 
03829         vis_ld64(ref[0], TMP0);
03830         vis_fzero(ZERO);
03831 
03832         vis_ld64_2(ref, 8, TMP2);
03833 
03834         vis_ld64(constants6[0], CONST_6);
03835 
03836         vis_ld64(constants256_1024[0], CONST_256);
03837         vis_faligndata(TMP0, TMP2, REF_S0);
03838 
03839         if (off != 0x7) {
03840                 vis_alignaddr_g0((void *)off_plus_1);
03841                 vis_faligndata(TMP0, TMP2, REF_S2);
03842         } else {
03843                 vis_src1(TMP2, REF_S2);
03844         }
03845 
03846         height >>= 1;
03847         do {    /* 31 cycles */
03848                 vis_ld64_2(ref, stride, TMP0);
03849                 vis_mul8x16au(REF_S0, CONST_256, TMP8);
03850                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);
03851 
03852                 vis_ld64_2(ref, stride_8, TMP2);
03853                 ref += stride;
03854                 vis_mul8x16au(REF_S2, CONST_256, TMP12);
03855                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);
03856 
03857                 vis_alignaddr_g0((void *)off);
03858 
03859                 vis_ld64_2(ref, stride, TMP4);
03860                 vis_faligndata(TMP0, TMP2, REF_S4);
03861 
03862                 vis_ld64_2(ref, stride_8, TMP6);
03863                 ref += stride;
03864 
03865                 vis_ld64(dest[0], DST_0);
03866                 vis_faligndata(TMP4, TMP6, REF_S0);
03867 
03868                 vis_ld64_2(dest, stride, DST_2);
03869 
03870                 if (off != 0x7) {
03871                         vis_alignaddr_g0((void *)off_plus_1);
03872                         vis_faligndata(TMP0, TMP2, REF_S6);
03873                         vis_faligndata(TMP4, TMP6, REF_S2);
03874                 } else {
03875                         vis_src1(TMP2, REF_S6);
03876                         vis_src1(TMP6, REF_S2);
03877                 }
03878 
03879                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
03880                 vis_pmerge(ZERO, REF_S4, TMP22);
03881 
03882                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
03883                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);
03884 
03885                 vis_mul8x16au(REF_S6, CONST_256, TMP26);
03886                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);
03887 
03888                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);
03889                 vis_padd16(TMP22, CONST_6, TMP22);
03890 
03891                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
03892                 vis_padd16(TMP24, CONST_6, TMP24);
03893 
03894                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);
03895                 vis_padd16(TMP22, TMP26, TMP22);
03896 
03897                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);
03898                 vis_padd16(TMP24, TMP28, TMP24);
03899 
03900                 vis_mul8x16au(REF_S2, CONST_256, TMP26);
03901                 vis_padd16(TMP8, TMP22, TMP8);
03902 
03903                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
03904                 vis_padd16(TMP10, TMP24, TMP10);
03905 
03906                 vis_padd16(TMP8, TMP12, TMP8);
03907 
03908                 vis_padd16(TMP10, TMP14, TMP10);
03909 
03910                 vis_padd16(TMP8, TMP30, TMP8);
03911 
03912                 vis_padd16(TMP10, TMP32, TMP10);
03913                 vis_pack16(TMP8, DST_0);
03914 
03915                 vis_pack16(TMP10, DST_1);
03916                 vis_st64(DST_0, dest[0]);
03917                 dest += stride;
03918 
03919                 vis_padd16(REF_S4, TMP22, TMP12);
03920 
03921                 vis_padd16(REF_S6, TMP24, TMP14);
03922 
03923                 vis_padd16(TMP12, TMP26, TMP12);
03924 
03925                 vis_padd16(TMP14, TMP28, TMP14);
03926 
03927                 vis_padd16(TMP12, REF_0, TMP12);
03928 
03929                 vis_padd16(TMP14, REF_2, TMP14);
03930                 vis_pack16(TMP12, DST_2);
03931 
03932                 vis_pack16(TMP14, DST_3);
03933                 vis_st64(DST_2, dest[0]);
03934                 dest += stride;
03935         } while (--height);
03936 }
03937 
03938 /* End of no rounding code */
03939 
03940 #define ACCEL_SPARC_VIS 1
03941 #define ACCEL_SPARC_VIS2 2
03942 
03943 static int vis_level(void)
03944 {
03945     int accel = 0;
03946     accel |= ACCEL_SPARC_VIS;
03947     accel |= ACCEL_SPARC_VIS2;
03948     return accel;
03949 }
03950 
03951 /* libavcodec initialization code */
03952 void ff_dsputil_init_vis(DSPContext* c, AVCodecContext *avctx)
03953 {
03954   /* VIS-specific optimizations */
03955   int accel = vis_level ();
03956   const int high_bit_depth = avctx->bits_per_raw_sample > 8;
03957 
03958   if (accel & ACCEL_SPARC_VIS) {
03959       if (avctx->bits_per_raw_sample <= 8 &&
03960           avctx->idct_algo == FF_IDCT_SIMPLEVIS) {
03961           c->idct_put = ff_simple_idct_put_vis;
03962           c->idct_add = ff_simple_idct_add_vis;
03963           c->idct     = ff_simple_idct_vis;
03964           c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
03965       }
03966 
03967       if (!high_bit_depth) {
03968       c->put_pixels_tab[0][0] = MC_put_o_16_vis;
03969       c->put_pixels_tab[0][1] = MC_put_x_16_vis;
03970       c->put_pixels_tab[0][2] = MC_put_y_16_vis;
03971       c->put_pixels_tab[0][3] = MC_put_xy_16_vis;
03972 
03973       c->put_pixels_tab[1][0] = MC_put_o_8_vis;
03974       c->put_pixels_tab[1][1] = MC_put_x_8_vis;
03975       c->put_pixels_tab[1][2] = MC_put_y_8_vis;
03976       c->put_pixels_tab[1][3] = MC_put_xy_8_vis;
03977 
03978       c->avg_pixels_tab[0][0] = MC_avg_o_16_vis;
03979       c->avg_pixels_tab[0][1] = MC_avg_x_16_vis;
03980       c->avg_pixels_tab[0][2] = MC_avg_y_16_vis;
03981       c->avg_pixels_tab[0][3] = MC_avg_xy_16_vis;
03982 
03983       c->avg_pixels_tab[1][0] = MC_avg_o_8_vis;
03984       c->avg_pixels_tab[1][1] = MC_avg_x_8_vis;
03985       c->avg_pixels_tab[1][2] = MC_avg_y_8_vis;
03986       c->avg_pixels_tab[1][3] = MC_avg_xy_8_vis;
03987 
03988       c->put_no_rnd_pixels_tab[0][0] = MC_put_no_round_o_16_vis;
03989       c->put_no_rnd_pixels_tab[0][1] = MC_put_no_round_x_16_vis;
03990       c->put_no_rnd_pixels_tab[0][2] = MC_put_no_round_y_16_vis;
03991       c->put_no_rnd_pixels_tab[0][3] = MC_put_no_round_xy_16_vis;
03992 
03993       c->put_no_rnd_pixels_tab[1][0] = MC_put_no_round_o_8_vis;
03994       c->put_no_rnd_pixels_tab[1][1] = MC_put_no_round_x_8_vis;
03995       c->put_no_rnd_pixels_tab[1][2] = MC_put_no_round_y_8_vis;
03996       c->put_no_rnd_pixels_tab[1][3] = MC_put_no_round_xy_8_vis;
03997 
03998       c->avg_no_rnd_pixels_tab[0][0] = MC_avg_no_round_o_16_vis;
03999       c->avg_no_rnd_pixels_tab[0][1] = MC_avg_no_round_x_16_vis;
04000       c->avg_no_rnd_pixels_tab[0][2] = MC_avg_no_round_y_16_vis;
04001       c->avg_no_rnd_pixels_tab[0][3] = MC_avg_no_round_xy_16_vis;
04002 
04003       c->avg_no_rnd_pixels_tab[1][0] = MC_avg_no_round_o_8_vis;
04004       c->avg_no_rnd_pixels_tab[1][1] = MC_avg_no_round_x_8_vis;
04005       c->avg_no_rnd_pixels_tab[1][2] = MC_avg_no_round_y_8_vis;
04006       c->avg_no_rnd_pixels_tab[1][3] = MC_avg_no_round_xy_8_vis;
04007       }
04008   }
04009 }
libavcodec/sparc/dsputil_vis.c
