FFmpeg: libavcodec/sparc/dsputil

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