git.sesse.net Git - ffmpeg/blob - libavcodec/ppc/h264_altivec_template.c

   1 /*
   2  * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libav is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Libav; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/mem.h"
  22
  23 #ifdef DEBUG
  24 #define ASSERT_ALIGNED(ptr) assert(((unsigned long)ptr&0x0000000F));
  25 #else
  26 #define ASSERT_ALIGNED(ptr) ;
  27 #endif
  28
  29 /* this code assume that stride % 16 == 0 */
  30
  31 #define CHROMA_MC8_ALTIVEC_CORE(BIAS1, BIAS2) \
  32         vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc2uc);\
  33         vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc3uc);\
  34 \
  35         psum = vec_mladd(vA, vsrc0ssH, BIAS1);\
  36         psum = vec_mladd(vB, vsrc1ssH, psum);\
  37         psum = vec_mladd(vC, vsrc2ssH, psum);\
  38         psum = vec_mladd(vD, vsrc3ssH, psum);\
  39         psum = BIAS2(psum);\
  40         psum = vec_sr(psum, v6us);\
  41 \
  42         vdst = vec_ld(0, dst);\
  43         ppsum = (vec_u8)vec_pack(psum, psum);\
  44         vfdst = vec_perm(vdst, ppsum, fperm);\
  45 \
  46         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
  47 \
  48         vec_st(fsum, 0, dst);\
  49 \
  50         vsrc0ssH = vsrc2ssH;\
  51         vsrc1ssH = vsrc3ssH;\
  52 \
  53         dst += stride;\
  54         src += stride;
  55
  56 #define CHROMA_MC8_ALTIVEC_CORE_SIMPLE \
  57 \
  58         vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);\
  59         vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);\
  60 \
  61         psum = vec_mladd(vA, vsrc0ssH, v32ss);\
  62         psum = vec_mladd(vE, vsrc1ssH, psum);\
  63         psum = vec_sr(psum, v6us);\
  64 \
  65         vdst = vec_ld(0, dst);\
  66         ppsum = (vec_u8)vec_pack(psum, psum);\
  67         vfdst = vec_perm(vdst, ppsum, fperm);\
  68 \
  69         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
  70 \
  71         vec_st(fsum, 0, dst);\
  72 \
  73         dst += stride;\
  74         src += stride;
  75
  76 #define noop(a) a
  77 #define add28(a) vec_add(v28ss, a)
  78
  79 #ifdef PREFIX_h264_chroma_mc8_altivec
  80 static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
  81                                     int stride, int h, int x, int y) {
  82     DECLARE_ALIGNED(16, signed int, ABCD)[4] =
  83                         {((8 - x) * (8 - y)),
  84                          ((    x) * (8 - y)),
  85                          ((8 - x) * (    y)),
  86                          ((    x) * (    y))};
  87     register int i;
  88     vec_u8 fperm;
  89     const vec_s32 vABCD = vec_ld(0, ABCD);
  90     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);
  91     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);
  92     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);
  93     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);
  94     LOAD_ZERO;
  95     const vec_s16 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));
  96     const vec_u16 v6us = vec_splat_u16(6);
  97     register int loadSecond = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
  98     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
  99
 100     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;
 101     vec_u8 vsrc0uc, vsrc1uc;
 102     vec_s16 vsrc0ssH, vsrc1ssH;
 103     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;
 104     vec_s16 vsrc2ssH, vsrc3ssH, psum;
 105     vec_u8 vdst, ppsum, vfdst, fsum;
 106
 107     if (((unsigned long)dst) % 16 == 0) {
 108         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
 109                          0x14, 0x15, 0x16, 0x17,
 110                          0x08, 0x09, 0x0A, 0x0B,
 111                          0x0C, 0x0D, 0x0E, 0x0F};
 112     } else {
 113         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
 114                          0x04, 0x05, 0x06, 0x07,
 115                          0x18, 0x19, 0x1A, 0x1B,
 116                          0x1C, 0x1D, 0x1E, 0x1F};
 117     }
 118
 119     vsrcAuc = vec_ld(0, src);
 120
 121     if (loadSecond)
 122         vsrcBuc = vec_ld(16, src);
 123     vsrcperm0 = vec_lvsl(0, src);
 124     vsrcperm1 = vec_lvsl(1, src);
 125
 126     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);
 127     if (reallyBadAlign)
 128         vsrc1uc = vsrcBuc;
 129     else
 130         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);
 131
 132     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);
 133     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);
 134
 135     if (ABCD[3]) {
 136         if (!loadSecond) {// -> !reallyBadAlign
 137             for (i = 0 ; i < h ; i++) {
 138                 vsrcCuc = vec_ld(stride + 0, src);
 139                 vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
 140                 vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
 141
 142                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)
 143             }
 144         } else {
 145             vec_u8 vsrcDuc;
 146             for (i = 0 ; i < h ; i++) {
 147                 vsrcCuc = vec_ld(stride + 0, src);
 148                 vsrcDuc = vec_ld(stride + 16, src);
 149                 vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
 150                 if (reallyBadAlign)
 151                     vsrc3uc = vsrcDuc;
 152                 else
 153                     vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
 154
 155                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)
 156             }
 157         }
 158     } else {
 159         const vec_s16 vE = vec_add(vB, vC);
 160         if (ABCD[2]) { // x == 0 B == 0
 161             if (!loadSecond) {// -> !reallyBadAlign
 162                 for (i = 0 ; i < h ; i++) {
 163                     vsrcCuc = vec_ld(stride + 0, src);
 164                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
 165                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
 166
 167                     vsrc0uc = vsrc1uc;
 168                 }
 169             } else {
 170                 vec_u8 vsrcDuc;
 171                 for (i = 0 ; i < h ; i++) {
 172                     vsrcCuc = vec_ld(stride + 0, src);
 173                     vsrcDuc = vec_ld(stride + 15, src);
 174                     vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
 175                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
 176
 177                     vsrc0uc = vsrc1uc;
 178                 }
 179             }
 180         } else { // y == 0 C == 0
 181             if (!loadSecond) {// -> !reallyBadAlign
 182                 for (i = 0 ; i < h ; i++) {
 183                     vsrcCuc = vec_ld(0, src);
 184                     vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
 185                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
 186
 187                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
 188                 }
 189             } else {
 190                 vec_u8 vsrcDuc;
 191                 for (i = 0 ; i < h ; i++) {
 192                     vsrcCuc = vec_ld(0, src);
 193                     vsrcDuc = vec_ld(15, src);
 194                     vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
 195                     if (reallyBadAlign)
 196                         vsrc1uc = vsrcDuc;
 197                     else
 198                         vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
 199
 200                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
 201                 }
 202             }
 203         }
 204     }
 205 }
 206 #endif
 207
 208 /* this code assume that stride % 16 == 0 */
 209 #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec
 210 static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {
 211    DECLARE_ALIGNED(16, signed int, ABCD)[4] =
 212                         {((8 - x) * (8 - y)),
 213                          ((    x) * (8 - y)),
 214                          ((8 - x) * (    y)),
 215                          ((    x) * (    y))};
 216     register int i;
 217     vec_u8 fperm;
 218     const vec_s32 vABCD = vec_ld(0, ABCD);
 219     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);
 220     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);
 221     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);
 222     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);
 223     LOAD_ZERO;
 224     const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));
 225     const vec_u16 v6us  = vec_splat_u16(6);
 226     register int loadSecond     = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
 227     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
 228
 229     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;
 230     vec_u8 vsrc0uc, vsrc1uc;
 231     vec_s16 vsrc0ssH, vsrc1ssH;
 232     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;
 233     vec_s16 vsrc2ssH, vsrc3ssH, psum;
 234     vec_u8 vdst, ppsum, vfdst, fsum;
 235
 236     if (((unsigned long)dst) % 16 == 0) {
 237         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
 238                          0x14, 0x15, 0x16, 0x17,
 239                          0x08, 0x09, 0x0A, 0x0B,
 240                          0x0C, 0x0D, 0x0E, 0x0F};
 241     } else {
 242         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
 243                          0x04, 0x05, 0x06, 0x07,
 244                          0x18, 0x19, 0x1A, 0x1B,
 245                          0x1C, 0x1D, 0x1E, 0x1F};
 246     }
 247
 248     vsrcAuc = vec_ld(0, src);
 249
 250     if (loadSecond)
 251         vsrcBuc = vec_ld(16, src);
 252     vsrcperm0 = vec_lvsl(0, src);
 253     vsrcperm1 = vec_lvsl(1, src);
 254
 255     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);
 256     if (reallyBadAlign)
 257         vsrc1uc = vsrcBuc;
 258     else
 259         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);
 260
 261     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc);
 262     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc);
 263
 264     if (!loadSecond) {// -> !reallyBadAlign
 265         for (i = 0 ; i < h ; i++) {
 266
 267
 268             vsrcCuc = vec_ld(stride + 0, src);
 269
 270             vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
 271             vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
 272
 273             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)
 274         }
 275     } else {
 276         vec_u8 vsrcDuc;
 277         for (i = 0 ; i < h ; i++) {
 278             vsrcCuc = vec_ld(stride + 0, src);
 279             vsrcDuc = vec_ld(stride + 16, src);
 280
 281             vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
 282             if (reallyBadAlign)
 283                 vsrc3uc = vsrcDuc;
 284             else
 285                 vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
 286
 287             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)
 288         }
 289     }
 290 }
 291 #endif
 292
 293 #undef noop
 294 #undef add28
 295 #undef CHROMA_MC8_ALTIVEC_CORE
 296
 297 /* this code assume stride % 16 == 0 */
 298 #ifdef PREFIX_h264_qpel16_h_lowpass_altivec
 299 static void PREFIX_h264_qpel16_h_lowpass_altivec(uint8_t * dst, uint8_t * src, int dstStride, int srcStride) {
 300     register int i;
 301
 302     LOAD_ZERO;
 303     const vec_u8 permM2 = vec_lvsl(-2, src);
 304     const vec_u8 permM1 = vec_lvsl(-1, src);
 305     const vec_u8 permP0 = vec_lvsl(+0, src);
 306     const vec_u8 permP1 = vec_lvsl(+1, src);
 307     const vec_u8 permP2 = vec_lvsl(+2, src);
 308     const vec_u8 permP3 = vec_lvsl(+3, src);
 309     const vec_s16 v5ss = vec_splat_s16(5);
 310     const vec_u16 v5us = vec_splat_u16(5);
 311     const vec_s16 v20ss = vec_sl(vec_splat_s16(5),vec_splat_u16(2));
 312     const vec_s16 v16ss = vec_sl(vec_splat_s16(1),vec_splat_u16(4));
 313
 314     vec_u8 srcM2, srcM1, srcP0, srcP1, srcP2, srcP3;
 315
 316     register int align = ((((unsigned long)src) - 2) % 16);
 317
 318     vec_s16 srcP0A, srcP0B, srcP1A, srcP1B,
 319               srcP2A, srcP2B, srcP3A, srcP3B,
 320               srcM1A, srcM1B, srcM2A, srcM2B,
 321               sum1A, sum1B, sum2A, sum2B, sum3A, sum3B,
 322               pp1A, pp1B, pp2A, pp2B, pp3A, pp3B,
 323               psumA, psumB, sumA, sumB;
 324
 325     vec_u8 sum, fsum;
 326
 327     for (i = 0 ; i < 16 ; i ++) {
 328         vec_u8 srcR1 = vec_ld(-2, src);
 329         vec_u8 srcR2 = vec_ld(14, src);
 330
 331         switch (align) {
 332         default: {
 333             srcM2 = vec_perm(srcR1, srcR2, permM2);
 334             srcM1 = vec_perm(srcR1, srcR2, permM1);
 335             srcP0 = vec_perm(srcR1, srcR2, permP0);
 336             srcP1 = vec_perm(srcR1, srcR2, permP1);
 337             srcP2 = vec_perm(srcR1, srcR2, permP2);
 338             srcP3 = vec_perm(srcR1, srcR2, permP3);
 339         } break;
 340         case 11: {
 341             srcM2 = vec_perm(srcR1, srcR2, permM2);
 342             srcM1 = vec_perm(srcR1, srcR2, permM1);
 343             srcP0 = vec_perm(srcR1, srcR2, permP0);
 344             srcP1 = vec_perm(srcR1, srcR2, permP1);
 345             srcP2 = vec_perm(srcR1, srcR2, permP2);
 346             srcP3 = srcR2;
 347         } break;
 348         case 12: {
 349             vec_u8 srcR3 = vec_ld(30, src);
 350             srcM2 = vec_perm(srcR1, srcR2, permM2);
 351             srcM1 = vec_perm(srcR1, srcR2, permM1);
 352             srcP0 = vec_perm(srcR1, srcR2, permP0);
 353             srcP1 = vec_perm(srcR1, srcR2, permP1);
 354             srcP2 = srcR2;
 355             srcP3 = vec_perm(srcR2, srcR3, permP3);
 356         } break;
 357         case 13: {
 358             vec_u8 srcR3 = vec_ld(30, src);
 359             srcM2 = vec_perm(srcR1, srcR2, permM2);
 360             srcM1 = vec_perm(srcR1, srcR2, permM1);
 361             srcP0 = vec_perm(srcR1, srcR2, permP0);
 362             srcP1 = srcR2;
 363             srcP2 = vec_perm(srcR2, srcR3, permP2);
 364             srcP3 = vec_perm(srcR2, srcR3, permP3);
 365         } break;
 366         case 14: {
 367             vec_u8 srcR3 = vec_ld(30, src);
 368             srcM2 = vec_perm(srcR1, srcR2, permM2);
 369             srcM1 = vec_perm(srcR1, srcR2, permM1);
 370             srcP0 = srcR2;
 371             srcP1 = vec_perm(srcR2, srcR3, permP1);
 372             srcP2 = vec_perm(srcR2, srcR3, permP2);
 373             srcP3 = vec_perm(srcR2, srcR3, permP3);
 374         } break;
 375         case 15: {
 376             vec_u8 srcR3 = vec_ld(30, src);
 377             srcM2 = vec_perm(srcR1, srcR2, permM2);
 378             srcM1 = srcR2;
 379             srcP0 = vec_perm(srcR2, srcR3, permP0);
 380             srcP1 = vec_perm(srcR2, srcR3, permP1);
 381             srcP2 = vec_perm(srcR2, srcR3, permP2);
 382             srcP3 = vec_perm(srcR2, srcR3, permP3);
 383         } break;
 384         }
 385
 386         srcP0A = (vec_s16) vec_mergeh(zero_u8v, srcP0);
 387         srcP0B = (vec_s16) vec_mergel(zero_u8v, srcP0);
 388         srcP1A = (vec_s16) vec_mergeh(zero_u8v, srcP1);
 389         srcP1B = (vec_s16) vec_mergel(zero_u8v, srcP1);
 390
 391         srcP2A = (vec_s16) vec_mergeh(zero_u8v, srcP2);
 392         srcP2B = (vec_s16) vec_mergel(zero_u8v, srcP2);
 393         srcP3A = (vec_s16) vec_mergeh(zero_u8v, srcP3);
 394         srcP3B = (vec_s16) vec_mergel(zero_u8v, srcP3);
 395
 396         srcM1A = (vec_s16) vec_mergeh(zero_u8v, srcM1);
 397         srcM1B = (vec_s16) vec_mergel(zero_u8v, srcM1);
 398         srcM2A = (vec_s16) vec_mergeh(zero_u8v, srcM2);
 399         srcM2B = (vec_s16) vec_mergel(zero_u8v, srcM2);
 400
 401         sum1A = vec_adds(srcP0A, srcP1A);
 402         sum1B = vec_adds(srcP0B, srcP1B);
 403         sum2A = vec_adds(srcM1A, srcP2A);
 404         sum2B = vec_adds(srcM1B, srcP2B);
 405         sum3A = vec_adds(srcM2A, srcP3A);
 406         sum3B = vec_adds(srcM2B, srcP3B);
 407
 408         pp1A = vec_mladd(sum1A, v20ss, v16ss);
 409         pp1B = vec_mladd(sum1B, v20ss, v16ss);
 410
 411         pp2A = vec_mladd(sum2A, v5ss, zero_s16v);
 412         pp2B = vec_mladd(sum2B, v5ss, zero_s16v);
 413
 414         pp3A = vec_add(sum3A, pp1A);
 415         pp3B = vec_add(sum3B, pp1B);
 416
 417         psumA = vec_sub(pp3A, pp2A);
 418         psumB = vec_sub(pp3B, pp2B);
 419
 420         sumA = vec_sra(psumA, v5us);
 421         sumB = vec_sra(psumB, v5us);
 422
 423         sum = vec_packsu(sumA, sumB);
 424
 425         ASSERT_ALIGNED(dst);
 426
 427         OP_U8_ALTIVEC(fsum, sum, vec_ld(0, dst));
 428
 429         vec_st(fsum, 0, dst);
 430
 431         src += srcStride;
 432         dst += dstStride;
 433     }
 434 }
 435 #endif
 436
 437 /* this code assume stride % 16 == 0 */
 438 #ifdef PREFIX_h264_qpel16_v_lowpass_altivec
 439 static void PREFIX_h264_qpel16_v_lowpass_altivec(uint8_t * dst, uint8_t * src, int dstStride, int srcStride) {
 440     register int i;
 441
 442     LOAD_ZERO;
 443     const vec_u8 perm = vec_lvsl(0, src);
 444     const vec_s16 v20ss = vec_sl(vec_splat_s16(5),vec_splat_u16(2));
 445     const vec_u16 v5us = vec_splat_u16(5);
 446     const vec_s16 v5ss = vec_splat_s16(5);
 447     const vec_s16 v16ss = vec_sl(vec_splat_s16(1),vec_splat_u16(4));
 448
 449     uint8_t *srcbis = src - (srcStride * 2);
 450
 451     const vec_u8 srcM2a = vec_ld(0, srcbis);
 452     const vec_u8 srcM2b = vec_ld(16, srcbis);
 453     const vec_u8 srcM2 = vec_perm(srcM2a, srcM2b, perm);
 454     //srcbis += srcStride;
 455     const vec_u8 srcM1a = vec_ld(0, srcbis += srcStride);
 456     const vec_u8 srcM1b = vec_ld(16, srcbis);
 457     const vec_u8 srcM1 = vec_perm(srcM1a, srcM1b, perm);
 458     //srcbis += srcStride;
 459     const vec_u8 srcP0a = vec_ld(0, srcbis += srcStride);
 460     const vec_u8 srcP0b = vec_ld(16, srcbis);
 461     const vec_u8 srcP0 = vec_perm(srcP0a, srcP0b, perm);
 462     //srcbis += srcStride;
 463     const vec_u8 srcP1a = vec_ld(0, srcbis += srcStride);
 464     const vec_u8 srcP1b = vec_ld(16, srcbis);
 465     const vec_u8 srcP1 = vec_perm(srcP1a, srcP1b, perm);
 466     //srcbis += srcStride;
 467     const vec_u8 srcP2a = vec_ld(0, srcbis += srcStride);
 468     const vec_u8 srcP2b = vec_ld(16, srcbis);
 469     const vec_u8 srcP2 = vec_perm(srcP2a, srcP2b, perm);
 470     //srcbis += srcStride;
 471
 472     vec_s16 srcM2ssA = (vec_s16) vec_mergeh(zero_u8v, srcM2);
 473     vec_s16 srcM2ssB = (vec_s16) vec_mergel(zero_u8v, srcM2);
 474     vec_s16 srcM1ssA = (vec_s16) vec_mergeh(zero_u8v, srcM1);
 475     vec_s16 srcM1ssB = (vec_s16) vec_mergel(zero_u8v, srcM1);
 476     vec_s16 srcP0ssA = (vec_s16) vec_mergeh(zero_u8v, srcP0);
 477     vec_s16 srcP0ssB = (vec_s16) vec_mergel(zero_u8v, srcP0);
 478     vec_s16 srcP1ssA = (vec_s16) vec_mergeh(zero_u8v, srcP1);
 479     vec_s16 srcP1ssB = (vec_s16) vec_mergel(zero_u8v, srcP1);
 480     vec_s16 srcP2ssA = (vec_s16) vec_mergeh(zero_u8v, srcP2);
 481     vec_s16 srcP2ssB = (vec_s16) vec_mergel(zero_u8v, srcP2);
 482
 483     vec_s16 pp1A, pp1B, pp2A, pp2B, pp3A, pp3B,
 484               psumA, psumB, sumA, sumB,
 485               srcP3ssA, srcP3ssB,
 486               sum1A, sum1B, sum2A, sum2B, sum3A, sum3B;
 487
 488     vec_u8 sum, fsum, srcP3a, srcP3b, srcP3;
 489
 490     for (i = 0 ; i < 16 ; i++) {
 491         srcP3a = vec_ld(0, srcbis += srcStride);
 492         srcP3b = vec_ld(16, srcbis);
 493         srcP3 = vec_perm(srcP3a, srcP3b, perm);
 494         srcP3ssA = (vec_s16) vec_mergeh(zero_u8v, srcP3);
 495         srcP3ssB = (vec_s16) vec_mergel(zero_u8v, srcP3);
 496         //srcbis += srcStride;
 497
 498         sum1A = vec_adds(srcP0ssA, srcP1ssA);
 499         sum1B = vec_adds(srcP0ssB, srcP1ssB);
 500         sum2A = vec_adds(srcM1ssA, srcP2ssA);
 501         sum2B = vec_adds(srcM1ssB, srcP2ssB);
 502         sum3A = vec_adds(srcM2ssA, srcP3ssA);
 503         sum3B = vec_adds(srcM2ssB, srcP3ssB);
 504
 505         srcM2ssA = srcM1ssA;
 506         srcM2ssB = srcM1ssB;
 507         srcM1ssA = srcP0ssA;
 508         srcM1ssB = srcP0ssB;
 509         srcP0ssA = srcP1ssA;
 510         srcP0ssB = srcP1ssB;
 511         srcP1ssA = srcP2ssA;
 512         srcP1ssB = srcP2ssB;
 513         srcP2ssA = srcP3ssA;
 514         srcP2ssB = srcP3ssB;
 515
 516         pp1A = vec_mladd(sum1A, v20ss, v16ss);
 517         pp1B = vec_mladd(sum1B, v20ss, v16ss);
 518
 519         pp2A = vec_mladd(sum2A, v5ss, zero_s16v);
 520         pp2B = vec_mladd(sum2B, v5ss, zero_s16v);
 521
 522         pp3A = vec_add(sum3A, pp1A);
 523         pp3B = vec_add(sum3B, pp1B);
 524
 525         psumA = vec_sub(pp3A, pp2A);
 526         psumB = vec_sub(pp3B, pp2B);
 527
 528         sumA = vec_sra(psumA, v5us);
 529         sumB = vec_sra(psumB, v5us);
 530
 531         sum = vec_packsu(sumA, sumB);
 532
 533         ASSERT_ALIGNED(dst);
 534
 535         OP_U8_ALTIVEC(fsum, sum, vec_ld(0, dst));
 536
 537         vec_st(fsum, 0, dst);
 538
 539         dst += dstStride;
 540     }
 541 }
 542 #endif
 543
 544 /* this code assume stride % 16 == 0 *and* tmp is properly aligned */
 545 #ifdef PREFIX_h264_qpel16_hv_lowpass_altivec
 546 static void PREFIX_h264_qpel16_hv_lowpass_altivec(uint8_t * dst, int16_t * tmp, uint8_t * src, int dstStride, int tmpStride, int srcStride) {
 547     register int i;
 548     LOAD_ZERO;
 549     const vec_u8 permM2 = vec_lvsl(-2, src);
 550     const vec_u8 permM1 = vec_lvsl(-1, src);
 551     const vec_u8 permP0 = vec_lvsl(+0, src);
 552     const vec_u8 permP1 = vec_lvsl(+1, src);
 553     const vec_u8 permP2 = vec_lvsl(+2, src);
 554     const vec_u8 permP3 = vec_lvsl(+3, src);
 555     const vec_s16 v20ss = vec_sl(vec_splat_s16(5),vec_splat_u16(2));
 556     const vec_u32 v10ui = vec_splat_u32(10);
 557     const vec_s16 v5ss = vec_splat_s16(5);
 558     const vec_s16 v1ss = vec_splat_s16(1);
 559     const vec_s32 v512si = vec_sl(vec_splat_s32(1),vec_splat_u32(9));
 560     const vec_u32 v16ui = vec_sl(vec_splat_u32(1),vec_splat_u32(4));
 561
 562     register int align = ((((unsigned long)src) - 2) % 16);
 563
 564     vec_s16 srcP0A, srcP0B, srcP1A, srcP1B,
 565               srcP2A, srcP2B, srcP3A, srcP3B,
 566               srcM1A, srcM1B, srcM2A, srcM2B,
 567               sum1A, sum1B, sum2A, sum2B, sum3A, sum3B,
 568               pp1A, pp1B, pp2A, pp2B, psumA, psumB;
 569
 570     const vec_u8 mperm = (const vec_u8)
 571         {0x00, 0x08, 0x01, 0x09, 0x02, 0x0A, 0x03, 0x0B,
 572          0x04, 0x0C, 0x05, 0x0D, 0x06, 0x0E, 0x07, 0x0F};
 573     int16_t *tmpbis = tmp;
 574
 575     vec_s16 tmpM1ssA, tmpM1ssB, tmpM2ssA, tmpM2ssB,
 576               tmpP0ssA, tmpP0ssB, tmpP1ssA, tmpP1ssB,
 577               tmpP2ssA, tmpP2ssB;
 578
 579     vec_s32 pp1Ae, pp1Ao, pp1Be, pp1Bo, pp2Ae, pp2Ao, pp2Be, pp2Bo,
 580               pp3Ae, pp3Ao, pp3Be, pp3Bo, pp1cAe, pp1cAo, pp1cBe, pp1cBo,
 581               pp32Ae, pp32Ao, pp32Be, pp32Bo, sumAe, sumAo, sumBe, sumBo,
 582               ssumAe, ssumAo, ssumBe, ssumBo;
 583     vec_u8 fsum, sumv, sum;
 584     vec_s16 ssume, ssumo;
 585
 586     src -= (2 * srcStride);
 587     for (i = 0 ; i < 21 ; i ++) {
 588         vec_u8 srcM2, srcM1, srcP0, srcP1, srcP2, srcP3;
 589         vec_u8 srcR1 = vec_ld(-2, src);
 590         vec_u8 srcR2 = vec_ld(14, src);
 591
 592         switch (align) {
 593         default: {
 594             srcM2 = vec_perm(srcR1, srcR2, permM2);
 595             srcM1 = vec_perm(srcR1, srcR2, permM1);
 596             srcP0 = vec_perm(srcR1, srcR2, permP0);
 597             srcP1 = vec_perm(srcR1, srcR2, permP1);
 598             srcP2 = vec_perm(srcR1, srcR2, permP2);
 599             srcP3 = vec_perm(srcR1, srcR2, permP3);
 600         } break;
 601         case 11: {
 602             srcM2 = vec_perm(srcR1, srcR2, permM2);
 603             srcM1 = vec_perm(srcR1, srcR2, permM1);
 604             srcP0 = vec_perm(srcR1, srcR2, permP0);
 605             srcP1 = vec_perm(srcR1, srcR2, permP1);
 606             srcP2 = vec_perm(srcR1, srcR2, permP2);
 607             srcP3 = srcR2;
 608         } break;
 609         case 12: {
 610             vec_u8 srcR3 = vec_ld(30, src);
 611             srcM2 = vec_perm(srcR1, srcR2, permM2);
 612             srcM1 = vec_perm(srcR1, srcR2, permM1);
 613             srcP0 = vec_perm(srcR1, srcR2, permP0);
 614             srcP1 = vec_perm(srcR1, srcR2, permP1);
 615             srcP2 = srcR2;
 616             srcP3 = vec_perm(srcR2, srcR3, permP3);
 617         } break;
 618         case 13: {
 619             vec_u8 srcR3 = vec_ld(30, src);
 620             srcM2 = vec_perm(srcR1, srcR2, permM2);
 621             srcM1 = vec_perm(srcR1, srcR2, permM1);
 622             srcP0 = vec_perm(srcR1, srcR2, permP0);
 623             srcP1 = srcR2;
 624             srcP2 = vec_perm(srcR2, srcR3, permP2);
 625             srcP3 = vec_perm(srcR2, srcR3, permP3);
 626         } break;
 627         case 14: {
 628             vec_u8 srcR3 = vec_ld(30, src);
 629             srcM2 = vec_perm(srcR1, srcR2, permM2);
 630             srcM1 = vec_perm(srcR1, srcR2, permM1);
 631             srcP0 = srcR2;
 632             srcP1 = vec_perm(srcR2, srcR3, permP1);
 633             srcP2 = vec_perm(srcR2, srcR3, permP2);
 634             srcP3 = vec_perm(srcR2, srcR3, permP3);
 635         } break;
 636         case 15: {
 637             vec_u8 srcR3 = vec_ld(30, src);
 638             srcM2 = vec_perm(srcR1, srcR2, permM2);
 639             srcM1 = srcR2;
 640             srcP0 = vec_perm(srcR2, srcR3, permP0);
 641             srcP1 = vec_perm(srcR2, srcR3, permP1);
 642             srcP2 = vec_perm(srcR2, srcR3, permP2);
 643             srcP3 = vec_perm(srcR2, srcR3, permP3);
 644         } break;
 645         }
 646
 647         srcP0A = (vec_s16) vec_mergeh(zero_u8v, srcP0);
 648         srcP0B = (vec_s16) vec_mergel(zero_u8v, srcP0);
 649         srcP1A = (vec_s16) vec_mergeh(zero_u8v, srcP1);
 650         srcP1B = (vec_s16) vec_mergel(zero_u8v, srcP1);
 651
 652         srcP2A = (vec_s16) vec_mergeh(zero_u8v, srcP2);
 653         srcP2B = (vec_s16) vec_mergel(zero_u8v, srcP2);
 654         srcP3A = (vec_s16) vec_mergeh(zero_u8v, srcP3);
 655         srcP3B = (vec_s16) vec_mergel(zero_u8v, srcP3);
 656
 657         srcM1A = (vec_s16) vec_mergeh(zero_u8v, srcM1);
 658         srcM1B = (vec_s16) vec_mergel(zero_u8v, srcM1);
 659         srcM2A = (vec_s16) vec_mergeh(zero_u8v, srcM2);
 660         srcM2B = (vec_s16) vec_mergel(zero_u8v, srcM2);
 661
 662         sum1A = vec_adds(srcP0A, srcP1A);
 663         sum1B = vec_adds(srcP0B, srcP1B);
 664         sum2A = vec_adds(srcM1A, srcP2A);
 665         sum2B = vec_adds(srcM1B, srcP2B);
 666         sum3A = vec_adds(srcM2A, srcP3A);
 667         sum3B = vec_adds(srcM2B, srcP3B);
 668
 669         pp1A = vec_mladd(sum1A, v20ss, sum3A);
 670         pp1B = vec_mladd(sum1B, v20ss, sum3B);
 671
 672         pp2A = vec_mladd(sum2A, v5ss, zero_s16v);
 673         pp2B = vec_mladd(sum2B, v5ss, zero_s16v);
 674
 675         psumA = vec_sub(pp1A, pp2A);
 676         psumB = vec_sub(pp1B, pp2B);
 677
 678         vec_st(psumA, 0, tmp);
 679         vec_st(psumB, 16, tmp);
 680
 681         src += srcStride;
 682         tmp += tmpStride; /* int16_t*, and stride is 16, so it's OK here */
 683     }
 684
 685     tmpM2ssA = vec_ld(0, tmpbis);
 686     tmpM2ssB = vec_ld(16, tmpbis);
 687     tmpbis += tmpStride;
 688     tmpM1ssA = vec_ld(0, tmpbis);
 689     tmpM1ssB = vec_ld(16, tmpbis);
 690     tmpbis += tmpStride;
 691     tmpP0ssA = vec_ld(0, tmpbis);
 692     tmpP0ssB = vec_ld(16, tmpbis);
 693     tmpbis += tmpStride;
 694     tmpP1ssA = vec_ld(0, tmpbis);
 695     tmpP1ssB = vec_ld(16, tmpbis);
 696     tmpbis += tmpStride;
 697     tmpP2ssA = vec_ld(0, tmpbis);
 698     tmpP2ssB = vec_ld(16, tmpbis);
 699     tmpbis += tmpStride;
 700
 701     for (i = 0 ; i < 16 ; i++) {
 702         const vec_s16 tmpP3ssA = vec_ld(0, tmpbis);
 703         const vec_s16 tmpP3ssB = vec_ld(16, tmpbis);
 704
 705         const vec_s16 sum1A = vec_adds(tmpP0ssA, tmpP1ssA);
 706         const vec_s16 sum1B = vec_adds(tmpP0ssB, tmpP1ssB);
 707         const vec_s16 sum2A = vec_adds(tmpM1ssA, tmpP2ssA);
 708         const vec_s16 sum2B = vec_adds(tmpM1ssB, tmpP2ssB);
 709         const vec_s16 sum3A = vec_adds(tmpM2ssA, tmpP3ssA);
 710         const vec_s16 sum3B = vec_adds(tmpM2ssB, tmpP3ssB);
 711
 712         tmpbis += tmpStride;
 713
 714         tmpM2ssA = tmpM1ssA;
 715         tmpM2ssB = tmpM1ssB;
 716         tmpM1ssA = tmpP0ssA;
 717         tmpM1ssB = tmpP0ssB;
 718         tmpP0ssA = tmpP1ssA;
 719         tmpP0ssB = tmpP1ssB;
 720         tmpP1ssA = tmpP2ssA;
 721         tmpP1ssB = tmpP2ssB;
 722         tmpP2ssA = tmpP3ssA;
 723         tmpP2ssB = tmpP3ssB;
 724
 725         pp1Ae = vec_mule(sum1A, v20ss);
 726         pp1Ao = vec_mulo(sum1A, v20ss);
 727         pp1Be = vec_mule(sum1B, v20ss);
 728         pp1Bo = vec_mulo(sum1B, v20ss);
 729
 730         pp2Ae = vec_mule(sum2A, v5ss);
 731         pp2Ao = vec_mulo(sum2A, v5ss);
 732         pp2Be = vec_mule(sum2B, v5ss);
 733         pp2Bo = vec_mulo(sum2B, v5ss);
 734
 735         pp3Ae = vec_sra((vec_s32)sum3A, v16ui);
 736         pp3Ao = vec_mulo(sum3A, v1ss);
 737         pp3Be = vec_sra((vec_s32)sum3B, v16ui);
 738         pp3Bo = vec_mulo(sum3B, v1ss);
 739
 740         pp1cAe = vec_add(pp1Ae, v512si);
 741         pp1cAo = vec_add(pp1Ao, v512si);
 742         pp1cBe = vec_add(pp1Be, v512si);
 743         pp1cBo = vec_add(pp1Bo, v512si);
 744
 745         pp32Ae = vec_sub(pp3Ae, pp2Ae);
 746         pp32Ao = vec_sub(pp3Ao, pp2Ao);
 747         pp32Be = vec_sub(pp3Be, pp2Be);
 748         pp32Bo = vec_sub(pp3Bo, pp2Bo);
 749
 750         sumAe = vec_add(pp1cAe, pp32Ae);
 751         sumAo = vec_add(pp1cAo, pp32Ao);
 752         sumBe = vec_add(pp1cBe, pp32Be);
 753         sumBo = vec_add(pp1cBo, pp32Bo);
 754
 755         ssumAe = vec_sra(sumAe, v10ui);
 756         ssumAo = vec_sra(sumAo, v10ui);
 757         ssumBe = vec_sra(sumBe, v10ui);
 758         ssumBo = vec_sra(sumBo, v10ui);
 759
 760         ssume = vec_packs(ssumAe, ssumBe);
 761         ssumo = vec_packs(ssumAo, ssumBo);
 762
 763         sumv = vec_packsu(ssume, ssumo);
 764         sum = vec_perm(sumv, sumv, mperm);
 765
 766         ASSERT_ALIGNED(dst);
 767
 768         OP_U8_ALTIVEC(fsum, sum, vec_ld(0, dst));
 769
 770         vec_st(fsum, 0, dst);
 771
 772         dst += dstStride;
 773     }
 774 }
 775 #endif