MythTV: motion_comp_vis.c Source File

00001 /*
00002  * motion_comp_vis.c
00003  * Copyright (C) 2003 David S. Miller <davem@redhat.com>
00004  *
00005  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
00006  * See http://libmpeg2.sourceforge.net/ for updates.
00007  *
00008  * mpeg2dec is free software; you can redistribute it and/or modify
00009  * it under the terms of the GNU General Public License as published by
00010  * the Free Software Foundation; either version 2 of the License, or
00011  * (at your option) any later version.
00012  *
00013  * mpeg2dec is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016  * GNU General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU General Public License
00019  * along with this program; if not, write to the Free Software
00020  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00021  */
00022 
00023 #include "mpeg2config.h"
00024 
00025 #if ARCH_SPARC
00026 
00027 #include <inttypes.h>
00028 
00029 #include "mpeg2.h"
00030 #include "attributes.h"
00031 #include "mpeg2_internal.h"
00032 #include "vis.h"
00033 
00034 /* The trick used in some of this file is the formula from the MMX
00035  * motion comp code, which is:
00036  *
00037  * (x+y+1)>>1 == (x|y)-((x^y)>>1)
00038  *
00039  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
00040  * We avoid overflows by masking before we do the shift, and we
00041  * implement the shift by multiplying by 1/2 using mul8x16.  So in
00042  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
00043  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
00044  * the value 0x80808080 is in f8):
00045  *
00046  *      fxor            f0, f2, f10
00047  *      fand            f10, f4, f10
00048  *      fmul8x16        f8, f10, f10
00049  *      fand            f10, f6, f10
00050  *      for             f0, f2, f12
00051  *      fpsub16         f12, f10, f10
00052  */
00053 
00054 #define DUP4(x) {x, x, x, x}
00055 #define DUP8(x) {x, x, x, x, x, x, x, x}
00056 static const int16_t constants1[] ATTR_ALIGN(8) = DUP4 (1);
00057 static const int16_t constants2[] ATTR_ALIGN(8) = DUP4 (2);
00058 static const int16_t constants3[] ATTR_ALIGN(8) = DUP4 (3);
00059 static const int16_t constants6[] ATTR_ALIGN(8) = DUP4 (6);
00060 static const int8_t constants_fe[] ATTR_ALIGN(8) = DUP8 (0xfe);
00061 static const int8_t constants_7f[] ATTR_ALIGN(8) = DUP8 (0x7f);
00062 static const int8_t constants128[] ATTR_ALIGN(8) = DUP8 (128);
00063 static const int16_t constants256_512[] ATTR_ALIGN(8) =
00064         {256, 512, 256, 512};
00065 static const int16_t constants256_1024[] ATTR_ALIGN(8) =
00066         {256, 1024, 256, 1024};
00067 
00068 #define REF_0           0
00069 #define REF_0_1         1
00070 #define REF_2           2
00071 #define REF_2_1         3
00072 #define REF_4           4
00073 #define REF_4_1         5
00074 #define REF_6           6
00075 #define REF_6_1         7
00076 #define REF_S0          8
00077 #define REF_S0_1        9
00078 #define REF_S2          10
00079 #define REF_S2_1        11
00080 #define REF_S4          12
00081 #define REF_S4_1        13
00082 #define REF_S6          14
00083 #define REF_S6_1        15
00084 #define DST_0           16
00085 #define DST_1           17
00086 #define DST_2           18
00087 #define DST_3           19
00088 #define CONST_1         20
00089 #define CONST_2         20
00090 #define CONST_3         20
00091 #define CONST_6         20
00092 #define MASK_fe         20
00093 #define CONST_128       22
00094 #define CONST_256       22
00095 #define CONST_512       22
00096 #define CONST_1024      22
00097 #define TMP0            24
00098 #define TMP1            25
00099 #define TMP2            26
00100 #define TMP3            27
00101 #define TMP4            28
00102 #define TMP5            29
00103 #define ZERO            30
00104 #define MASK_7f         30
00105 
00106 #define TMP6            32
00107 #define TMP8            34
00108 #define TMP10           36
00109 #define TMP12           38
00110 #define TMP14           40
00111 #define TMP16           42
00112 #define TMP18           44
00113 #define TMP20           46
00114 #define TMP22           48
00115 #define TMP24           50
00116 #define TMP26           52
00117 #define TMP28           54
00118 #define TMP30           56
00119 #define TMP32           58
00120 
00121 static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * _ref,
00122                              const int stride, int height)
00123 {
00124         uint8_t *ref = (uint8_t *) _ref;
00125         int offset;
00126 
00127         ref = vis_alignaddr(ref);
00128         offset = (ref != _ref) ? 16 : 0;
00129         do {    /* 5 cycles */
00130                 vis_ld64(ref[0], TMP0);
00131 
00132                 vis_ld64_2(ref, 8, TMP2);
00133 
00134                 vis_ld64_2(ref, offset, TMP4);
00135                 ref += stride;
00136 
00137                 vis_faligndata(TMP0, TMP2, REF_0);
00138                 vis_st64(REF_0, dest[0]);
00139 
00140                 vis_faligndata(TMP2, TMP4, REF_2);
00141                 vis_st64_2(REF_2, dest, 8);
00142                 dest += stride;
00143         } while (--height);
00144 }
00145 
00146 static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * _ref,
00147                             const int stride, int height)
00148 {
00149         uint8_t *ref = (uint8_t *) _ref;
00150         int offset;
00151 
00152         ref = vis_alignaddr(ref);
00153         offset = (ref != _ref) ? 8 : 0;
00154         do {    /* 4 cycles */
00155                 vis_ld64(ref[0], TMP0);
00156 
00157                 vis_ld64_2(ref, offset, TMP2);
00158                 ref += stride;
00159 
00160                 /* stall */
00161 
00162                 vis_faligndata(TMP0, TMP2, REF_0);
00163                 vis_st64(REF_0, dest[0]);
00164                 dest += stride;
00165         } while (--height);
00166 }
00167 
00168 
00169 static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * _ref,
00170                              const int stride, int height)
00171 {
00172         uint8_t *ref = (uint8_t *) _ref;
00173         int stride_8 = stride + 8;
00174         int offset;
00175 
00176         ref = vis_alignaddr(ref);
00177         offset = (ref != _ref) ? 16 : 0;
00178 
00179         vis_ld64(ref[0], TMP0);
00180 
00181         vis_ld64(ref[8], TMP2);
00182 
00183         vis_ld64_2(ref, offset, TMP4);
00184 
00185         vis_ld64(dest[0], DST_0);
00186 
00187         vis_ld64(dest[8], DST_2);
00188 
00189         vis_ld64(constants_fe[0], MASK_fe);
00190         vis_faligndata(TMP0, TMP2, REF_0);
00191 
00192         vis_ld64(constants_7f[0], MASK_7f);
00193         vis_faligndata(TMP2, TMP4, REF_2);
00194 
00195         vis_ld64(constants128[0], CONST_128);
00196 
00197         ref += stride;
00198         height = (height >> 1) - 1;
00199 
00200         do {    /* 24 cycles */
00201                 vis_ld64(ref[0], TMP0);
00202                 vis_xor(DST_0, REF_0, TMP6);
00203 
00204                 vis_ld64_2(ref, 8, TMP2);
00205                 vis_and(TMP6, MASK_fe, TMP6);
00206 
00207                 vis_ld64_2(ref, offset, TMP4);
00208                 ref += stride;
00209                 vis_mul8x16(CONST_128, TMP6, TMP6);
00210                 vis_xor(DST_2, REF_2, TMP8);
00211 
00212                 vis_and(TMP8, MASK_fe, TMP8);
00213 
00214                 vis_or(DST_0, REF_0, TMP10);
00215                 vis_ld64_2(dest, stride, DST_0);
00216                 vis_mul8x16(CONST_128, TMP8, TMP8);
00217 
00218                 vis_or(DST_2, REF_2, TMP12);
00219                 vis_ld64_2(dest, stride_8, DST_2);
00220 
00221                 vis_ld64(ref[0], TMP14);
00222                 vis_and(TMP6, MASK_7f, TMP6);
00223 
00224                 vis_and(TMP8, MASK_7f, TMP8);
00225 
00226                 vis_psub16(TMP10, TMP6, TMP6);
00227                 vis_st64(TMP6, dest[0]);
00228 
00229                 vis_psub16(TMP12, TMP8, TMP8);
00230                 vis_st64_2(TMP8, dest, 8);
00231 
00232                 dest += stride;
00233                 vis_ld64_2(ref, 8, TMP16);
00234                 vis_faligndata(TMP0, TMP2, REF_0);
00235 
00236                 vis_ld64_2(ref, offset, TMP18);
00237                 vis_faligndata(TMP2, TMP4, REF_2);
00238                 ref += stride;
00239 
00240                 vis_xor(DST_0, REF_0, TMP20);
00241 
00242                 vis_and(TMP20, MASK_fe, TMP20);
00243 
00244                 vis_xor(DST_2, REF_2, TMP22);
00245                 vis_mul8x16(CONST_128, TMP20, TMP20);
00246 
00247                 vis_and(TMP22, MASK_fe, TMP22);
00248 
00249                 vis_or(DST_0, REF_0, TMP24);
00250                 vis_mul8x16(CONST_128, TMP22, TMP22);
00251 
00252                 vis_or(DST_2, REF_2, TMP26);
00253 
00254                 vis_ld64_2(dest, stride, DST_0);
00255                 vis_faligndata(TMP14, TMP16, REF_0);
00256 
00257                 vis_ld64_2(dest, stride_8, DST_2);
00258                 vis_faligndata(TMP16, TMP18, REF_2);
00259 
00260                 vis_and(TMP20, MASK_7f, TMP20);
00261 
00262                 vis_and(TMP22, MASK_7f, TMP22);
00263 
00264                 vis_psub16(TMP24, TMP20, TMP20);
00265                 vis_st64(TMP20, dest[0]);
00266 
00267                 vis_psub16(TMP26, TMP22, TMP22);
00268                 vis_st64_2(TMP22, dest, 8);
00269                 dest += stride;
00270         } while (--height);
00271 
00272         vis_ld64(ref[0], TMP0);
00273         vis_xor(DST_0, REF_0, TMP6);
00274 
00275         vis_ld64_2(ref, 8, TMP2);
00276         vis_and(TMP6, MASK_fe, TMP6);
00277 
00278         vis_ld64_2(ref, offset, TMP4);
00279         vis_mul8x16(CONST_128, TMP6, TMP6);
00280         vis_xor(DST_2, REF_2, TMP8);
00281 
00282         vis_and(TMP8, MASK_fe, TMP8);
00283 
00284         vis_or(DST_0, REF_0, TMP10);
00285         vis_ld64_2(dest, stride, DST_0);
00286         vis_mul8x16(CONST_128, TMP8, TMP8);
00287 
00288         vis_or(DST_2, REF_2, TMP12);
00289         vis_ld64_2(dest, stride_8, DST_2);
00290 
00291         vis_ld64(ref[0], TMP14);
00292         vis_and(TMP6, MASK_7f, TMP6);
00293 
00294         vis_and(TMP8, MASK_7f, TMP8);
00295 
00296         vis_psub16(TMP10, TMP6, TMP6);
00297         vis_st64(TMP6, dest[0]);
00298 
00299         vis_psub16(TMP12, TMP8, TMP8);
00300         vis_st64_2(TMP8, dest, 8);
00301 
00302         dest += stride;
00303         vis_faligndata(TMP0, TMP2, REF_0);
00304 
00305         vis_faligndata(TMP2, TMP4, REF_2);
00306 
00307         vis_xor(DST_0, REF_0, TMP20);
00308 
00309         vis_and(TMP20, MASK_fe, TMP20);
00310 
00311         vis_xor(DST_2, REF_2, TMP22);
00312         vis_mul8x16(CONST_128, TMP20, TMP20);
00313 
00314         vis_and(TMP22, MASK_fe, TMP22);
00315 
00316         vis_or(DST_0, REF_0, TMP24);
00317         vis_mul8x16(CONST_128, TMP22, TMP22);
00318 
00319         vis_or(DST_2, REF_2, TMP26);
00320 
00321         vis_and(TMP20, MASK_7f, TMP20);
00322 
00323         vis_and(TMP22, MASK_7f, TMP22);
00324 
00325         vis_psub16(TMP24, TMP20, TMP20);
00326         vis_st64(TMP20, dest[0]);
00327 
00328         vis_psub16(TMP26, TMP22, TMP22);
00329         vis_st64_2(TMP22, dest, 8);
00330 }
00331 
00332 static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * _ref,
00333                             const int stride, int height)
00334 {
00335         uint8_t *ref = (uint8_t *) _ref;
00336         int offset;
00337 
00338         ref = vis_alignaddr(ref);
00339         offset = (ref != _ref) ? 8 : 0;
00340 
00341         vis_ld64(ref[0], TMP0);
00342 
00343         vis_ld64_2(ref, offset, TMP2);
00344 
00345         vis_ld64(dest[0], DST_0);
00346 
00347         vis_ld64(constants_fe[0], MASK_fe);
00348 
00349         vis_ld64(constants_7f[0], MASK_7f);
00350         vis_faligndata(TMP0, TMP2, REF_0);
00351 
00352         vis_ld64(constants128[0], CONST_128);
00353 
00354         ref += stride;
00355         height = (height >> 1) - 1;
00356 
00357         do {    /* 12 cycles */
00358                 vis_ld64(ref[0], TMP0);
00359                 vis_xor(DST_0, REF_0, TMP4);
00360 
00361                 vis_ld64_2(ref, offset, TMP2);
00362                 vis_and(TMP4, MASK_fe, TMP4);
00363 
00364                 vis_or(DST_0, REF_0, TMP6);
00365                 vis_ld64_2(dest, stride, DST_0);
00366                 ref += stride;
00367                 vis_mul8x16(CONST_128, TMP4, TMP4);
00368 
00369                 vis_ld64(ref[0], TMP12);
00370                 vis_faligndata(TMP0, TMP2, REF_0);
00371 
00372                 vis_ld64_2(ref, offset, TMP2);
00373                 vis_xor(DST_0, REF_0, TMP0);
00374                 ref += stride;
00375 
00376                 vis_and(TMP0, MASK_fe, TMP0);
00377 
00378                 vis_and(TMP4, MASK_7f, TMP4);
00379 
00380                 vis_psub16(TMP6, TMP4, TMP4);
00381                 vis_st64(TMP4, dest[0]);
00382                 dest += stride;
00383                 vis_mul8x16(CONST_128, TMP0, TMP0);
00384 
00385                 vis_or(DST_0, REF_0, TMP6);
00386                 vis_ld64_2(dest, stride, DST_0);
00387 
00388                 vis_faligndata(TMP12, TMP2, REF_0);
00389 
00390                 vis_and(TMP0, MASK_7f, TMP0);
00391 
00392                 vis_psub16(TMP6, TMP0, TMP4);
00393                 vis_st64(TMP4, dest[0]);
00394                 dest += stride;
00395         } while (--height);
00396 
00397         vis_ld64(ref[0], TMP0);
00398         vis_xor(DST_0, REF_0, TMP4);
00399 
00400         vis_ld64_2(ref, offset, TMP2);
00401         vis_and(TMP4, MASK_fe, TMP4);
00402 
00403         vis_or(DST_0, REF_0, TMP6);
00404         vis_ld64_2(dest, stride, DST_0);
00405         vis_mul8x16(CONST_128, TMP4, TMP4);
00406 
00407         vis_faligndata(TMP0, TMP2, REF_0);
00408 
00409         vis_xor(DST_0, REF_0, TMP0);
00410 
00411         vis_and(TMP0, MASK_fe, TMP0);
00412 
00413         vis_and(TMP4, MASK_7f, TMP4);
00414 
00415         vis_psub16(TMP6, TMP4, TMP4);
00416         vis_st64(TMP4, dest[0]);
00417         dest += stride;
00418         vis_mul8x16(CONST_128, TMP0, TMP0);
00419 
00420         vis_or(DST_0, REF_0, TMP6);
00421 
00422         vis_and(TMP0, MASK_7f, TMP0);
00423 
00424         vis_psub16(TMP6, TMP0, TMP4);
00425         vis_st64(TMP4, dest[0]);
00426 }
00427 
00428 static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * _ref,
00429                              const int stride, int height)
00430 {
00431         uint8_t *ref = (uint8_t *) _ref;
00432         unsigned long off = (unsigned long) ref & 0x7;
00433         unsigned long off_plus_1 = off + 1;
00434 
00435         ref = vis_alignaddr(ref);
00436 
00437         vis_ld64(ref[0],    TMP0);
00438 
00439         vis_ld64_2(ref, 8,  TMP2);
00440 
00441         vis_ld64_2(ref, 16, TMP4);
00442 
00443         vis_ld64(constants_fe[0], MASK_fe);
00444 
00445         vis_ld64(constants_7f[0], MASK_7f);
00446         vis_faligndata(TMP0, TMP2, REF_0);
00447 
00448         vis_ld64(constants128[0], CONST_128);
00449         vis_faligndata(TMP2, TMP4, REF_4);
00450 
00451         if (off != 0x7) {
00452                 vis_alignaddr_g0((void *)off_plus_1);
00453                 vis_faligndata(TMP0, TMP2, REF_2);
00454                 vis_faligndata(TMP2, TMP4, REF_6);
00455         } else {
00456                 vis_src1(TMP2, REF_2);
00457                 vis_src1(TMP4, REF_6);
00458         }
00459 
00460         ref += stride;
00461         height = (height >> 1) - 1;
00462 
00463         do {    /* 34 cycles */
00464                 vis_ld64(ref[0],    TMP0);
00465                 vis_xor(REF_0, REF_2, TMP6);
00466 
00467                 vis_ld64_2(ref, 8,  TMP2);
00468                 vis_xor(REF_4, REF_6, TMP8);
00469 
00470                 vis_ld64_2(ref, 16, TMP4);
00471                 vis_and(TMP6, MASK_fe, TMP6);
00472                 ref += stride;
00473 
00474                 vis_ld64(ref[0],    TMP14);
00475                 vis_mul8x16(CONST_128, TMP6, TMP6);
00476                 vis_and(TMP8, MASK_fe, TMP8);
00477 
00478                 vis_ld64_2(ref, 8,  TMP16);
00479                 vis_mul8x16(CONST_128, TMP8, TMP8);
00480                 vis_or(REF_0, REF_2, TMP10);
00481 
00482                 vis_ld64_2(ref, 16, TMP18);
00483                 ref += stride;
00484                 vis_or(REF_4, REF_6, TMP12);
00485 
00486                 vis_alignaddr_g0((void *)off);
00487 
00488                 vis_faligndata(TMP0, TMP2, REF_0);
00489 
00490                 vis_faligndata(TMP2, TMP4, REF_4);
00491 
00492                 if (off != 0x7) {
00493                         vis_alignaddr_g0((void *)off_plus_1);
00494                         vis_faligndata(TMP0, TMP2, REF_2);
00495                         vis_faligndata(TMP2, TMP4, REF_6);
00496                 } else {
00497                         vis_src1(TMP2, REF_2);
00498                         vis_src1(TMP4, REF_6);
00499                 }
00500 
00501                 vis_and(TMP6, MASK_7f, TMP6);
00502 
00503                 vis_and(TMP8, MASK_7f, TMP8);
00504 
00505                 vis_psub16(TMP10, TMP6, TMP6);
00506                 vis_st64(TMP6, dest[0]);
00507 
00508                 vis_psub16(TMP12, TMP8, TMP8);
00509                 vis_st64_2(TMP8, dest, 8);
00510                 dest += stride;
00511 
00512                 vis_xor(REF_0, REF_2, TMP6);
00513 
00514                 vis_xor(REF_4, REF_6, TMP8);
00515 
00516                 vis_and(TMP6, MASK_fe, TMP6);
00517 
00518                 vis_mul8x16(CONST_128, TMP6, TMP6);
00519                 vis_and(TMP8, MASK_fe, TMP8);
00520 
00521                 vis_mul8x16(CONST_128, TMP8, TMP8);
00522                 vis_or(REF_0, REF_2, TMP10);
00523 
00524                 vis_or(REF_4, REF_6, TMP12);
00525 
00526                 vis_alignaddr_g0((void *)off);
00527 
00528                 vis_faligndata(TMP14, TMP16, REF_0);
00529 
00530                 vis_faligndata(TMP16, TMP18, REF_4);
00531 
00532                 if (off != 0x7) {
00533                         vis_alignaddr_g0((void *)off_plus_1);
00534                         vis_faligndata(TMP14, TMP16, REF_2);
00535                         vis_faligndata(TMP16, TMP18, REF_6);
00536                 } else {
00537                         vis_src1(TMP16, REF_2);
00538                         vis_src1(TMP18, REF_6);
00539                 }
00540 
00541                 vis_and(TMP6, MASK_7f, TMP6);
00542 
00543                 vis_and(TMP8, MASK_7f, TMP8);
00544 
00545                 vis_psub16(TMP10, TMP6, TMP6);
00546                 vis_st64(TMP6, dest[0]);
00547 
00548                 vis_psub16(TMP12, TMP8, TMP8);
00549                 vis_st64_2(TMP8, dest, 8);
00550                 dest += stride;
00551         } while (--height);
00552 
00553         vis_ld64(ref[0],    TMP0);
00554         vis_xor(REF_0, REF_2, TMP6);
00555 
00556         vis_ld64_2(ref, 8,  TMP2);
00557         vis_xor(REF_4, REF_6, TMP8);
00558 
00559         vis_ld64_2(ref, 16, TMP4);
00560         vis_and(TMP6, MASK_fe, TMP6);
00561 
00562         vis_mul8x16(CONST_128, TMP6, TMP6);
00563         vis_and(TMP8, MASK_fe, TMP8);
00564 
00565         vis_mul8x16(CONST_128, TMP8, TMP8);
00566         vis_or(REF_0, REF_2, TMP10);
00567 
00568         vis_or(REF_4, REF_6, TMP12);
00569 
00570         vis_alignaddr_g0((void *)off);
00571 
00572         vis_faligndata(TMP0, TMP2, REF_0);
00573 
00574         vis_faligndata(TMP2, TMP4, REF_4);
00575 
00576         if (off != 0x7) {
00577                 vis_alignaddr_g0((void *)off_plus_1);
00578                 vis_faligndata(TMP0, TMP2, REF_2);
00579                 vis_faligndata(TMP2, TMP4, REF_6);
00580         } else {
00581                 vis_src1(TMP2, REF_2);
00582                 vis_src1(TMP4, REF_6);
00583         }
00584 
00585         vis_and(TMP6, MASK_7f, TMP6);
00586 
00587         vis_and(TMP8, MASK_7f, TMP8);
00588 
00589         vis_psub16(TMP10, TMP6, TMP6);
00590         vis_st64(TMP6, dest[0]);
00591 
00592         vis_psub16(TMP12, TMP8, TMP8);
00593         vis_st64_2(TMP8, dest, 8);
00594         dest += stride;
00595 
00596         vis_xor(REF_0, REF_2, TMP6);
00597 
00598         vis_xor(REF_4, REF_6, TMP8);
00599 
00600         vis_and(TMP6, MASK_fe, TMP6);
00601 
00602         vis_mul8x16(CONST_128, TMP6, TMP6);
00603         vis_and(TMP8, MASK_fe, TMP8);
00604 
00605         vis_mul8x16(CONST_128, TMP8, TMP8);
00606         vis_or(REF_0, REF_2, TMP10);
00607 
00608         vis_or(REF_4, REF_6, TMP12);
00609 
00610         vis_and(TMP6, MASK_7f, TMP6);
00611 
00612         vis_and(TMP8, MASK_7f, TMP8);
00613 
00614         vis_psub16(TMP10, TMP6, TMP6);
00615         vis_st64(TMP6, dest[0]);
00616 
00617         vis_psub16(TMP12, TMP8, TMP8);
00618         vis_st64_2(TMP8, dest, 8);
00619 }
00620 
00621 static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * _ref,
00622                             const int stride, int height)
00623 {
00624         uint8_t *ref = (uint8_t *) _ref;
00625         unsigned long off = (unsigned long) ref & 0x7;
00626         unsigned long off_plus_1 = off + 1;
00627 
00628         ref = vis_alignaddr(ref);
00629 
00630         vis_ld64(ref[0], TMP0);
00631 
00632         vis_ld64(ref[8], TMP2);
00633 
00634         vis_ld64(constants_fe[0], MASK_fe);
00635 
00636         vis_ld64(constants_7f[0], MASK_7f);
00637 
00638         vis_ld64(constants128[0], CONST_128);
00639         vis_faligndata(TMP0, TMP2, REF_0);
00640 
00641         if (off != 0x7) {
00642                 vis_alignaddr_g0((void *)off_plus_1);
00643                 vis_faligndata(TMP0, TMP2, REF_2);
00644         } else {
00645                 vis_src1(TMP2, REF_2);
00646         }
00647 
00648         ref += stride;
00649         height = (height >> 1) - 1;
00650 
00651         do {    /* 20 cycles */
00652                 vis_ld64(ref[0], TMP0);
00653                 vis_xor(REF_0, REF_2, TMP4);
00654 
00655                 vis_ld64_2(ref, 8, TMP2);
00656                 vis_and(TMP4, MASK_fe, TMP4);
00657                 ref += stride;
00658 
00659                 vis_ld64(ref[0], TMP8);
00660                 vis_or(REF_0, REF_2, TMP6);
00661                 vis_mul8x16(CONST_128, TMP4, TMP4);
00662 
00663                 vis_alignaddr_g0((void *)off);
00664 
00665                 vis_ld64_2(ref, 8, TMP10);
00666                 ref += stride;
00667                 vis_faligndata(TMP0, TMP2, REF_0);
00668 
00669                 if (off != 0x7) {
00670                         vis_alignaddr_g0((void *)off_plus_1);
00671                         vis_faligndata(TMP0, TMP2, REF_2);
00672                 } else {
00673                         vis_src1(TMP2, REF_2);
00674                 }
00675 
00676                 vis_and(TMP4, MASK_7f, TMP4);
00677 
00678                 vis_psub16(TMP6, TMP4, DST_0);
00679                 vis_st64(DST_0, dest[0]);
00680                 dest += stride;
00681 
00682                 vis_xor(REF_0, REF_2, TMP12);
00683 
00684                 vis_and(TMP12, MASK_fe, TMP12);
00685 
00686                 vis_or(REF_0, REF_2, TMP14);
00687                 vis_mul8x16(CONST_128, TMP12, TMP12);
00688 
00689                 vis_alignaddr_g0((void *)off);
00690                 vis_faligndata(TMP8, TMP10, REF_0);
00691                 if (off != 0x7) {
00692                         vis_alignaddr_g0((void *)off_plus_1);
00693                         vis_faligndata(TMP8, TMP10, REF_2);
00694                 } else {
00695                         vis_src1(TMP10, REF_2);
00696                 }
00697 
00698                 vis_and(TMP12, MASK_7f, TMP12);
00699 
00700                 vis_psub16(TMP14, TMP12, DST_0);
00701                 vis_st64(DST_0, dest[0]);
00702                 dest += stride;
00703         } while (--height);
00704 
00705         vis_ld64(ref[0], TMP0);
00706         vis_xor(REF_0, REF_2, TMP4);
00707 
00708         vis_ld64_2(ref, 8, TMP2);
00709         vis_and(TMP4, MASK_fe, TMP4);
00710 
00711         vis_or(REF_0, REF_2, TMP6);
00712         vis_mul8x16(CONST_128, TMP4, TMP4);
00713 
00714         vis_alignaddr_g0((void *)off);
00715 
00716         vis_faligndata(TMP0, TMP2, REF_0);
00717 
00718         if (off != 0x7) {
00719                 vis_alignaddr_g0((void *)off_plus_1);
00720                 vis_faligndata(TMP0, TMP2, REF_2);
00721         } else {
00722                 vis_src1(TMP2, REF_2);
00723         }
00724 
00725         vis_and(TMP4, MASK_7f, TMP4);
00726 
00727         vis_psub16(TMP6, TMP4, DST_0);
00728         vis_st64(DST_0, dest[0]);
00729         dest += stride;
00730 
00731         vis_xor(REF_0, REF_2, TMP12);
00732 
00733         vis_and(TMP12, MASK_fe, TMP12);
00734 
00735         vis_or(REF_0, REF_2, TMP14);
00736         vis_mul8x16(CONST_128, TMP12, TMP12);
00737 
00738         vis_and(TMP12, MASK_7f, TMP12);
00739 
00740         vis_psub16(TMP14, TMP12, DST_0);
00741         vis_st64(DST_0, dest[0]);
00742         dest += stride;
00743 }
00744 
00745 static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * _ref,
00746                              const int stride, int height)
00747 {
00748         uint8_t *ref = (uint8_t *) _ref;
00749         unsigned long off = (unsigned long) ref & 0x7;
00750         unsigned long off_plus_1 = off + 1;
00751 
00752         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
00753 
00754         vis_ld64(constants3[0], CONST_3);
00755         vis_fzero(ZERO);
00756         vis_ld64(constants256_512[0], CONST_256);
00757 
00758         ref = vis_alignaddr(ref);
00759         do {    /* 26 cycles */
00760                 vis_ld64(ref[0], TMP0);
00761 
00762                 vis_ld64(ref[8], TMP2);
00763 
00764                 vis_alignaddr_g0((void *)off);
00765 
00766                 vis_ld64(ref[16], TMP4);
00767 
00768                 vis_ld64(dest[0], DST_0);
00769                 vis_faligndata(TMP0, TMP2, REF_0);
00770 
00771                 vis_ld64(dest[8], DST_2);
00772                 vis_faligndata(TMP2, TMP4, REF_4);
00773 
00774                 if (off != 0x7) {
00775                         vis_alignaddr_g0((void *)off_plus_1);
00776                         vis_faligndata(TMP0, TMP2, REF_2);
00777                         vis_faligndata(TMP2, TMP4, REF_6);
00778                 } else {
00779                         vis_src1(TMP2, REF_2);
00780                         vis_src1(TMP4, REF_6);
00781                 }
00782 
00783                 vis_mul8x16au(REF_0,   CONST_256, TMP0);
00784 
00785                 vis_pmerge(ZERO,     REF_2,     TMP4);
00786                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
00787 
00788                 vis_pmerge(ZERO, REF_2_1, TMP6);
00789 
00790                 vis_padd16(TMP0, TMP4, TMP0);
00791 
00792                 vis_mul8x16al(DST_0,   CONST_512, TMP4);
00793                 vis_padd16(TMP2, TMP6, TMP2);
00794 
00795                 vis_mul8x16al(DST_1,   CONST_512, TMP6);
00796 
00797                 vis_mul8x16au(REF_6,   CONST_256, TMP12);
00798 
00799                 vis_padd16(TMP0, TMP4, TMP0);
00800                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
00801 
00802                 vis_padd16(TMP2, TMP6, TMP2);
00803                 vis_mul8x16au(REF_4,   CONST_256, TMP16);
00804 
00805                 vis_padd16(TMP0, CONST_3, TMP8);
00806                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);
00807 
00808                 vis_padd16(TMP2, CONST_3, TMP10);
00809                 vis_pack16(TMP8, DST_0);
00810 
00811                 vis_pack16(TMP10, DST_1);
00812                 vis_padd16(TMP16, TMP12, TMP0);
00813 
00814                 vis_st64(DST_0, dest[0]);
00815                 vis_mul8x16al(DST_2,   CONST_512, TMP4);
00816                 vis_padd16(TMP18, TMP14, TMP2);
00817 
00818                 vis_mul8x16al(DST_3,   CONST_512, TMP6);
00819                 vis_padd16(TMP0, CONST_3, TMP0);
00820 
00821                 vis_padd16(TMP2, CONST_3, TMP2);
00822 
00823                 vis_padd16(TMP0, TMP4, TMP0);
00824 
00825                 vis_padd16(TMP2, TMP6, TMP2);
00826                 vis_pack16(TMP0, DST_2);
00827 
00828                 vis_pack16(TMP2, DST_3);
00829                 vis_st64(DST_2, dest[8]);
00830 
00831                 ref += stride;
00832                 dest += stride;
00833         } while (--height);
00834 }
00835 
00836 static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * _ref,
00837                             const int stride, int height)
00838 {
00839         uint8_t *ref = (uint8_t *) _ref;
00840         unsigned long off = (unsigned long) ref & 0x7;
00841         unsigned long off_plus_1 = off + 1;
00842         int stride_times_2 = stride << 1;
00843 
00844         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
00845 
00846         vis_ld64(constants3[0], CONST_3);
00847         vis_fzero(ZERO);
00848         vis_ld64(constants256_512[0], CONST_256);
00849 
00850         ref = vis_alignaddr(ref);
00851         height >>= 2;
00852         do {    /* 47 cycles */
00853                 vis_ld64(ref[0],   TMP0);
00854 
00855                 vis_ld64_2(ref, 8, TMP2);
00856                 ref += stride;
00857 
00858                 vis_alignaddr_g0((void *)off);
00859 
00860                 vis_ld64(ref[0],   TMP4);
00861                 vis_faligndata(TMP0, TMP2, REF_0);
00862 
00863                 vis_ld64_2(ref, 8, TMP6);
00864                 ref += stride;
00865 
00866                 vis_ld64(ref[0],   TMP8);
00867 
00868                 vis_ld64_2(ref, 8, TMP10);
00869                 ref += stride;
00870                 vis_faligndata(TMP4, TMP6, REF_4);
00871 
00872                 vis_ld64(ref[0],   TMP12);
00873 
00874                 vis_ld64_2(ref, 8, TMP14);
00875                 ref += stride;
00876                 vis_faligndata(TMP8, TMP10, REF_S0);
00877 
00878                 vis_faligndata(TMP12, TMP14, REF_S4);
00879 
00880                 if (off != 0x7) {
00881                         vis_alignaddr_g0((void *)off_plus_1);
00882 
00883                         vis_ld64(dest[0], DST_0);
00884                         vis_faligndata(TMP0, TMP2, REF_2);
00885 
00886                         vis_ld64_2(dest, stride, DST_2);
00887                         vis_faligndata(TMP4, TMP6, REF_6);
00888 
00889                         vis_faligndata(TMP8, TMP10, REF_S2);
00890 
00891                         vis_faligndata(TMP12, TMP14, REF_S6);
00892                 } else {
00893                         vis_ld64(dest[0], DST_0);
00894                         vis_src1(TMP2, REF_2);
00895 
00896                         vis_ld64_2(dest, stride, DST_2);
00897                         vis_src1(TMP6, REF_6);
00898 
00899                         vis_src1(TMP10, REF_S2);
00900 
00901                         vis_src1(TMP14, REF_S6);
00902                 }
00903 
00904                 vis_pmerge(ZERO,     REF_0,     TMP0);
00905                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
00906 
00907                 vis_pmerge(ZERO,     REF_2,     TMP4);
00908                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);
00909 
00910                 vis_padd16(TMP0, CONST_3, TMP0);
00911                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
00912 
00913                 vis_padd16(TMP2, CONST_3, TMP2);
00914                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
00915 
00916                 vis_padd16(TMP0, TMP4, TMP0);
00917                 vis_mul8x16au(REF_4, CONST_256, TMP8);
00918 
00919                 vis_padd16(TMP2, TMP6, TMP2);
00920                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);
00921 
00922                 vis_padd16(TMP0, TMP16, TMP0);
00923                 vis_mul8x16au(REF_6, CONST_256, TMP12);
00924 
00925                 vis_padd16(TMP2, TMP18, TMP2);
00926                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);
00927 
00928                 vis_padd16(TMP8, CONST_3, TMP8);
00929                 vis_mul8x16al(DST_2, CONST_512, TMP16);
00930 
00931                 vis_padd16(TMP8, TMP12, TMP8);
00932                 vis_mul8x16al(DST_3, CONST_512, TMP18);
00933 
00934                 vis_padd16(TMP10, TMP14, TMP10);
00935                 vis_pack16(TMP0, DST_0);
00936 
00937                 vis_pack16(TMP2, DST_1);
00938                 vis_st64(DST_0, dest[0]);
00939                 dest += stride;
00940                 vis_padd16(TMP10, CONST_3, TMP10);
00941 
00942                 vis_ld64_2(dest, stride, DST_0);
00943                 vis_padd16(TMP8, TMP16, TMP8);
00944 
00945                 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
00946                 vis_padd16(TMP10, TMP18, TMP10);
00947                 vis_pack16(TMP8, DST_2);
00948 
00949                 vis_pack16(TMP10, DST_3);
00950                 vis_st64(DST_2, dest[0]);
00951                 dest += stride;
00952 
00953                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
00954                 vis_pmerge(ZERO,     REF_S0,     TMP0);
00955 
00956                 vis_pmerge(ZERO,     REF_S2,     TMP24);
00957                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
00958 
00959                 vis_padd16(TMP0, CONST_3, TMP0);
00960                 vis_mul8x16au(REF_S4, CONST_256, TMP8);
00961 
00962                 vis_padd16(TMP2, CONST_3, TMP2);
00963                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
00964 
00965                 vis_padd16(TMP0, TMP24, TMP0);
00966                 vis_mul8x16au(REF_S6, CONST_256, TMP12);
00967 
00968                 vis_padd16(TMP2, TMP6, TMP2);
00969                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
00970 
00971                 vis_padd16(TMP8, CONST_3, TMP8);
00972                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
00973 
00974                 vis_padd16(TMP10, CONST_3, TMP10);
00975                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
00976 
00977                 vis_padd16(TMP8, TMP12, TMP8);
00978                 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
00979 
00980                 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
00981                 vis_padd16(TMP0, TMP16, TMP0);
00982 
00983                 vis_padd16(TMP2, TMP18, TMP2);
00984                 vis_pack16(TMP0, DST_0);
00985 
00986                 vis_padd16(TMP10, TMP14, TMP10);
00987                 vis_pack16(TMP2, DST_1);
00988                 vis_st64(DST_0, dest[0]);
00989                 dest += stride;
00990 
00991                 vis_padd16(TMP8, TMP20, TMP8);
00992 
00993                 vis_padd16(TMP10, TMP22, TMP10);
00994                 vis_pack16(TMP8, DST_2);
00995 
00996                 vis_pack16(TMP10, DST_3);
00997                 vis_st64(DST_2, dest[0]);
00998                 dest += stride;
00999         } while (--height);
01000 }
01001 
01002 static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * _ref,
01003                              const int stride, int height)
01004 {
01005         uint8_t *ref = (uint8_t *) _ref;
01006         int offset;
01007 
01008         ref = vis_alignaddr(ref);
01009         offset = (ref != _ref) ? 16 : 0;
01010 
01011         vis_ld64(ref[0], TMP0);
01012 
01013         vis_ld64_2(ref, 8, TMP2);
01014 
01015         vis_ld64_2(ref, offset, TMP4);
01016         ref += stride;
01017 
01018         vis_ld64(ref[0], TMP6);
01019         vis_faligndata(TMP0, TMP2, REF_0);
01020 
01021         vis_ld64_2(ref, 8, TMP8);
01022         vis_faligndata(TMP2, TMP4, REF_4);
01023 
01024         vis_ld64_2(ref, offset, TMP10);
01025         ref += stride;
01026 
01027         vis_ld64(constants_fe[0], MASK_fe);
01028         vis_faligndata(TMP6, TMP8, REF_2);
01029 
01030         vis_ld64(constants_7f[0], MASK_7f);
01031         vis_faligndata(TMP8, TMP10, REF_6);
01032 
01033         vis_ld64(constants128[0], CONST_128);
01034         height = (height >> 1) - 1;
01035         do {    /* 24 cycles */
01036                 vis_ld64(ref[0], TMP0);
01037                 vis_xor(REF_0, REF_2, TMP12);
01038 
01039                 vis_ld64_2(ref, 8, TMP2);
01040                 vis_xor(REF_4, REF_6, TMP16);
01041 
01042                 vis_ld64_2(ref, offset, TMP4);
01043                 ref += stride;
01044                 vis_or(REF_0, REF_2, TMP14);
01045 
01046                 vis_ld64(ref[0], TMP6);
01047                 vis_or(REF_4, REF_6, TMP18);
01048 
01049                 vis_ld64_2(ref, 8, TMP8);
01050                 vis_faligndata(TMP0, TMP2, REF_0);
01051 
01052                 vis_ld64_2(ref, offset, TMP10);
01053                 ref += stride;
01054                 vis_faligndata(TMP2, TMP4, REF_4);
01055 
01056                 vis_and(TMP12, MASK_fe, TMP12);
01057 
01058                 vis_and(TMP16, MASK_fe, TMP16);
01059                 vis_mul8x16(CONST_128, TMP12, TMP12);
01060 
01061                 vis_mul8x16(CONST_128, TMP16, TMP16);
01062                 vis_xor(REF_0, REF_2, TMP0);
01063 
01064                 vis_xor(REF_4, REF_6, TMP2);
01065 
01066                 vis_or(REF_0, REF_2, TMP20);
01067 
01068                 vis_and(TMP12, MASK_7f, TMP12);
01069 
01070                 vis_and(TMP16, MASK_7f, TMP16);
01071 
01072                 vis_psub16(TMP14, TMP12, TMP12);
01073                 vis_st64(TMP12, dest[0]);
01074 
01075                 vis_psub16(TMP18, TMP16, TMP16);
01076                 vis_st64_2(TMP16, dest, 8);
01077                 dest += stride;
01078 
01079                 vis_or(REF_4, REF_6, TMP18);
01080 
01081                 vis_and(TMP0, MASK_fe, TMP0);
01082 
01083                 vis_and(TMP2, MASK_fe, TMP2);
01084                 vis_mul8x16(CONST_128, TMP0, TMP0);
01085 
01086                 vis_faligndata(TMP6, TMP8, REF_2);
01087                 vis_mul8x16(CONST_128, TMP2, TMP2);
01088 
01089                 vis_faligndata(TMP8, TMP10, REF_6);
01090 
01091                 vis_and(TMP0, MASK_7f, TMP0);
01092 
01093                 vis_and(TMP2, MASK_7f, TMP2);
01094 
01095                 vis_psub16(TMP20, TMP0, TMP0);
01096                 vis_st64(TMP0, dest[0]);
01097 
01098                 vis_psub16(TMP18, TMP2, TMP2);
01099                 vis_st64_2(TMP2, dest, 8);
01100                 dest += stride;
01101         } while (--height);
01102 
01103         vis_ld64(ref[0], TMP0);
01104         vis_xor(REF_0, REF_2, TMP12);
01105 
01106         vis_ld64_2(ref, 8, TMP2);
01107         vis_xor(REF_4, REF_6, TMP16);
01108 
01109         vis_ld64_2(ref, offset, TMP4);
01110         vis_or(REF_0, REF_2, TMP14);
01111 
01112         vis_or(REF_4, REF_6, TMP18);
01113 
01114         vis_faligndata(TMP0, TMP2, REF_0);
01115 
01116         vis_faligndata(TMP2, TMP4, REF_4);
01117 
01118         vis_and(TMP12, MASK_fe, TMP12);
01119 
01120         vis_and(TMP16, MASK_fe, TMP16);
01121         vis_mul8x16(CONST_128, TMP12, TMP12);
01122 
01123         vis_mul8x16(CONST_128, TMP16, TMP16);
01124         vis_xor(REF_0, REF_2, TMP0);
01125 
01126         vis_xor(REF_4, REF_6, TMP2);
01127 
01128         vis_or(REF_0, REF_2, TMP20);
01129 
01130         vis_and(TMP12, MASK_7f, TMP12);
01131 
01132         vis_and(TMP16, MASK_7f, TMP16);
01133 
01134         vis_psub16(TMP14, TMP12, TMP12);
01135         vis_st64(TMP12, dest[0]);
01136 
01137         vis_psub16(TMP18, TMP16, TMP16);
01138         vis_st64_2(TMP16, dest, 8);
01139         dest += stride;
01140 
01141         vis_or(REF_4, REF_6, TMP18);
01142 
01143         vis_and(TMP0, MASK_fe, TMP0);
01144 
01145         vis_and(TMP2, MASK_fe, TMP2);
01146         vis_mul8x16(CONST_128, TMP0, TMP0);
01147 
01148         vis_mul8x16(CONST_128, TMP2, TMP2);
01149 
01150         vis_and(TMP0, MASK_7f, TMP0);
01151 
01152         vis_and(TMP2, MASK_7f, TMP2);
01153 
01154         vis_psub16(TMP20, TMP0, TMP0);
01155         vis_st64(TMP0, dest[0]);
01156 
01157         vis_psub16(TMP18, TMP2, TMP2);
01158         vis_st64_2(TMP2, dest, 8);
01159 }
01160 
01161 static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * _ref,
01162                             const int stride, int height)
01163 {
01164         uint8_t *ref = (uint8_t *) _ref;
01165         int offset;
01166 
01167         ref = vis_alignaddr(ref);
01168         offset = (ref != _ref) ? 8 : 0;
01169 
01170         vis_ld64(ref[0], TMP0);
01171 
01172         vis_ld64_2(ref, offset, TMP2);
01173         ref += stride;
01174 
01175         vis_ld64(ref[0], TMP4);
01176 
01177         vis_ld64_2(ref, offset, TMP6);
01178         ref += stride;
01179 
01180         vis_ld64(constants_fe[0], MASK_fe);
01181         vis_faligndata(TMP0, TMP2, REF_0);
01182 
01183         vis_ld64(constants_7f[0], MASK_7f);
01184         vis_faligndata(TMP4, TMP6, REF_2);
01185 
01186         vis_ld64(constants128[0], CONST_128);
01187         height = (height >> 1) - 1;
01188         do {    /* 12 cycles */
01189                 vis_ld64(ref[0], TMP0);
01190                 vis_xor(REF_0, REF_2, TMP4);
01191 
01192                 vis_ld64_2(ref, offset, TMP2);
01193                 ref += stride;
01194                 vis_and(TMP4, MASK_fe, TMP4);
01195 
01196                 vis_or(REF_0, REF_2, TMP6);
01197                 vis_mul8x16(CONST_128, TMP4, TMP4);
01198 
01199                 vis_faligndata(TMP0, TMP2, REF_0);
01200                 vis_ld64(ref[0], TMP0);
01201 
01202                 vis_ld64_2(ref, offset, TMP2);
01203                 ref += stride;
01204                 vis_xor(REF_0, REF_2, TMP12);
01205 
01206                 vis_and(TMP4, MASK_7f, TMP4);
01207 
01208                 vis_and(TMP12, MASK_fe, TMP12);
01209 
01210                 vis_mul8x16(CONST_128, TMP12, TMP12);
01211                 vis_or(REF_0, REF_2, TMP14);
01212 
01213                 vis_psub16(TMP6, TMP4, DST_0);
01214                 vis_st64(DST_0, dest[0]);
01215                 dest += stride;
01216 
01217                 vis_faligndata(TMP0, TMP2, REF_2);
01218 
01219                 vis_and(TMP12, MASK_7f, TMP12);
01220 
01221                 vis_psub16(TMP14, TMP12, DST_0);
01222                 vis_st64(DST_0, dest[0]);
01223                 dest += stride;
01224         } while (--height);
01225 
01226         vis_ld64(ref[0], TMP0);
01227         vis_xor(REF_0, REF_2, TMP4);
01228 
01229         vis_ld64_2(ref, offset, TMP2);
01230         vis_and(TMP4, MASK_fe, TMP4);
01231 
01232         vis_or(REF_0, REF_2, TMP6);
01233         vis_mul8x16(CONST_128, TMP4, TMP4);
01234 
01235         vis_faligndata(TMP0, TMP2, REF_0);
01236 
01237         vis_xor(REF_0, REF_2, TMP12);
01238 
01239         vis_and(TMP4, MASK_7f, TMP4);
01240 
01241         vis_and(TMP12, MASK_fe, TMP12);
01242 
01243         vis_mul8x16(CONST_128, TMP12, TMP12);
01244         vis_or(REF_0, REF_2, TMP14);
01245 
01246         vis_psub16(TMP6, TMP4, DST_0);
01247         vis_st64(DST_0, dest[0]);
01248         dest += stride;
01249 
01250         vis_and(TMP12, MASK_7f, TMP12);
01251 
01252         vis_psub16(TMP14, TMP12, DST_0);
01253         vis_st64(DST_0, dest[0]);
01254 }
01255 
01256 static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * _ref,
01257                              const int stride, int height)
01258 {
01259         uint8_t *ref = (uint8_t *) _ref;
01260         int stride_8 = stride + 8;
01261         int stride_16;
01262         int offset;
01263 
01264         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01265 
01266         ref = vis_alignaddr(ref);
01267         offset = (ref != _ref) ? 16 : 0;
01268 
01269         vis_ld64(ref[ 0], TMP0);
01270         vis_fzero(ZERO);
01271 
01272         vis_ld64(ref[ 8], TMP2);
01273 
01274         vis_ld64_2(ref, offset, TMP4);
01275         stride_16 = stride + offset;
01276 
01277         vis_ld64(constants3[0], CONST_3);
01278         vis_faligndata(TMP0, TMP2, REF_2);
01279 
01280         vis_ld64(constants256_512[0], CONST_256);
01281         vis_faligndata(TMP2, TMP4, REF_6);
01282         height >>= 1;
01283 
01284         do {    /* 31 cycles */
01285                 vis_ld64_2(ref, stride, TMP0);
01286                 vis_pmerge(ZERO,       REF_2,     TMP12);
01287                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);
01288 
01289                 vis_ld64_2(ref, stride_8, TMP2);
01290                 vis_pmerge(ZERO,       REF_6,     TMP16);
01291                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);
01292 
01293                 vis_ld64_2(ref, stride_16, TMP4);
01294                 ref += stride;
01295 
01296                 vis_ld64(dest[0], DST_0);
01297                 vis_faligndata(TMP0, TMP2, REF_0);
01298 
01299                 vis_ld64_2(dest, 8, DST_2);
01300                 vis_faligndata(TMP2, TMP4, REF_4);
01301 
01302                 vis_ld64_2(ref, stride, TMP6);
01303                 vis_pmerge(ZERO,     REF_0,     TMP0);
01304                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);
01305 
01306                 vis_ld64_2(ref, stride_8, TMP8);
01307                 vis_pmerge(ZERO,     REF_4,     TMP4);
01308 
01309                 vis_ld64_2(ref, stride_16, TMP10);
01310                 ref += stride;
01311 
01312                 vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
01313                 vis_faligndata(TMP6, TMP8, REF_2);
01314                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
01315 
01316                 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
01317                 vis_faligndata(TMP8, TMP10, REF_6);
01318                 vis_mul8x16al(DST_0,   CONST_512, TMP20);
01319 
01320                 vis_padd16(TMP0, CONST_3, TMP0);
01321                 vis_mul8x16al(DST_1,   CONST_512, TMP22);
01322 
01323                 vis_padd16(TMP2, CONST_3, TMP2);
01324                 vis_mul8x16al(DST_2,   CONST_512, TMP24);
01325 
01326                 vis_padd16(TMP4, CONST_3, TMP4);
01327                 vis_mul8x16al(DST_3,   CONST_512, TMP26);
01328 
01329                 vis_padd16(TMP6, CONST_3, TMP6);
01330 
01331                 vis_padd16(TMP12, TMP20, TMP12);
01332                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);
01333 
01334                 vis_padd16(TMP14, TMP22, TMP14);
01335                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
01336 
01337                 vis_padd16(TMP16, TMP24, TMP16);
01338                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);
01339 
01340                 vis_padd16(TMP18, TMP26, TMP18);
01341                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
01342 
01343                 vis_padd16(TMP12, TMP0, TMP12);
01344                 vis_mul8x16au(REF_2,   CONST_256, TMP28);
01345 
01346                 vis_padd16(TMP14, TMP2, TMP14);
01347                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);
01348 
01349                 vis_padd16(TMP16, TMP4, TMP16);
01350                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);
01351 
01352                 vis_padd16(TMP18, TMP6, TMP18);
01353                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
01354 
01355                 vis_pack16(TMP12, DST_0);
01356                 vis_padd16(TMP28, TMP0, TMP12);
01357 
01358                 vis_pack16(TMP14, DST_1);
01359                 vis_st64(DST_0, dest[0]);
01360                 vis_padd16(TMP30, TMP2, TMP14);
01361 
01362                 vis_pack16(TMP16, DST_2);
01363                 vis_padd16(REF_S4, TMP4, TMP16);
01364 
01365                 vis_pack16(TMP18, DST_3);
01366                 vis_st64_2(DST_2, dest, 8);
01367                 dest += stride;
01368                 vis_padd16(REF_S6, TMP6, TMP18);
01369 
01370                 vis_padd16(TMP12, TMP20, TMP12);
01371 
01372                 vis_padd16(TMP14, TMP22, TMP14);
01373                 vis_pack16(TMP12, DST_0);
01374 
01375                 vis_padd16(TMP16, TMP24, TMP16);
01376                 vis_pack16(TMP14, DST_1);
01377                 vis_st64(DST_0, dest[0]);
01378 
01379                 vis_padd16(TMP18, TMP26, TMP18);
01380                 vis_pack16(TMP16, DST_2);
01381 
01382                 vis_pack16(TMP18, DST_3);
01383                 vis_st64_2(DST_2, dest, 8);
01384                 dest += stride;
01385         } while (--height);
01386 }
01387 
01388 static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * _ref,
01389                             const int stride, int height)
01390 {
01391         uint8_t *ref = (uint8_t *) _ref;
01392         int stride_8;
01393         int offset;
01394 
01395         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01396 
01397         ref = vis_alignaddr(ref);
01398         offset = (ref != _ref) ? 8 : 0;
01399 
01400         vis_ld64(ref[ 0], TMP0);
01401         vis_fzero(ZERO);
01402 
01403         vis_ld64_2(ref, offset, TMP2);
01404         stride_8 = stride + offset;
01405 
01406         vis_ld64(constants3[0], CONST_3);
01407         vis_faligndata(TMP0, TMP2, REF_2);
01408 
01409         vis_ld64(constants256_512[0], CONST_256);
01410 
01411         height >>= 1;
01412         do {    /* 20 cycles */
01413                 vis_ld64_2(ref, stride, TMP0);
01414                 vis_pmerge(ZERO,       REF_2,     TMP8);
01415                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);
01416 
01417                 vis_ld64_2(ref, stride_8, TMP2);
01418                 ref += stride;
01419 
01420                 vis_ld64(dest[0], DST_0);
01421 
01422                 vis_ld64_2(dest, stride, DST_2);
01423                 vis_faligndata(TMP0, TMP2, REF_0);
01424 
01425                 vis_ld64_2(ref, stride, TMP4);
01426                 vis_mul8x16al(DST_0,   CONST_512, TMP16);
01427                 vis_pmerge(ZERO,       REF_0,     TMP12);
01428 
01429                 vis_ld64_2(ref, stride_8, TMP6);
01430                 ref += stride;
01431                 vis_mul8x16al(DST_1,   CONST_512, TMP18);
01432                 vis_pmerge(ZERO,       REF_0_1,   TMP14);
01433 
01434                 vis_padd16(TMP12, CONST_3, TMP12);
01435                 vis_mul8x16al(DST_2,   CONST_512, TMP24);
01436 
01437                 vis_padd16(TMP14, CONST_3, TMP14);
01438                 vis_mul8x16al(DST_3,   CONST_512, TMP26);
01439 
01440                 vis_faligndata(TMP4, TMP6, REF_2);
01441 
01442                 vis_padd16(TMP8, TMP12, TMP8);
01443 
01444                 vis_padd16(TMP10, TMP14, TMP10);
01445                 vis_mul8x16au(REF_2,   CONST_256, TMP20);
01446 
01447                 vis_padd16(TMP8, TMP16, TMP0);
01448                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);
01449 
01450                 vis_padd16(TMP10, TMP18, TMP2);
01451                 vis_pack16(TMP0, DST_0);
01452 
01453                 vis_pack16(TMP2, DST_1);
01454                 vis_st64(DST_0, dest[0]);
01455                 dest += stride;
01456                 vis_padd16(TMP12, TMP20, TMP12);
01457 
01458                 vis_padd16(TMP14, TMP22, TMP14);
01459 
01460                 vis_padd16(TMP12, TMP24, TMP0);
01461 
01462                 vis_padd16(TMP14, TMP26, TMP2);
01463                 vis_pack16(TMP0, DST_2);
01464 
01465                 vis_pack16(TMP2, DST_3);
01466                 vis_st64(DST_2, dest[0]);
01467                 dest += stride;
01468         } while (--height);
01469 }
01470 
01471 static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
01472                               const int stride, int height)
01473 {
01474         uint8_t *ref = (uint8_t *) _ref;
01475         unsigned long off = (unsigned long) ref & 0x7;
01476         unsigned long off_plus_1 = off + 1;
01477         int stride_8 = stride + 8;
01478         int stride_16 = stride + 16;
01479 
01480         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01481 
01482         ref = vis_alignaddr(ref);
01483 
01484         vis_ld64(ref[ 0], TMP0);
01485         vis_fzero(ZERO);
01486 
01487         vis_ld64(ref[ 8], TMP2);
01488 
01489         vis_ld64(ref[16], TMP4);
01490 
01491         vis_ld64(constants2[0], CONST_2);
01492         vis_faligndata(TMP0, TMP2, REF_S0);
01493 
01494         vis_ld64(constants256_512[0], CONST_256);
01495         vis_faligndata(TMP2, TMP4, REF_S4);
01496 
01497         if (off != 0x7) {
01498                 vis_alignaddr_g0((void *)off_plus_1);
01499                 vis_faligndata(TMP0, TMP2, REF_S2);
01500                 vis_faligndata(TMP2, TMP4, REF_S6);
01501         } else {
01502                 vis_src1(TMP2, REF_S2);
01503                 vis_src1(TMP4, REF_S6);
01504         }
01505 
01506         height >>= 1;
01507         do {
01508                 vis_ld64_2(ref, stride, TMP0);
01509                 vis_mul8x16au(REF_S0, CONST_256, TMP12);
01510                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);
01511 
01512                 vis_alignaddr_g0((void *)off);
01513 
01514                 vis_ld64_2(ref, stride_8, TMP2);
01515                 vis_mul8x16au(REF_S2, CONST_256, TMP16);
01516                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);
01517 
01518                 vis_ld64_2(ref, stride_16, TMP4);
01519                 ref += stride;
01520                 vis_mul8x16au(REF_S4, CONST_256, TMP20);
01521                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);
01522 
01523                 vis_ld64_2(ref, stride, TMP6);
01524                 vis_mul8x16au(REF_S6, CONST_256, TMP24);
01525                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);
01526 
01527                 vis_ld64_2(ref, stride_8, TMP8);
01528                 vis_faligndata(TMP0, TMP2, REF_0);
01529 
01530                 vis_ld64_2(ref, stride_16, TMP10);
01531                 ref += stride;
01532                 vis_faligndata(TMP2, TMP4, REF_4);
01533 
01534                 vis_faligndata(TMP6, TMP8, REF_S0);
01535 
01536                 vis_faligndata(TMP8, TMP10, REF_S4);
01537 
01538                 if (off != 0x7) {
01539                         vis_alignaddr_g0((void *)off_plus_1);
01540                         vis_faligndata(TMP0, TMP2, REF_2);
01541                         vis_faligndata(TMP2, TMP4, REF_6);
01542                         vis_faligndata(TMP6, TMP8, REF_S2);
01543                         vis_faligndata(TMP8, TMP10, REF_S6);
01544                 } else {
01545                         vis_src1(TMP2, REF_2);
01546                         vis_src1(TMP4, REF_6);
01547                         vis_src1(TMP8, REF_S2);
01548                         vis_src1(TMP10, REF_S6);
01549                 }
01550 
01551                 vis_mul8x16au(REF_0, CONST_256, TMP0);
01552                 vis_pmerge(ZERO,      REF_0_1,  TMP2);
01553 
01554                 vis_mul8x16au(REF_2, CONST_256, TMP4);
01555                 vis_pmerge(ZERO,      REF_2_1,  TMP6);
01556 
01557                 vis_padd16(TMP0, CONST_2, TMP8);
01558                 vis_mul8x16au(REF_4, CONST_256, TMP0);
01559 
01560                 vis_padd16(TMP2, CONST_2, TMP10);
01561                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);
01562 
01563                 vis_padd16(TMP8, TMP4, TMP8);
01564                 vis_mul8x16au(REF_6, CONST_256, TMP4);
01565 
01566                 vis_padd16(TMP10, TMP6, TMP10);
01567                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);
01568 
01569                 vis_padd16(TMP12, TMP8, TMP12);
01570 
01571                 vis_padd16(TMP14, TMP10, TMP14);
01572 
01573                 vis_padd16(TMP12, TMP16, TMP12);
01574 
01575                 vis_padd16(TMP14, TMP18, TMP14);
01576                 vis_pack16(TMP12, DST_0);
01577 
01578                 vis_pack16(TMP14, DST_1);
01579                 vis_st64(DST_0, dest[0]);
01580                 vis_padd16(TMP0, CONST_2, TMP12);
01581 
01582                 vis_mul8x16au(REF_S0, CONST_256, TMP0);
01583                 vis_padd16(TMP2, CONST_2, TMP14);
01584 
01585                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
01586                 vis_padd16(TMP12, TMP4, TMP12);
01587 
01588                 vis_mul8x16au(REF_S2, CONST_256, TMP4);
01589                 vis_padd16(TMP14, TMP6, TMP14);
01590 
01591                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
01592                 vis_padd16(TMP20, TMP12, TMP20);
01593 
01594                 vis_padd16(TMP22, TMP14, TMP22);
01595 
01596                 vis_padd16(TMP20, TMP24, TMP20);
01597 
01598                 vis_padd16(TMP22, TMP26, TMP22);
01599                 vis_pack16(TMP20, DST_2);
01600 
01601                 vis_pack16(TMP22, DST_3);
01602                 vis_st64_2(DST_2, dest, 8);
01603                 dest += stride;
01604                 vis_padd16(TMP0, TMP4, TMP24);
01605 
01606                 vis_mul8x16au(REF_S4, CONST_256, TMP0);
01607                 vis_padd16(TMP2, TMP6, TMP26);
01608 
01609                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
01610                 vis_padd16(TMP24, TMP8, TMP24);
01611 
01612                 vis_padd16(TMP26, TMP10, TMP26);
01613                 vis_pack16(TMP24, DST_0);
01614 
01615                 vis_pack16(TMP26, DST_1);
01616                 vis_st64(DST_0, dest[0]);
01617                 vis_pmerge(ZERO, REF_S6, TMP4);
01618 
01619                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);
01620 
01621                 vis_padd16(TMP0, TMP4, TMP0);
01622 
01623                 vis_padd16(TMP2, TMP6, TMP2);
01624 
01625                 vis_padd16(TMP0, TMP12, TMP0);
01626 
01627                 vis_padd16(TMP2, TMP14, TMP2);
01628                 vis_pack16(TMP0, DST_2);
01629 
01630                 vis_pack16(TMP2, DST_3);
01631                 vis_st64_2(DST_2, dest, 8);
01632                 dest += stride;
01633         } while (--height);
01634 }
01635 
01636 static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
01637                              const int stride, int height)
01638 {
01639         uint8_t *ref = (uint8_t *) _ref;
01640         unsigned long off = (unsigned long) ref & 0x7;
01641         unsigned long off_plus_1 = off + 1;
01642         int stride_8 = stride + 8;
01643 
01644         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
01645 
01646         ref = vis_alignaddr(ref);
01647 
01648         vis_ld64(ref[ 0], TMP0);
01649         vis_fzero(ZERO);
01650 
01651         vis_ld64(ref[ 8], TMP2);
01652 
01653         vis_ld64(constants2[0], CONST_2);
01654 
01655         vis_ld64(constants256_512[0], CONST_256);
01656         vis_faligndata(TMP0, TMP2, REF_S0);
01657 
01658         if (off != 0x7) {
01659                 vis_alignaddr_g0((void *)off_plus_1);
01660                 vis_faligndata(TMP0, TMP2, REF_S2);
01661         } else {
01662                 vis_src1(TMP2, REF_S2);
01663         }
01664 
01665         height >>= 1;
01666         do {    /* 26 cycles */
01667                 vis_ld64_2(ref, stride, TMP0);
01668                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);
01669                 vis_pmerge(ZERO,        REF_S2,    TMP12);
01670 
01671                 vis_alignaddr_g0((void *)off);
01672 
01673                 vis_ld64_2(ref, stride_8, TMP2);
01674                 ref += stride;
01675                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
01676                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);
01677 
01678                 vis_ld64_2(ref, stride, TMP4);
01679 
01680                 vis_ld64_2(ref, stride_8, TMP6);
01681                 ref += stride;
01682                 vis_faligndata(TMP0, TMP2, REF_S4);
01683 
01684                 vis_pmerge(ZERO, REF_S4, TMP18);
01685 
01686                 vis_pmerge(ZERO, REF_S4_1, TMP20);
01687 
01688                 vis_faligndata(TMP4, TMP6, REF_S0);
01689 
01690                 if (off != 0x7) {
01691                         vis_alignaddr_g0((void *)off_plus_1);
01692                         vis_faligndata(TMP0, TMP2, REF_S6);
01693                         vis_faligndata(TMP4, TMP6, REF_S2);
01694                 } else {
01695                         vis_src1(TMP2, REF_S6);
01696                         vis_src1(TMP6, REF_S2);
01697                 }
01698 
01699                 vis_padd16(TMP18, CONST_2, TMP18);
01700                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);
01701 
01702                 vis_padd16(TMP20, CONST_2, TMP20);
01703                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
01704 
01705                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);
01706                 vis_pmerge(ZERO, REF_S0_1, TMP28);
01707 
01708                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);
01709                 vis_padd16(TMP18, TMP22, TMP18);
01710 
01711                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
01712                 vis_padd16(TMP20, TMP24, TMP20);
01713 
01714                 vis_padd16(TMP8,  TMP18, TMP8);
01715 
01716                 vis_padd16(TMP10, TMP20, TMP10);
01717 
01718                 vis_padd16(TMP8,  TMP12, TMP8);
01719 
01720                 vis_padd16(TMP10, TMP14, TMP10);
01721                 vis_pack16(TMP8,  DST_0);
01722 
01723                 vis_pack16(TMP10, DST_1);
01724                 vis_st64(DST_0, dest[0]);
01725                 dest += stride;
01726                 vis_padd16(TMP18, TMP26, TMP18);
01727 
01728                 vis_padd16(TMP20, TMP28, TMP20);
01729 
01730                 vis_padd16(TMP18, TMP30, TMP18);
01731 
01732                 vis_padd16(TMP20, TMP32, TMP20);
01733                 vis_pack16(TMP18, DST_2);
01734 
01735                 vis_pack16(TMP20, DST_3);
01736                 vis_st64(DST_2, dest[0]);
01737                 dest += stride;
01738         } while (--height);
01739 }
01740 
01741 static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
01742                               const int stride, int height)
01743 {
01744         uint8_t *ref = (uint8_t *) _ref;
01745         unsigned long off = (unsigned long) ref & 0x7;
01746         unsigned long off_plus_1 = off + 1;
01747         int stride_8 = stride + 8;
01748         int stride_16 = stride + 16;
01749 
01750         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
01751 
01752         ref = vis_alignaddr(ref);
01753 
01754         vis_ld64(ref[ 0], TMP0);
01755         vis_fzero(ZERO);
01756 
01757         vis_ld64(ref[ 8], TMP2);
01758 
01759         vis_ld64(ref[16], TMP4);
01760 
01761         vis_ld64(constants6[0], CONST_6);
01762         vis_faligndata(TMP0, TMP2, REF_S0);
01763 
01764         vis_ld64(constants256_1024[0], CONST_256);
01765         vis_faligndata(TMP2, TMP4, REF_S4);
01766 
01767         if (off != 0x7) {
01768                 vis_alignaddr_g0((void *)off_plus_1);
01769                 vis_faligndata(TMP0, TMP2, REF_S2);
01770                 vis_faligndata(TMP2, TMP4, REF_S6);
01771         } else {
01772                 vis_src1(TMP2, REF_S2);
01773                 vis_src1(TMP4, REF_S6);
01774         }
01775 
01776         height >>= 1;
01777         do {    /* 55 cycles */
01778                 vis_ld64_2(ref, stride, TMP0);
01779                 vis_mul8x16au(REF_S0, CONST_256, TMP12);
01780                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);
01781 
01782                 vis_alignaddr_g0((void *)off);
01783 
01784                 vis_ld64_2(ref, stride_8, TMP2);
01785                 vis_mul8x16au(REF_S2, CONST_256, TMP16);
01786                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);
01787 
01788                 vis_ld64_2(ref, stride_16, TMP4);
01789                 ref += stride;
01790                 vis_mul8x16au(REF_S4, CONST_256, TMP20);
01791                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);
01792 
01793                 vis_ld64_2(ref, stride, TMP6);
01794                 vis_mul8x16au(REF_S6, CONST_256, TMP24);
01795                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);
01796 
01797                 vis_ld64_2(ref, stride_8, TMP8);
01798                 vis_faligndata(TMP0, TMP2, REF_0);
01799 
01800                 vis_ld64_2(ref, stride_16, TMP10);
01801                 ref += stride;
01802                 vis_faligndata(TMP2, TMP4, REF_4);
01803 
01804                 vis_ld64(dest[0], DST_0);
01805                 vis_faligndata(TMP6, TMP8, REF_S0);
01806 
01807                 vis_ld64_2(dest, 8, DST_2);
01808                 vis_faligndata(TMP8, TMP10, REF_S4);
01809 
01810                 if (off != 0x7) {
01811                         vis_alignaddr_g0((void *)off_plus_1);
01812                         vis_faligndata(TMP0, TMP2, REF_2);
01813                         vis_faligndata(TMP2, TMP4, REF_6);
01814                         vis_faligndata(TMP6, TMP8, REF_S2);
01815                         vis_faligndata(TMP8, TMP10, REF_S6);
01816                 } else {
01817                         vis_src1(TMP2, REF_2);
01818                         vis_src1(TMP4, REF_6);
01819                         vis_src1(TMP8, REF_S2);
01820                         vis_src1(TMP10, REF_S6);
01821                 }
01822 
01823                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
01824                 vis_pmerge(ZERO, REF_0, TMP0);
01825 
01826                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
01827                 vis_pmerge(ZERO,      REF_0_1,  TMP2);
01828 
01829                 vis_mul8x16au(REF_2, CONST_256, TMP4);
01830                 vis_pmerge(ZERO,      REF_2_1,  TMP6);
01831 
01832                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);
01833                 vis_padd16(TMP0, CONST_6, TMP0);
01834 
01835                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);
01836                 vis_padd16(TMP2, CONST_6, TMP2);
01837 
01838                 vis_padd16(TMP0, TMP4, TMP0);
01839                 vis_mul8x16au(REF_4, CONST_256, TMP4);
01840 
01841                 vis_padd16(TMP2, TMP6, TMP2);
01842                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);
01843 
01844                 vis_padd16(TMP12, TMP0, TMP12);
01845                 vis_mul8x16au(REF_6, CONST_256, TMP8);
01846 
01847                 vis_padd16(TMP14, TMP2, TMP14);
01848                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);
01849 
01850                 vis_padd16(TMP12, TMP16, TMP12);
01851                 vis_mul8x16au(REF_S0, CONST_256, REF_4);
01852 
01853                 vis_padd16(TMP14, TMP18, TMP14);
01854                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
01855 
01856                 vis_padd16(TMP12, TMP30, TMP12);
01857 
01858                 vis_padd16(TMP14, TMP32, TMP14);
01859                 vis_pack16(TMP12, DST_0);
01860 
01861                 vis_pack16(TMP14, DST_1);
01862                 vis_st64(DST_0, dest[0]);
01863                 vis_padd16(TMP4, CONST_6, TMP4);
01864 
01865                 vis_ld64_2(dest, stride, DST_0);
01866                 vis_padd16(TMP6, CONST_6, TMP6);
01867                 vis_mul8x16au(REF_S2, CONST_256, TMP12);
01868 
01869                 vis_padd16(TMP4, TMP8, TMP4);
01870                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);
01871 
01872                 vis_padd16(TMP6, TMP10, TMP6);
01873 
01874                 vis_padd16(TMP20, TMP4, TMP20);
01875 
01876                 vis_padd16(TMP22, TMP6, TMP22);
01877 
01878                 vis_padd16(TMP20, TMP24, TMP20);
01879 
01880                 vis_padd16(TMP22, TMP26, TMP22);
01881 
01882                 vis_padd16(TMP20, REF_0, TMP20);
01883                 vis_mul8x16au(REF_S4, CONST_256, REF_0);
01884 
01885                 vis_padd16(TMP22, REF_2, TMP22);
01886                 vis_pack16(TMP20, DST_2);
01887 
01888                 vis_pack16(TMP22, DST_3);
01889                 vis_st64_2(DST_2, dest, 8);
01890                 dest += stride;
01891 
01892                 vis_ld64_2(dest, 8, DST_2);
01893                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
01894                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);
01895 
01896                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
01897                 vis_padd16(REF_4, TMP0, TMP8);
01898 
01899                 vis_mul8x16au(REF_S6, CONST_256, REF_4);
01900                 vis_padd16(REF_6, TMP2, TMP10);
01901 
01902                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
01903                 vis_padd16(TMP8, TMP12, TMP8);
01904 
01905                 vis_padd16(TMP10, TMP14, TMP10);
01906 
01907                 vis_padd16(TMP8, TMP30, TMP8);
01908 
01909                 vis_padd16(TMP10, TMP32, TMP10);
01910                 vis_pack16(TMP8, DST_0);
01911 
01912                 vis_pack16(TMP10, DST_1);
01913                 vis_st64(DST_0, dest[0]);
01914 
01915                 vis_padd16(REF_0, TMP4, REF_0);
01916 
01917                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);
01918                 vis_padd16(REF_2, TMP6, REF_2);
01919 
01920                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);
01921                 vis_padd16(REF_0, REF_4, REF_0);
01922 
01923                 vis_padd16(REF_2, REF_6, REF_2);
01924 
01925                 vis_padd16(REF_0, TMP30, REF_0);
01926 
01927                 /* stall */
01928 
01929                 vis_padd16(REF_2, TMP32, REF_2);
01930                 vis_pack16(REF_0, DST_2);
01931 
01932                 vis_pack16(REF_2, DST_3);
01933                 vis_st64_2(DST_2, dest, 8);
01934                 dest += stride;
01935         } while (--height);
01936 }
01937 
01938 static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
01939                              const int stride, int height)
01940 {
01941         uint8_t *ref = (uint8_t *) _ref;
01942         unsigned long off = (unsigned long) ref & 0x7;
01943         unsigned long off_plus_1 = off + 1;
01944         int stride_8 = stride + 8;
01945 
01946         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
01947 
01948         ref = vis_alignaddr(ref);
01949 
01950         vis_ld64(ref[0], TMP0);
01951         vis_fzero(ZERO);
01952 
01953         vis_ld64_2(ref, 8, TMP2);
01954 
01955         vis_ld64(constants6[0], CONST_6);
01956 
01957         vis_ld64(constants256_1024[0], CONST_256);
01958         vis_faligndata(TMP0, TMP2, REF_S0);
01959 
01960         if (off != 0x7) {
01961                 vis_alignaddr_g0((void *)off_plus_1);
01962                 vis_faligndata(TMP0, TMP2, REF_S2);
01963         } else {
01964                 vis_src1(TMP2, REF_S2);
01965         }
01966 
01967         height >>= 1;
01968         do {    /* 31 cycles */
01969                 vis_ld64_2(ref, stride, TMP0);
01970                 vis_mul8x16au(REF_S0, CONST_256, TMP8);
01971                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);
01972 
01973                 vis_ld64_2(ref, stride_8, TMP2);
01974                 ref += stride;
01975                 vis_mul8x16au(REF_S2, CONST_256, TMP12);
01976                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);
01977 
01978                 vis_alignaddr_g0((void *)off);
01979 
01980                 vis_ld64_2(ref, stride, TMP4);
01981                 vis_faligndata(TMP0, TMP2, REF_S4);
01982 
01983                 vis_ld64_2(ref, stride_8, TMP6);
01984                 ref += stride;
01985 
01986                 vis_ld64(dest[0], DST_0);
01987                 vis_faligndata(TMP4, TMP6, REF_S0);
01988 
01989                 vis_ld64_2(dest, stride, DST_2);
01990 
01991                 if (off != 0x7) {
01992                         vis_alignaddr_g0((void *)off_plus_1);
01993                         vis_faligndata(TMP0, TMP2, REF_S6);
01994                         vis_faligndata(TMP4, TMP6, REF_S2);
01995                 } else {
01996                         vis_src1(TMP2, REF_S6);
01997                         vis_src1(TMP6, REF_S2);
01998                 }
01999 
02000                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);
02001                 vis_pmerge(ZERO, REF_S4, TMP22);
02002 
02003                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);
02004                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);
02005 
02006                 vis_mul8x16au(REF_S6, CONST_256, TMP26);
02007                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);
02008 
02009                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);
02010                 vis_padd16(TMP22, CONST_6, TMP22);
02011 
02012                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
02013                 vis_padd16(TMP24, CONST_6, TMP24);
02014 
02015                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);
02016                 vis_padd16(TMP22, TMP26, TMP22);
02017 
02018                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);
02019                 vis_padd16(TMP24, TMP28, TMP24);
02020 
02021                 vis_mul8x16au(REF_S2, CONST_256, TMP26);
02022                 vis_padd16(TMP8, TMP22, TMP8);
02023 
02024                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
02025                 vis_padd16(TMP10, TMP24, TMP10);
02026 
02027                 vis_padd16(TMP8, TMP12, TMP8);
02028 
02029                 vis_padd16(TMP10, TMP14, TMP10);
02030 
02031                 vis_padd16(TMP8, TMP30, TMP8);
02032 
02033                 vis_padd16(TMP10, TMP32, TMP10);
02034                 vis_pack16(TMP8, DST_0);
02035 
02036                 vis_pack16(TMP10, DST_1);
02037                 vis_st64(DST_0, dest[0]);
02038                 dest += stride;
02039 
02040                 vis_padd16(REF_S4, TMP22, TMP12);
02041 
02042                 vis_padd16(REF_S6, TMP24, TMP14);
02043 
02044                 vis_padd16(TMP12, TMP26, TMP12);
02045 
02046                 vis_padd16(TMP14, TMP28, TMP14);
02047 
02048                 vis_padd16(TMP12, REF_0, TMP12);
02049 
02050                 vis_padd16(TMP14, REF_2, TMP14);
02051                 vis_pack16(TMP12, DST_2);
02052 
02053                 vis_pack16(TMP14, DST_3);
02054                 vis_st64(DST_2, dest[0]);
02055                 dest += stride;
02056         } while (--height);
02057 }
02058 
02059 MPEG2_MC_EXTERN(vis);
02060 
02061 #endif  /* !(ARCH_SPARC) */