• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/sparc/dsputil_vis.c

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

Generated on Sat Feb 16 2013 09:23:13 for ffmpeg by  doxygen 1.7.1