Cinelerra: hvirtual/quicktime/ffmpeg/libavcodec/sparc/dsputil

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