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

   1 /*
   2  * Copyright (c) 2002 Brian Foley
   3  * Copyright (c) 2002 Dieter Shirley
   4  * Copyright (c) 2003-2004 Romain Dolbeau <romain@dolbeau.org>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "libavcodec/dsputil.h"
  24
  25 #include "gcc_fixes.h"
  26
  27 #include "dsputil_ppc.h"
  28 #include "util_altivec.h"
  29
  30 int sad16_x2_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  31 {
  32     int i;
  33     DECLARE_ALIGNED_16(int, s);
  34     const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0);
  35     vector unsigned char *tv;
  36     vector unsigned char pix1v, pix2v, pix2iv, avgv, t5;
  37     vector unsigned int sad;
  38     vector signed int sumdiffs;
  39
  40     s = 0;
  41     sad = (vector unsigned int)vec_splat_u32(0);
  42     for(i=0;i<h;i++) {
  43         /*
  44            Read unaligned pixels into our vectors. The vectors are as follows:
  45            pix1v: pix1[0]-pix1[15]
  46            pix2v: pix2[0]-pix2[15]      pix2iv: pix2[1]-pix2[16]
  47         */
  48         tv = (vector unsigned char *) pix1;
  49         pix1v = vec_perm(tv[0], tv[1], vec_lvsl(0, pix1));
  50
  51         tv = (vector unsigned char *) &pix2[0];
  52         pix2v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[0]));
  53
  54         tv = (vector unsigned char *) &pix2[1];
  55         pix2iv = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[1]));
  56
  57         /* Calculate the average vector */
  58         avgv = vec_avg(pix2v, pix2iv);
  59
  60         /* Calculate a sum of abs differences vector */
  61         t5 = vec_sub(vec_max(pix1v, avgv), vec_min(pix1v, avgv));
  62
  63         /* Add each 4 pixel group together and put 4 results into sad */
  64         sad = vec_sum4s(t5, sad);
  65
  66         pix1 += line_size;
  67         pix2 += line_size;
  68     }
  69     /* Sum up the four partial sums, and put the result into s */
  70     sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero);
  71     sumdiffs = vec_splat(sumdiffs, 3);
  72     vec_ste(sumdiffs, 0, &s);
  73
  74     return s;
  75 }
  76
  77 int sad16_y2_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  78 {
  79     int i;
  80     DECLARE_ALIGNED_16(int, s);
  81     const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0);
  82     vector unsigned char *tv;
  83     vector unsigned char pix1v, pix2v, pix3v, avgv, t5;
  84     vector unsigned int sad;
  85     vector signed int sumdiffs;
  86     uint8_t *pix3 = pix2 + line_size;
  87
  88     s = 0;
  89     sad = (vector unsigned int)vec_splat_u32(0);
  90
  91     /*
  92        Due to the fact that pix3 = pix2 + line_size, the pix3 of one
  93        iteration becomes pix2 in the next iteration. We can use this
  94        fact to avoid a potentially expensive unaligned read, each
  95        time around the loop.
  96        Read unaligned pixels into our vectors. The vectors are as follows:
  97        pix2v: pix2[0]-pix2[15]
  98        Split the pixel vectors into shorts
  99     */
 100     tv = (vector unsigned char *) &pix2[0];
 101     pix2v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[0]));
 102
 103     for(i=0;i<h;i++) {
 104         /*
 105            Read unaligned pixels into our vectors. The vectors are as follows:
 106            pix1v: pix1[0]-pix1[15]
 107            pix3v: pix3[0]-pix3[15]
 108         */
 109         tv = (vector unsigned char *) pix1;
 110         pix1v = vec_perm(tv[0], tv[1], vec_lvsl(0, pix1));
 111
 112         tv = (vector unsigned char *) &pix3[0];
 113         pix3v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix3[0]));
 114
 115         /* Calculate the average vector */
 116         avgv = vec_avg(pix2v, pix3v);
 117
 118         /* Calculate a sum of abs differences vector */
 119         t5 = vec_sub(vec_max(pix1v, avgv), vec_min(pix1v, avgv));
 120
 121         /* Add each 4 pixel group together and put 4 results into sad */
 122         sad = vec_sum4s(t5, sad);
 123
 124         pix1 += line_size;
 125         pix2v = pix3v;
 126         pix3 += line_size;
 127
 128     }
 129
 130     /* Sum up the four partial sums, and put the result into s */
 131     sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero);
 132     sumdiffs = vec_splat(sumdiffs, 3);
 133     vec_ste(sumdiffs, 0, &s);
 134     return s;
 135 }
 136
 137 int sad16_xy2_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
 138 {
 139     int i;
 140     DECLARE_ALIGNED_16(int, s);
 141     uint8_t *pix3 = pix2 + line_size;
 142     const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0);
 143     const vector unsigned short two = (const vector unsigned short)vec_splat_u16(2);
 144     vector unsigned char *tv, avgv, t5;
 145     vector unsigned char pix1v, pix2v, pix3v, pix2iv, pix3iv;
 146     vector unsigned short pix2lv, pix2hv, pix2ilv, pix2ihv;
 147     vector unsigned short pix3lv, pix3hv, pix3ilv, pix3ihv;
 148     vector unsigned short avghv, avglv;
 149     vector unsigned short t1, t2, t3, t4;
 150     vector unsigned int sad;
 151     vector signed int sumdiffs;
 152
 153     sad = (vector unsigned int)vec_splat_u32(0);
 154
 155     s = 0;
 156
 157     /*
 158        Due to the fact that pix3 = pix2 + line_size, the pix3 of one
 159        iteration becomes pix2 in the next iteration. We can use this
 160        fact to avoid a potentially expensive unaligned read, as well
 161        as some splitting, and vector addition each time around the loop.
 162        Read unaligned pixels into our vectors. The vectors are as follows:
 163        pix2v: pix2[0]-pix2[15]  pix2iv: pix2[1]-pix2[16]
 164        Split the pixel vectors into shorts
 165     */
 166     tv = (vector unsigned char *) &pix2[0];
 167     pix2v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[0]));
 168
 169     tv = (vector unsigned char *) &pix2[1];
 170     pix2iv = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix2[1]));
 171
 172     pix2hv = (vector unsigned short) vec_mergeh(zero, pix2v);
 173     pix2lv = (vector unsigned short) vec_mergel(zero, pix2v);
 174     pix2ihv = (vector unsigned short) vec_mergeh(zero, pix2iv);
 175     pix2ilv = (vector unsigned short) vec_mergel(zero, pix2iv);
 176     t1 = vec_add(pix2hv, pix2ihv);
 177     t2 = vec_add(pix2lv, pix2ilv);
 178
 179     for(i=0;i<h;i++) {
 180         /*
 181            Read unaligned pixels into our vectors. The vectors are as follows:
 182            pix1v: pix1[0]-pix1[15]
 183            pix3v: pix3[0]-pix3[15]      pix3iv: pix3[1]-pix3[16]
 184         */
 185         tv = (vector unsigned char *) pix1;
 186         pix1v = vec_perm(tv[0], tv[1], vec_lvsl(0, pix1));
 187
 188         tv = (vector unsigned char *) &pix3[0];
 189         pix3v = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix3[0]));
 190
 191         tv = (vector unsigned char *) &pix3[1];
 192         pix3iv = vec_perm(tv[0], tv[1], vec_lvsl(0, &pix3[1]));
 193
 194         /*
 195           Note that AltiVec does have vec_avg, but this works on vector pairs
 196           and rounds up. We could do avg(avg(a,b),avg(c,d)), but the rounding
 197           would mean that, for example, avg(3,0,0,1) = 2, when it should be 1.
 198           Instead, we have to split the pixel vectors into vectors of shorts,
 199           and do the averaging by hand.
 200         */
 201
 202         /* Split the pixel vectors into shorts */
 203         pix3hv = (vector unsigned short) vec_mergeh(zero, pix3v);
 204         pix3lv = (vector unsigned short) vec_mergel(zero, pix3v);
 205         pix3ihv = (vector unsigned short) vec_mergeh(zero, pix3iv);
 206         pix3ilv = (vector unsigned short) vec_mergel(zero, pix3iv);
 207
 208         /* Do the averaging on them */
 209         t3 = vec_add(pix3hv, pix3ihv);
 210         t4 = vec_add(pix3lv, pix3ilv);
 211
 212         avghv = vec_sr(vec_add(vec_add(t1, t3), two), two);
 213         avglv = vec_sr(vec_add(vec_add(t2, t4), two), two);
 214
 215         /* Pack the shorts back into a result */
 216         avgv = vec_pack(avghv, avglv);
 217
 218         /* Calculate a sum of abs differences vector */
 219         t5 = vec_sub(vec_max(pix1v, avgv), vec_min(pix1v, avgv));
 220
 221         /* Add each 4 pixel group together and put 4 results into sad */
 222         sad = vec_sum4s(t5, sad);
 223
 224         pix1 += line_size;
 225         pix3 += line_size;
 226         /* Transfer the calculated values for pix3 into pix2 */
 227         t1 = t3;
 228         t2 = t4;
 229     }
 230     /* Sum up the four partial sums, and put the result into s */
 231     sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero);
 232     sumdiffs = vec_splat(sumdiffs, 3);
 233     vec_ste(sumdiffs, 0, &s);
 234
 235     return s;
 236 }
 237
 238 int sad16_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
 239 {
 240     int i;
 241     DECLARE_ALIGNED_16(int, s);
 242     const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0);
 243     vector unsigned char perm1, perm2, *pix1v, *pix2v;
 244     vector unsigned char t1, t2, t3,t4, t5;
 245     vector unsigned int sad;
 246     vector signed int sumdiffs;
 247
 248     sad = (vector unsigned int)vec_splat_u32(0);
 249
 250
 251     for(i=0;i<h;i++) {
 252         /* Read potentially unaligned pixels into t1 and t2 */
 253         perm1 = vec_lvsl(0, pix1);
 254         pix1v = (vector unsigned char *) pix1;
 255         perm2 = vec_lvsl(0, pix2);
 256         pix2v = (vector unsigned char *) pix2;
 257         t1 = vec_perm(pix1v[0], pix1v[1], perm1);
 258         t2 = vec_perm(pix2v[0], pix2v[1], perm2);
 259
 260         /* Calculate a sum of abs differences vector */
 261         t3 = vec_max(t1, t2);
 262         t4 = vec_min(t1, t2);
 263         t5 = vec_sub(t3, t4);
 264
 265         /* Add each 4 pixel group together and put 4 results into sad */
 266         sad = vec_sum4s(t5, sad);
 267
 268         pix1 += line_size;
 269         pix2 += line_size;
 270     }
 271
 272     /* Sum up the four partial sums, and put the result into s */
 273     sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero);
 274     sumdiffs = vec_splat(sumdiffs, 3);
 275     vec_ste(sumdiffs, 0, &s);
 276
 277     return s;
 278 }
 279
 280 int sad8_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
 281 {
 282     int i;
 283     DECLARE_ALIGNED_16(int, s);
 284     const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0);
 285     vector unsigned char perm1, perm2, permclear, *pix1v, *pix2v;
 286     vector unsigned char t1, t2, t3,t4, t5;
 287     vector unsigned int sad;
 288     vector signed int sumdiffs;
 289
 290     sad = (vector unsigned int)vec_splat_u32(0);
 291
 292     permclear = (vector unsigned char)AVV(255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0);
 293
 294     for(i=0;i<h;i++) {
 295         /* Read potentially unaligned pixels into t1 and t2
 296            Since we're reading 16 pixels, and actually only want 8,
 297            mask out the last 8 pixels. The 0s don't change the sum. */
 298         perm1 = vec_lvsl(0, pix1);
 299         pix1v = (vector unsigned char *) pix1;
 300         perm2 = vec_lvsl(0, pix2);
 301         pix2v = (vector unsigned char *) pix2;
 302         t1 = vec_and(vec_perm(pix1v[0], pix1v[1], perm1), permclear);
 303         t2 = vec_and(vec_perm(pix2v[0], pix2v[1], perm2), permclear);
 304
 305         /* Calculate a sum of abs differences vector */
 306         t3 = vec_max(t1, t2);
 307         t4 = vec_min(t1, t2);
 308         t5 = vec_sub(t3, t4);
 309
 310         /* Add each 4 pixel group together and put 4 results into sad */
 311         sad = vec_sum4s(t5, sad);
 312
 313         pix1 += line_size;
 314         pix2 += line_size;
 315     }
 316
 317     /* Sum up the four partial sums, and put the result into s */
 318     sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero);
 319     sumdiffs = vec_splat(sumdiffs, 3);
 320     vec_ste(sumdiffs, 0, &s);
 321
 322     return s;
 323 }
 324
 325 int pix_norm1_altivec(uint8_t *pix, int line_size)
 326 {
 327     int i;
 328     DECLARE_ALIGNED_16(int, s);
 329     const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0);
 330     vector unsigned char *tv;
 331     vector unsigned char pixv;
 332     vector unsigned int sv;
 333     vector signed int sum;
 334
 335     sv = (vector unsigned int)vec_splat_u32(0);
 336
 337     s = 0;
 338     for (i = 0; i < 16; i++) {
 339         /* Read in the potentially unaligned pixels */
 340         tv = (vector unsigned char *) pix;
 341         pixv = vec_perm(tv[0], tv[1], vec_lvsl(0, pix));
 342
 343         /* Square the values, and add them to our sum */
 344         sv = vec_msum(pixv, pixv, sv);
 345
 346         pix += line_size;
 347     }
 348     /* Sum up the four partial sums, and put the result into s */
 349     sum = vec_sums((vector signed int) sv, (vector signed int) zero);
 350     sum = vec_splat(sum, 3);
 351     vec_ste(sum, 0, &s);
 352
 353     return s;
 354 }
 355
 356 /**
 357  * Sum of Squared Errors for a 8x8 block.
 358  * AltiVec-enhanced.
 359  * It's the sad8_altivec code above w/ squaring added.
 360  */
 361 int sse8_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
 362 {
 363     int i;
 364     DECLARE_ALIGNED_16(int, s);
 365     const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0);
 366     vector unsigned char perm1, perm2, permclear, *pix1v, *pix2v;
 367     vector unsigned char t1, t2, t3,t4, t5;
 368     vector unsigned int sum;
 369     vector signed int sumsqr;
 370
 371     sum = (vector unsigned int)vec_splat_u32(0);
 372
 373     permclear = (vector unsigned char)AVV(255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0);
 374
 375
 376     for(i=0;i<h;i++) {
 377         /* Read potentially unaligned pixels into t1 and t2
 378            Since we're reading 16 pixels, and actually only want 8,
 379            mask out the last 8 pixels. The 0s don't change the sum. */
 380         perm1 = vec_lvsl(0, pix1);
 381         pix1v = (vector unsigned char *) pix1;
 382         perm2 = vec_lvsl(0, pix2);
 383         pix2v = (vector unsigned char *) pix2;
 384         t1 = vec_and(vec_perm(pix1v[0], pix1v[1], perm1), permclear);
 385         t2 = vec_and(vec_perm(pix2v[0], pix2v[1], perm2), permclear);
 386
 387         /*
 388           Since we want to use unsigned chars, we can take advantage
 389           of the fact that abs(a-b)^2 = (a-b)^2.
 390         */
 391
 392         /* Calculate abs differences vector */
 393         t3 = vec_max(t1, t2);
 394         t4 = vec_min(t1, t2);
 395         t5 = vec_sub(t3, t4);
 396
 397         /* Square the values and add them to our sum */
 398         sum = vec_msum(t5, t5, sum);
 399
 400         pix1 += line_size;
 401         pix2 += line_size;
 402     }
 403
 404     /* Sum up the four partial sums, and put the result into s */
 405     sumsqr = vec_sums((vector signed int) sum, (vector signed int) zero);
 406     sumsqr = vec_splat(sumsqr, 3);
 407     vec_ste(sumsqr, 0, &s);
 408
 409     return s;
 410 }
 411
 412 /**
 413  * Sum of Squared Errors for a 16x16 block.
 414  * AltiVec-enhanced.
 415  * It's the sad16_altivec code above w/ squaring added.
 416  */
 417 int sse16_altivec(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
 418 {
 419     int i;
 420     DECLARE_ALIGNED_16(int, s);
 421     const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0);
 422     vector unsigned char perm1, perm2, *pix1v, *pix2v;
 423     vector unsigned char t1, t2, t3,t4, t5;
 424     vector unsigned int sum;
 425     vector signed int sumsqr;
 426
 427     sum = (vector unsigned int)vec_splat_u32(0);
 428
 429     for(i=0;i<h;i++) {
 430         /* Read potentially unaligned pixels into t1 and t2 */
 431         perm1 = vec_lvsl(0, pix1);
 432         pix1v = (vector unsigned char *) pix1;
 433         perm2 = vec_lvsl(0, pix2);
 434         pix2v = (vector unsigned char *) pix2;
 435         t1 = vec_perm(pix1v[0], pix1v[1], perm1);
 436         t2 = vec_perm(pix2v[0], pix2v[1], perm2);
 437
 438         /*
 439           Since we want to use unsigned chars, we can take advantage
 440           of the fact that abs(a-b)^2 = (a-b)^2.
 441         */
 442
 443         /* Calculate abs differences vector */
 444         t3 = vec_max(t1, t2);
 445         t4 = vec_min(t1, t2);
 446         t5 = vec_sub(t3, t4);
 447
 448         /* Square the values and add them to our sum */
 449         sum = vec_msum(t5, t5, sum);
 450
 451         pix1 += line_size;
 452         pix2 += line_size;
 453     }
 454
 455     /* Sum up the four partial sums, and put the result into s */
 456     sumsqr = vec_sums((vector signed int) sum, (vector signed int) zero);
 457     sumsqr = vec_splat(sumsqr, 3);
 458     vec_ste(sumsqr, 0, &s);
 459
 460     return s;
 461 }
 462
 463 int pix_sum_altivec(uint8_t * pix, int line_size)
 464 {
 465     const vector unsigned int zero = (const vector unsigned int)vec_splat_u32(0);
 466     vector unsigned char perm, *pixv;
 467     vector unsigned char t1;
 468     vector unsigned int sad;
 469     vector signed int sumdiffs;
 470
 471     int i;
 472     DECLARE_ALIGNED_16(int, s);
 473
 474     sad = (vector unsigned int)vec_splat_u32(0);
 475
 476     for (i = 0; i < 16; i++) {
 477         /* Read the potentially unaligned 16 pixels into t1 */
 478         perm = vec_lvsl(0, pix);
 479         pixv = (vector unsigned char *) pix;
 480         t1 = vec_perm(pixv[0], pixv[1], perm);
 481
 482         /* Add each 4 pixel group together and put 4 results into sad */
 483         sad = vec_sum4s(t1, sad);
 484
 485         pix += line_size;
 486     }
 487
 488     /* Sum up the four partial sums, and put the result into s */
 489     sumdiffs = vec_sums((vector signed int) sad, (vector signed int) zero);
 490     sumdiffs = vec_splat(sumdiffs, 3);
 491     vec_ste(sumdiffs, 0, &s);
 492
 493     return s;
 494 }
 495
 496 void get_pixels_altivec(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
 497 {
 498     int i;
 499     vector unsigned char perm, bytes, *pixv;
 500     const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0);
 501     vector signed short shorts;
 502
 503     for(i=0;i<8;i++)
 504     {
 505         // Read potentially unaligned pixels.
 506         // We're reading 16 pixels, and actually only want 8,
 507         // but we simply ignore the extras.
 508         perm = vec_lvsl(0, pixels);
 509         pixv = (vector unsigned char *) pixels;
 510         bytes = vec_perm(pixv[0], pixv[1], perm);
 511
 512         // convert the bytes into shorts
 513         shorts = (vector signed short)vec_mergeh(zero, bytes);
 514
 515         // save the data to the block, we assume the block is 16-byte aligned
 516         vec_st(shorts, i*16, (vector signed short*)block);
 517
 518         pixels += line_size;
 519     }
 520 }
 521
 522 void diff_pixels_altivec(DCTELEM *restrict block, const uint8_t *s1,
 523         const uint8_t *s2, int stride)
 524 {
 525     int i;
 526     vector unsigned char perm, bytes, *pixv;
 527     const vector unsigned char zero = (const vector unsigned char)vec_splat_u8(0);
 528     vector signed short shorts1, shorts2;
 529
 530     for(i=0;i<4;i++)
 531     {
 532         // Read potentially unaligned pixels
 533         // We're reading 16 pixels, and actually only want 8,
 534         // but we simply ignore the extras.
 535         perm = vec_lvsl(0, s1);
 536         pixv = (vector unsigned char *) s1;
 537         bytes = vec_perm(pixv[0], pixv[1], perm);
 538
 539         // convert the bytes into shorts
 540         shorts1 = (vector signed short)vec_mergeh(zero, bytes);
 541
 542         // Do the same for the second block of pixels
 543         perm = vec_lvsl(0, s2);
 544         pixv = (vector unsigned char *) s2;
 545         bytes = vec_perm(pixv[0], pixv[1], perm);
 546
 547         // convert the bytes into shorts
 548         shorts2 = (vector signed short)vec_mergeh(zero, bytes);
 549
 550         // Do the subtraction
 551         shorts1 = vec_sub(shorts1, shorts2);
 552
 553         // save the data to the block, we assume the block is 16-byte aligned
 554         vec_st(shorts1, 0, (vector signed short*)block);
 555
 556         s1 += stride;
 557         s2 += stride;
 558         block += 8;
 559
 560
 561         // The code below is a copy of the code above... This is a manual
 562         // unroll.
 563
 564         // Read potentially unaligned pixels
 565         // We're reading 16 pixels, and actually only want 8,
 566         // but we simply ignore the extras.
 567         perm = vec_lvsl(0, s1);
 568         pixv = (vector unsigned char *) s1;
 569         bytes = vec_perm(pixv[0], pixv[1], perm);
 570
 571         // convert the bytes into shorts
 572         shorts1 = (vector signed short)vec_mergeh(zero, bytes);
 573
 574         // Do the same for the second block of pixels
 575         perm = vec_lvsl(0, s2);
 576         pixv = (vector unsigned char *) s2;
 577         bytes = vec_perm(pixv[0], pixv[1], perm);
 578
 579         // convert the bytes into shorts
 580         shorts2 = (vector signed short)vec_mergeh(zero, bytes);
 581
 582         // Do the subtraction
 583         shorts1 = vec_sub(shorts1, shorts2);
 584
 585         // save the data to the block, we assume the block is 16-byte aligned
 586         vec_st(shorts1, 0, (vector signed short*)block);
 587
 588         s1 += stride;
 589         s2 += stride;
 590         block += 8;
 591     }
 592 }
 593
 594 void add_bytes_altivec(uint8_t *dst, uint8_t *src, int w) {
 595     register int i;
 596     register vector unsigned char vdst, vsrc;
 597
 598     /* dst and src are 16 bytes-aligned (guaranteed) */
 599     for(i = 0 ; (i + 15) < w ; i+=16)
 600     {
 601       vdst = vec_ld(i, (unsigned char*)dst);
 602       vsrc = vec_ld(i, (unsigned char*)src);
 603       vdst = vec_add(vsrc, vdst);
 604       vec_st(vdst, i, (unsigned char*)dst);
 605     }
 606     /* if w is not a multiple of 16 */
 607     for (; (i < w) ; i++)
 608     {
 609       dst[i] = src[i];
 610     }
 611 }
 612
 613 /* next one assumes that ((line_size % 16) == 0) */
 614 void put_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 615 {
 616 POWERPC_PERF_DECLARE(altivec_put_pixels16_num, 1);
 617     register vector unsigned char pixelsv1, pixelsv2;
 618     register vector unsigned char pixelsv1B, pixelsv2B;
 619     register vector unsigned char pixelsv1C, pixelsv2C;
 620     register vector unsigned char pixelsv1D, pixelsv2D;
 621
 622     register vector unsigned char perm = vec_lvsl(0, pixels);
 623     int i;
 624     register int line_size_2 = line_size << 1;
 625     register int line_size_3 = line_size + line_size_2;
 626     register int line_size_4 = line_size << 2;
 627
 628 POWERPC_PERF_START_COUNT(altivec_put_pixels16_num, 1);
 629 // hand-unrolling the loop by 4 gains about 15%
 630 // mininum execution time goes from 74 to 60 cycles
 631 // it's faster than -funroll-loops, but using
 632 // -funroll-loops w/ this is bad - 74 cycles again.
 633 // all this is on a 7450, tuning for the 7450
 634 #if 0
 635     for(i=0; i<h; i++) {
 636       pixelsv1 = vec_ld(0, (unsigned char*)pixels);
 637       pixelsv2 = vec_ld(16, (unsigned char*)pixels);
 638       vec_st(vec_perm(pixelsv1, pixelsv2, perm),
 639              0, (unsigned char*)block);
 640       pixels+=line_size;
 641       block +=line_size;
 642     }
 643 #else
 644     for(i=0; i<h; i+=4) {
 645       pixelsv1 = vec_ld(0, (unsigned char*)pixels);
 646       pixelsv2 = vec_ld(15, (unsigned char*)pixels);
 647       pixelsv1B = vec_ld(line_size, (unsigned char*)pixels);
 648       pixelsv2B = vec_ld(15 + line_size, (unsigned char*)pixels);
 649       pixelsv1C = vec_ld(line_size_2, (unsigned char*)pixels);
 650       pixelsv2C = vec_ld(15 + line_size_2, (unsigned char*)pixels);
 651       pixelsv1D = vec_ld(line_size_3, (unsigned char*)pixels);
 652       pixelsv2D = vec_ld(15 + line_size_3, (unsigned char*)pixels);
 653       vec_st(vec_perm(pixelsv1, pixelsv2, perm),
 654              0, (unsigned char*)block);
 655       vec_st(vec_perm(pixelsv1B, pixelsv2B, perm),
 656              line_size, (unsigned char*)block);
 657       vec_st(vec_perm(pixelsv1C, pixelsv2C, perm),
 658              line_size_2, (unsigned char*)block);
 659       vec_st(vec_perm(pixelsv1D, pixelsv2D, perm),
 660              line_size_3, (unsigned char*)block);
 661       pixels+=line_size_4;
 662       block +=line_size_4;
 663     }
 664 #endif
 665 POWERPC_PERF_STOP_COUNT(altivec_put_pixels16_num, 1);
 666 }
 667
 668 /* next one assumes that ((line_size % 16) == 0) */
 669 #define op_avg(a,b)  a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEUL)>>1) )
 670 void avg_pixels16_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 671 {
 672 POWERPC_PERF_DECLARE(altivec_avg_pixels16_num, 1);
 673     register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv;
 674     register vector unsigned char perm = vec_lvsl(0, pixels);
 675     int i;
 676
 677 POWERPC_PERF_START_COUNT(altivec_avg_pixels16_num, 1);
 678
 679     for(i=0; i<h; i++) {
 680       pixelsv1 = vec_ld(0, (unsigned char*)pixels);
 681       pixelsv2 = vec_ld(16, (unsigned char*)pixels);
 682       blockv = vec_ld(0, block);
 683       pixelsv = vec_perm(pixelsv1, pixelsv2, perm);
 684       blockv = vec_avg(blockv,pixelsv);
 685       vec_st(blockv, 0, (unsigned char*)block);
 686       pixels+=line_size;
 687       block +=line_size;
 688     }
 689
 690 POWERPC_PERF_STOP_COUNT(altivec_avg_pixels16_num, 1);
 691 }
 692
 693 /* next one assumes that ((line_size % 8) == 0) */
 694 void avg_pixels8_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h)
 695 {
 696 POWERPC_PERF_DECLARE(altivec_avg_pixels8_num, 1);
 697     register vector unsigned char pixelsv1, pixelsv2, pixelsv, blockv;
 698     int i;
 699
 700 POWERPC_PERF_START_COUNT(altivec_avg_pixels8_num, 1);
 701
 702    for (i = 0; i < h; i++) {
 703      /*
 704        block is 8 bytes-aligned, so we're either in the
 705        left block (16 bytes-aligned) or in the right block (not)
 706      */
 707      int rightside = ((unsigned long)block & 0x0000000F);
 708
 709      blockv = vec_ld(0, block);
 710      pixelsv1 = vec_ld(0, (unsigned char*)pixels);
 711      pixelsv2 = vec_ld(16, (unsigned char*)pixels);
 712      pixelsv = vec_perm(pixelsv1, pixelsv2, vec_lvsl(0, pixels));
 713
 714      if (rightside)
 715      {
 716        pixelsv = vec_perm(blockv, pixelsv, vcprm(0,1,s0,s1));
 717      }
 718      else
 719      {
 720        pixelsv = vec_perm(blockv, pixelsv, vcprm(s0,s1,2,3));
 721      }
 722
 723      blockv = vec_avg(blockv, pixelsv);
 724
 725      vec_st(blockv, 0, block);
 726
 727      pixels += line_size;
 728      block += line_size;
 729    }
 730
 731 POWERPC_PERF_STOP_COUNT(altivec_avg_pixels8_num, 1);
 732 }
 733
 734 /* next one assumes that ((line_size % 8) == 0) */
 735 void put_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 736 {
 737 POWERPC_PERF_DECLARE(altivec_put_pixels8_xy2_num, 1);
 738    register int i;
 739    register vector unsigned char
 740      pixelsv1, pixelsv2,
 741      pixelsavg;
 742    register vector unsigned char
 743      blockv, temp1, temp2;
 744    register vector unsigned short
 745      pixelssum1, pixelssum2, temp3;
 746    register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);
 747    register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);
 748
 749    temp1 = vec_ld(0, pixels);
 750    temp2 = vec_ld(16, pixels);
 751    pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));
 752    if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F)
 753    {
 754      pixelsv2 = temp2;
 755    }
 756    else
 757    {
 758      pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));
 759    }
 760    pixelsv1 = vec_mergeh(vczero, pixelsv1);
 761    pixelsv2 = vec_mergeh(vczero, pixelsv2);
 762    pixelssum1 = vec_add((vector unsigned short)pixelsv1,
 763                         (vector unsigned short)pixelsv2);
 764    pixelssum1 = vec_add(pixelssum1, vctwo);
 765
 766 POWERPC_PERF_START_COUNT(altivec_put_pixels8_xy2_num, 1);
 767    for (i = 0; i < h ; i++) {
 768      int rightside = ((unsigned long)block & 0x0000000F);
 769      blockv = vec_ld(0, block);
 770
 771      temp1 = vec_ld(line_size, pixels);
 772      temp2 = vec_ld(line_size + 16, pixels);
 773      pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));
 774      if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F)
 775      {
 776        pixelsv2 = temp2;
 777      }
 778      else
 779      {
 780        pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));
 781      }
 782
 783      pixelsv1 = vec_mergeh(vczero, pixelsv1);
 784      pixelsv2 = vec_mergeh(vczero, pixelsv2);
 785      pixelssum2 = vec_add((vector unsigned short)pixelsv1,
 786                           (vector unsigned short)pixelsv2);
 787      temp3 = vec_add(pixelssum1, pixelssum2);
 788      temp3 = vec_sra(temp3, vctwo);
 789      pixelssum1 = vec_add(pixelssum2, vctwo);
 790      pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero);
 791
 792      if (rightside)
 793      {
 794        blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1));
 795      }
 796      else
 797      {
 798        blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3));
 799      }
 800
 801      vec_st(blockv, 0, block);
 802
 803      block += line_size;
 804      pixels += line_size;
 805    }
 806
 807 POWERPC_PERF_STOP_COUNT(altivec_put_pixels8_xy2_num, 1);
 808 }
 809
 810 /* next one assumes that ((line_size % 8) == 0) */
 811 void put_no_rnd_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
 812 {
 813 POWERPC_PERF_DECLARE(altivec_put_no_rnd_pixels8_xy2_num, 1);
 814    register int i;
 815    register vector unsigned char
 816      pixelsv1, pixelsv2,
 817      pixelsavg;
 818    register vector unsigned char
 819      blockv, temp1, temp2;
 820    register vector unsigned short
 821      pixelssum1, pixelssum2, temp3;
 822    register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);
 823    register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1);
 824    register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);
 825
 826    temp1 = vec_ld(0, pixels);
 827    temp2 = vec_ld(16, pixels);
 828    pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));
 829    if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F)
 830    {
 831      pixelsv2 = temp2;
 832    }
 833    else
 834    {
 835      pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));
 836    }
 837    pixelsv1 = vec_mergeh(vczero, pixelsv1);
 838    pixelsv2 = vec_mergeh(vczero, pixelsv2);
 839    pixelssum1 = vec_add((vector unsigned short)pixelsv1,
 840                         (vector unsigned short)pixelsv2);
 841    pixelssum1 = vec_add(pixelssum1, vcone);
 842
 843 POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1);
 844    for (i = 0; i < h ; i++) {
 845      int rightside = ((unsigned long)block & 0x0000000F);
 846      blockv = vec_ld(0, block);
 847
 848      temp1 = vec_ld(line_size, pixels);
 849      temp2 = vec_ld(line_size + 16, pixels);
 850      pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));
 851      if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F)
 852      {
 853        pixelsv2 = temp2;
 854      }
 855      else
 856      {
 857        pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));
 858      }
 859
 860      pixelsv1 = vec_mergeh(vczero, pixelsv1);
 861      pixelsv2 = vec_mergeh(vczero, pixelsv2);
 862      pixelssum2 = vec_add((vector unsigned short)pixelsv1,
 863                           (vector unsigned short)pixelsv2);
 864      temp3 = vec_add(pixelssum1, pixelssum2);
 865      temp3 = vec_sra(temp3, vctwo);
 866      pixelssum1 = vec_add(pixelssum2, vcone);
 867      pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero);
 868
 869      if (rightside)
 870      {
 871        blockv = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1));
 872      }
 873      else
 874      {
 875        blockv = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3));
 876      }
 877
 878      vec_st(blockv, 0, block);
 879
 880      block += line_size;
 881      pixels += line_size;
 882    }
 883
 884 POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels8_xy2_num, 1);
 885 }
 886
 887 /* next one assumes that ((line_size % 16) == 0) */
 888 void put_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h)
 889 {
 890 POWERPC_PERF_DECLARE(altivec_put_pixels16_xy2_num, 1);
 891    register int i;
 892    register vector unsigned char
 893      pixelsv1, pixelsv2, pixelsv3, pixelsv4;
 894    register vector unsigned char
 895      blockv, temp1, temp2;
 896    register vector unsigned short
 897      pixelssum1, pixelssum2, temp3,
 898      pixelssum3, pixelssum4, temp4;
 899    register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);
 900    register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);
 901
 902 POWERPC_PERF_START_COUNT(altivec_put_pixels16_xy2_num, 1);
 903
 904    temp1 = vec_ld(0, pixels);
 905    temp2 = vec_ld(16, pixels);
 906    pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));
 907    if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F)
 908    {
 909      pixelsv2 = temp2;
 910    }
 911    else
 912    {
 913      pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));
 914    }
 915    pixelsv3 = vec_mergel(vczero, pixelsv1);
 916    pixelsv4 = vec_mergel(vczero, pixelsv2);
 917    pixelsv1 = vec_mergeh(vczero, pixelsv1);
 918    pixelsv2 = vec_mergeh(vczero, pixelsv2);
 919    pixelssum3 = vec_add((vector unsigned short)pixelsv3,
 920                         (vector unsigned short)pixelsv4);
 921    pixelssum3 = vec_add(pixelssum3, vctwo);
 922    pixelssum1 = vec_add((vector unsigned short)pixelsv1,
 923                         (vector unsigned short)pixelsv2);
 924    pixelssum1 = vec_add(pixelssum1, vctwo);
 925
 926    for (i = 0; i < h ; i++) {
 927      blockv = vec_ld(0, block);
 928
 929      temp1 = vec_ld(line_size, pixels);
 930      temp2 = vec_ld(line_size + 16, pixels);
 931      pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));
 932      if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F)
 933      {
 934        pixelsv2 = temp2;
 935      }
 936      else
 937      {
 938        pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));
 939      }
 940
 941      pixelsv3 = vec_mergel(vczero, pixelsv1);
 942      pixelsv4 = vec_mergel(vczero, pixelsv2);
 943      pixelsv1 = vec_mergeh(vczero, pixelsv1);
 944      pixelsv2 = vec_mergeh(vczero, pixelsv2);
 945
 946      pixelssum4 = vec_add((vector unsigned short)pixelsv3,
 947                           (vector unsigned short)pixelsv4);
 948      pixelssum2 = vec_add((vector unsigned short)pixelsv1,
 949                           (vector unsigned short)pixelsv2);
 950      temp4 = vec_add(pixelssum3, pixelssum4);
 951      temp4 = vec_sra(temp4, vctwo);
 952      temp3 = vec_add(pixelssum1, pixelssum2);
 953      temp3 = vec_sra(temp3, vctwo);
 954
 955      pixelssum3 = vec_add(pixelssum4, vctwo);
 956      pixelssum1 = vec_add(pixelssum2, vctwo);
 957
 958      blockv = vec_packsu(temp3, temp4);
 959
 960      vec_st(blockv, 0, block);
 961
 962      block += line_size;
 963      pixels += line_size;
 964    }
 965
 966 POWERPC_PERF_STOP_COUNT(altivec_put_pixels16_xy2_num, 1);
 967 }
 968
 969 /* next one assumes that ((line_size % 16) == 0) */
 970 void put_no_rnd_pixels16_xy2_altivec(uint8_t * block, const uint8_t * pixels, int line_size, int h)
 971 {
 972 POWERPC_PERF_DECLARE(altivec_put_no_rnd_pixels16_xy2_num, 1);
 973    register int i;
 974    register vector unsigned char
 975      pixelsv1, pixelsv2, pixelsv3, pixelsv4;
 976    register vector unsigned char
 977      blockv, temp1, temp2;
 978    register vector unsigned short
 979      pixelssum1, pixelssum2, temp3,
 980      pixelssum3, pixelssum4, temp4;
 981    register const vector unsigned char vczero = (const vector unsigned char)vec_splat_u8(0);
 982    register const vector unsigned short vcone = (const vector unsigned short)vec_splat_u16(1);
 983    register const vector unsigned short vctwo = (const vector unsigned short)vec_splat_u16(2);
 984
 985 POWERPC_PERF_START_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1);
 986
 987    temp1 = vec_ld(0, pixels);
 988    temp2 = vec_ld(16, pixels);
 989    pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));
 990    if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F)
 991    {
 992      pixelsv2 = temp2;
 993    }
 994    else
 995    {
 996      pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));
 997    }
 998    pixelsv3 = vec_mergel(vczero, pixelsv1);
 999    pixelsv4 = vec_mergel(vczero, pixelsv2);
1000    pixelsv1 = vec_mergeh(vczero, pixelsv1);
1001    pixelsv2 = vec_mergeh(vczero, pixelsv2);
1002    pixelssum3 = vec_add((vector unsigned short)pixelsv3,
1003                         (vector unsigned short)pixelsv4);
1004    pixelssum3 = vec_add(pixelssum3, vcone);
1005    pixelssum1 = vec_add((vector unsigned short)pixelsv1,
1006                         (vector unsigned short)pixelsv2);
1007    pixelssum1 = vec_add(pixelssum1, vcone);
1008
1009    for (i = 0; i < h ; i++) {
1010      blockv = vec_ld(0, block);
1011
1012      temp1 = vec_ld(line_size, pixels);
1013      temp2 = vec_ld(line_size + 16, pixels);
1014      pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));
1015      if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F)
1016      {
1017        pixelsv2 = temp2;
1018      }
1019      else
1020      {
1021        pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));
1022      }
1023
1024      pixelsv3 = vec_mergel(vczero, pixelsv1);
1025      pixelsv4 = vec_mergel(vczero, pixelsv2);
1026      pixelsv1 = vec_mergeh(vczero, pixelsv1);
1027      pixelsv2 = vec_mergeh(vczero, pixelsv2);
1028
1029      pixelssum4 = vec_add((vector unsigned short)pixelsv3,
1030                           (vector unsigned short)pixelsv4);
1031      pixelssum2 = vec_add((vector unsigned short)pixelsv1,
1032                           (vector unsigned short)pixelsv2);
1033      temp4 = vec_add(pixelssum3, pixelssum4);
1034      temp4 = vec_sra(temp4, vctwo);
1035      temp3 = vec_add(pixelssum1, pixelssum2);
1036      temp3 = vec_sra(temp3, vctwo);
1037
1038      pixelssum3 = vec_add(pixelssum4, vcone);
1039      pixelssum1 = vec_add(pixelssum2, vcone);
1040
1041      blockv = vec_packsu(temp3, temp4);
1042
1043      vec_st(blockv, 0, block);
1044
1045      block += line_size;
1046      pixels += line_size;
1047    }
1048
1049 POWERPC_PERF_STOP_COUNT(altivec_put_no_rnd_pixels16_xy2_num, 1);
1050 }
1051
1052 int hadamard8_diff8x8_altivec(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
1053 POWERPC_PERF_DECLARE(altivec_hadamard8_diff8x8_num, 1);
1054     int sum;
1055     register const vector unsigned char vzero =
1056                             (const vector unsigned char)vec_splat_u8(0);
1057     register vector signed short temp0, temp1, temp2, temp3, temp4,
1058                                  temp5, temp6, temp7;
1059 POWERPC_PERF_START_COUNT(altivec_hadamard8_diff8x8_num, 1);
1060   {
1061     register const vector signed short vprod1 =(const vector signed short)
1062                                         AVV( 1,-1, 1,-1, 1,-1, 1,-1);
1063     register const vector signed short vprod2 =(const vector signed short)
1064                                         AVV( 1, 1,-1,-1, 1, 1,-1,-1);
1065     register const vector signed short vprod3 =(const vector signed short)
1066                                         AVV( 1, 1, 1, 1,-1,-1,-1,-1);
1067     register const vector unsigned char perm1 = (const vector unsigned char)
1068       AVV(0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
1069           0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D);
1070     register const vector unsigned char perm2 = (const vector unsigned char)
1071       AVV(0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03,
1072           0x0C, 0x0D, 0x0E, 0x0F, 0x08, 0x09, 0x0A, 0x0B);
1073     register const vector unsigned char perm3 = (const vector unsigned char)
1074       AVV(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
1075           0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
1076
1077 #define ONEITERBUTTERFLY(i, res)                                        \
1078     {                                                                   \
1079       register vector unsigned char src1, src2, srcO;                   \
1080       register vector unsigned char dst1, dst2, dstO;                   \
1081       register vector signed short srcV, dstV;                          \
1082       register vector signed short but0, but1, but2, op1, op2, op3;     \
1083       src1 = vec_ld(stride * i, src);                                   \
1084       src2 = vec_ld((stride * i) + 15, src);                            \
1085       srcO = vec_perm(src1, src2, vec_lvsl(stride * i, src));           \
1086       dst1 = vec_ld(stride * i, dst);                                   \
1087       dst2 = vec_ld((stride * i) + 15, dst);                            \
1088       dstO = vec_perm(dst1, dst2, vec_lvsl(stride * i, dst));           \
1089       /* promote the unsigned chars to signed shorts */                 \
1090       /* we're in the 8x8 function, we only care for the first 8 */     \
1091       srcV =                                                            \
1092         (vector signed short)vec_mergeh((vector signed char)vzero,      \
1093         (vector signed char)srcO);                                      \
1094       dstV =                                                            \
1095         (vector signed short)vec_mergeh((vector signed char)vzero,      \
1096         (vector signed char)dstO);                                      \
1097       /* subtractions inside the first butterfly */                     \
1098       but0 = vec_sub(srcV, dstV);                                       \
1099       op1 = vec_perm(but0, but0, perm1);                                \
1100       but1 = vec_mladd(but0, vprod1, op1);                              \
1101       op2 = vec_perm(but1, but1, perm2);                                \
1102       but2 = vec_mladd(but1, vprod2, op2);                              \
1103       op3 = vec_perm(but2, but2, perm3);                                \
1104       res = vec_mladd(but2, vprod3, op3);                               \
1105     }
1106     ONEITERBUTTERFLY(0, temp0);
1107     ONEITERBUTTERFLY(1, temp1);
1108     ONEITERBUTTERFLY(2, temp2);
1109     ONEITERBUTTERFLY(3, temp3);
1110     ONEITERBUTTERFLY(4, temp4);
1111     ONEITERBUTTERFLY(5, temp5);
1112     ONEITERBUTTERFLY(6, temp6);
1113     ONEITERBUTTERFLY(7, temp7);
1114   }
1115 #undef ONEITERBUTTERFLY
1116   {
1117     register vector signed int vsum;
1118     register vector signed short line0 = vec_add(temp0, temp1);
1119     register vector signed short line1 = vec_sub(temp0, temp1);
1120     register vector signed short line2 = vec_add(temp2, temp3);
1121     register vector signed short line3 = vec_sub(temp2, temp3);
1122     register vector signed short line4 = vec_add(temp4, temp5);
1123     register vector signed short line5 = vec_sub(temp4, temp5);
1124     register vector signed short line6 = vec_add(temp6, temp7);
1125     register vector signed short line7 = vec_sub(temp6, temp7);
1126
1127     register vector signed short line0B = vec_add(line0, line2);
1128     register vector signed short line2B = vec_sub(line0, line2);
1129     register vector signed short line1B = vec_add(line1, line3);
1130     register vector signed short line3B = vec_sub(line1, line3);
1131     register vector signed short line4B = vec_add(line4, line6);
1132     register vector signed short line6B = vec_sub(line4, line6);
1133     register vector signed short line5B = vec_add(line5, line7);
1134     register vector signed short line7B = vec_sub(line5, line7);
1135
1136     register vector signed short line0C = vec_add(line0B, line4B);
1137     register vector signed short line4C = vec_sub(line0B, line4B);
1138     register vector signed short line1C = vec_add(line1B, line5B);
1139     register vector signed short line5C = vec_sub(line1B, line5B);
1140     register vector signed short line2C = vec_add(line2B, line6B);
1141     register vector signed short line6C = vec_sub(line2B, line6B);
1142     register vector signed short line3C = vec_add(line3B, line7B);
1143     register vector signed short line7C = vec_sub(line3B, line7B);
1144
1145     vsum = vec_sum4s(vec_abs(line0C), vec_splat_s32(0));
1146     vsum = vec_sum4s(vec_abs(line1C), vsum);
1147     vsum = vec_sum4s(vec_abs(line2C), vsum);
1148     vsum = vec_sum4s(vec_abs(line3C), vsum);
1149     vsum = vec_sum4s(vec_abs(line4C), vsum);
1150     vsum = vec_sum4s(vec_abs(line5C), vsum);
1151     vsum = vec_sum4s(vec_abs(line6C), vsum);
1152     vsum = vec_sum4s(vec_abs(line7C), vsum);
1153     vsum = vec_sums(vsum, (vector signed int)vzero);
1154     vsum = vec_splat(vsum, 3);
1155     vec_ste(vsum, 0, &sum);
1156   }
1157 POWERPC_PERF_STOP_COUNT(altivec_hadamard8_diff8x8_num, 1);
1158   return sum;
1159 }
1160
1161 /*
1162   16x8 works with 16 elements ; it allows to avoid replicating
1163   loads, and give the compiler more rooms for scheduling.
1164   It's only used from inside hadamard8_diff16_altivec.
1165
1166   Unfortunately, it seems gcc-3.3 is a bit dumb, and
1167   the compiled code has a LOT of spill code, it seems
1168   gcc (unlike xlc) cannot keep everything in registers
1169   by itself. The following code include hand-made
1170   registers allocation. It's not clean, but on
1171   a 7450 the resulting code is much faster (best case
1172   fall from 700+ cycles to 550).
1173
1174   xlc doesn't add spill code, but it doesn't know how to
1175   schedule for the 7450, and its code isn't much faster than
1176   gcc-3.3 on the 7450 (but uses 25% less instructions...)
1177
1178   On the 970, the hand-made RA is still a win (around 690
1179   vs. around 780), but xlc goes to around 660 on the
1180   regular C code...
1181 */
1182
1183 static int hadamard8_diff16x8_altivec(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h) {
1184     int sum;
1185     register vector signed short
1186         temp0 REG_v(v0),
1187         temp1 REG_v(v1),
1188         temp2 REG_v(v2),
1189         temp3 REG_v(v3),
1190         temp4 REG_v(v4),
1191         temp5 REG_v(v5),
1192         temp6 REG_v(v6),
1193         temp7 REG_v(v7);
1194     register vector signed short
1195         temp0S REG_v(v8),
1196         temp1S REG_v(v9),
1197         temp2S REG_v(v10),
1198         temp3S REG_v(v11),
1199         temp4S REG_v(v12),
1200         temp5S REG_v(v13),
1201         temp6S REG_v(v14),
1202         temp7S REG_v(v15);
1203     register const vector unsigned char vzero REG_v(v31)=
1204         (const vector unsigned char)vec_splat_u8(0);
1205   {
1206     register const vector signed short vprod1 REG_v(v16)=
1207         (const vector signed short)AVV( 1,-1, 1,-1, 1,-1, 1,-1);
1208     register const vector signed short vprod2 REG_v(v17)=
1209         (const vector signed short)AVV( 1, 1,-1,-1, 1, 1,-1,-1);
1210     register const vector signed short vprod3 REG_v(v18)=
1211         (const vector signed short)AVV( 1, 1, 1, 1,-1,-1,-1,-1);
1212     register const vector unsigned char perm1 REG_v(v19)=
1213         (const vector unsigned char)
1214         AVV(0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
1215             0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D);
1216     register const vector unsigned char perm2 REG_v(v20)=
1217         (const vector unsigned char)
1218         AVV(0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03,
1219             0x0C, 0x0D, 0x0E, 0x0F, 0x08, 0x09, 0x0A, 0x0B);
1220     register const vector unsigned char perm3 REG_v(v21)=
1221         (const vector unsigned char)
1222         AVV(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
1223             0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
1224
1225 #define ONEITERBUTTERFLY(i, res1, res2)                                 \
1226     {                                                                   \
1227       register vector unsigned char src1 REG_v(v22),                    \
1228                                     src2 REG_v(v23),                    \
1229                                     dst1 REG_v(v24),                    \
1230                                     dst2 REG_v(v25),                    \
1231                                     srcO REG_v(v22),                    \
1232                                     dstO REG_v(v23);                    \
1233                                                                         \
1234       register vector signed short  srcV REG_v(v24),                    \
1235                                     dstV REG_v(v25),                    \
1236                                     srcW REG_v(v26),                    \
1237                                     dstW REG_v(v27),                    \
1238                                     but0 REG_v(v28),                    \
1239                                     but0S REG_v(v29),                   \
1240                                     op1 REG_v(v30),                     \
1241                                     but1 REG_v(v22),                    \
1242                                     op1S REG_v(v23),                    \
1243                                     but1S REG_v(v24),                   \
1244                                     op2 REG_v(v25),                     \
1245                                     but2 REG_v(v26),                    \
1246                                     op2S REG_v(v27),                    \
1247                                     but2S REG_v(v28),                   \
1248                                     op3 REG_v(v29),                     \
1249                                     op3S REG_v(v30);                    \
1250                                                                         \
1251       src1 = vec_ld(stride * i, src);                                   \
1252       src2 = vec_ld((stride * i) + 16, src);                            \
1253       srcO = vec_perm(src1, src2, vec_lvsl(stride * i, src));           \
1254       dst1 = vec_ld(stride * i, dst);                                   \
1255       dst2 = vec_ld((stride * i) + 16, dst);                            \
1256       dstO = vec_perm(dst1, dst2, vec_lvsl(stride * i, dst));           \
1257       /* promote the unsigned chars to signed shorts */                 \
1258       srcV =                                                            \
1259         (vector signed short)vec_mergeh((vector signed char)vzero,      \
1260         (vector signed char)srcO);                                      \
1261       dstV =                                                            \
1262         (vector signed short)vec_mergeh((vector signed char)vzero,      \
1263         (vector signed char)dstO);                                      \
1264       srcW =                                                            \
1265         (vector signed short)vec_mergel((vector signed char)vzero,      \
1266         (vector signed char)srcO);                                      \
1267       dstW =                                                            \
1268         (vector signed short)vec_mergel((vector signed char)vzero,      \
1269         (vector signed char)dstO);                                      \
1270       /* subtractions inside the first butterfly */                     \
1271       but0 = vec_sub(srcV, dstV);                                       \
1272       but0S = vec_sub(srcW, dstW);                                      \
1273       op1 = vec_perm(but0, but0, perm1);                                \
1274       but1 = vec_mladd(but0, vprod1, op1);                              \
1275       op1S = vec_perm(but0S, but0S, perm1);                             \
1276       but1S = vec_mladd(but0S, vprod1, op1S);                           \
1277       op2 = vec_perm(but1, but1, perm2);                                \
1278       but2 = vec_mladd(but1, vprod2, op2);                              \
1279       op2S = vec_perm(but1S, but1S, perm2);                             \
1280       but2S = vec_mladd(but1S, vprod2, op2S);                           \
1281       op3 = vec_perm(but2, but2, perm3);                                \
1282       res1 = vec_mladd(but2, vprod3, op3);                              \
1283       op3S = vec_perm(but2S, but2S, perm3);                             \
1284       res2 = vec_mladd(but2S, vprod3, op3S);                            \
1285     }
1286     ONEITERBUTTERFLY(0, temp0, temp0S);
1287     ONEITERBUTTERFLY(1, temp1, temp1S);
1288     ONEITERBUTTERFLY(2, temp2, temp2S);
1289     ONEITERBUTTERFLY(3, temp3, temp3S);
1290     ONEITERBUTTERFLY(4, temp4, temp4S);
1291     ONEITERBUTTERFLY(5, temp5, temp5S);
1292     ONEITERBUTTERFLY(6, temp6, temp6S);
1293     ONEITERBUTTERFLY(7, temp7, temp7S);
1294   }
1295 #undef ONEITERBUTTERFLY
1296   {
1297     register vector signed int vsum;
1298     register vector signed short line0S, line1S, line2S, line3S, line4S,
1299                                  line5S, line6S, line7S, line0BS,line2BS,
1300                                  line1BS,line3BS,line4BS,line6BS,line5BS,
1301                                  line7BS,line0CS,line4CS,line1CS,line5CS,
1302                                  line2CS,line6CS,line3CS,line7CS;
1303
1304     register vector signed short line0 = vec_add(temp0, temp1);
1305     register vector signed short line1 = vec_sub(temp0, temp1);
1306     register vector signed short line2 = vec_add(temp2, temp3);
1307     register vector signed short line3 = vec_sub(temp2, temp3);
1308     register vector signed short line4 = vec_add(temp4, temp5);
1309     register vector signed short line5 = vec_sub(temp4, temp5);
1310     register vector signed short line6 = vec_add(temp6, temp7);
1311     register vector signed short line7 = vec_sub(temp6, temp7);
1312
1313     register vector signed short line0B = vec_add(line0, line2);
1314     register vector signed short line2B = vec_sub(line0, line2);
1315     register vector signed short line1B = vec_add(line1, line3);
1316     register vector signed short line3B = vec_sub(line1, line3);
1317     register vector signed short line4B = vec_add(line4, line6);
1318     register vector signed short line6B = vec_sub(line4, line6);
1319     register vector signed short line5B = vec_add(line5, line7);
1320     register vector signed short line7B = vec_sub(line5, line7);
1321
1322     register vector signed short line0C = vec_add(line0B, line4B);
1323     register vector signed short line4C = vec_sub(line0B, line4B);
1324     register vector signed short line1C = vec_add(line1B, line5B);
1325     register vector signed short line5C = vec_sub(line1B, line5B);
1326     register vector signed short line2C = vec_add(line2B, line6B);
1327     register vector signed short line6C = vec_sub(line2B, line6B);
1328     register vector signed short line3C = vec_add(line3B, line7B);
1329     register vector signed short line7C = vec_sub(line3B, line7B);
1330
1331     vsum = vec_sum4s(vec_abs(line0C), vec_splat_s32(0));
1332     vsum = vec_sum4s(vec_abs(line1C), vsum);
1333     vsum = vec_sum4s(vec_abs(line2C), vsum);
1334     vsum = vec_sum4s(vec_abs(line3C), vsum);
1335     vsum = vec_sum4s(vec_abs(line4C), vsum);
1336     vsum = vec_sum4s(vec_abs(line5C), vsum);
1337     vsum = vec_sum4s(vec_abs(line6C), vsum);
1338     vsum = vec_sum4s(vec_abs(line7C), vsum);
1339
1340     line0S = vec_add(temp0S, temp1S);
1341     line1S = vec_sub(temp0S, temp1S);
1342     line2S = vec_add(temp2S, temp3S);
1343     line3S = vec_sub(temp2S, temp3S);
1344     line4S = vec_add(temp4S, temp5S);
1345     line5S = vec_sub(temp4S, temp5S);
1346     line6S = vec_add(temp6S, temp7S);
1347     line7S = vec_sub(temp6S, temp7S);
1348
1349     line0BS = vec_add(line0S, line2S);
1350     line2BS = vec_sub(line0S, line2S);
1351     line1BS = vec_add(line1S, line3S);
1352     line3BS = vec_sub(line1S, line3S);
1353     line4BS = vec_add(line4S, line6S);
1354     line6BS = vec_sub(line4S, line6S);
1355     line5BS = vec_add(line5S, line7S);
1356     line7BS = vec_sub(line5S, line7S);
1357
1358     line0CS = vec_add(line0BS, line4BS);
1359     line4CS = vec_sub(line0BS, line4BS);
1360     line1CS = vec_add(line1BS, line5BS);
1361     line5CS = vec_sub(line1BS, line5BS);
1362     line2CS = vec_add(line2BS, line6BS);
1363     line6CS = vec_sub(line2BS, line6BS);
1364     line3CS = vec_add(line3BS, line7BS);
1365     line7CS = vec_sub(line3BS, line7BS);
1366
1367     vsum = vec_sum4s(vec_abs(line0CS), vsum);
1368     vsum = vec_sum4s(vec_abs(line1CS), vsum);
1369     vsum = vec_sum4s(vec_abs(line2CS), vsum);
1370     vsum = vec_sum4s(vec_abs(line3CS), vsum);
1371     vsum = vec_sum4s(vec_abs(line4CS), vsum);
1372     vsum = vec_sum4s(vec_abs(line5CS), vsum);
1373     vsum = vec_sum4s(vec_abs(line6CS), vsum);
1374     vsum = vec_sum4s(vec_abs(line7CS), vsum);
1375     vsum = vec_sums(vsum, (vector signed int)vzero);
1376     vsum = vec_splat(vsum, 3);
1377     vec_ste(vsum, 0, &sum);
1378   }
1379   return sum;
1380 }
1381
1382 int hadamard8_diff16_altivec(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
1383 POWERPC_PERF_DECLARE(altivec_hadamard8_diff16_num, 1);
1384     int score;
1385 POWERPC_PERF_START_COUNT(altivec_hadamard8_diff16_num, 1);
1386     score = hadamard8_diff16x8_altivec(s, dst, src, stride, 8);
1387     if (h==16) {
1388         dst += 8*stride;
1389         src += 8*stride;
1390         score += hadamard8_diff16x8_altivec(s, dst, src, stride, 8);
1391     }
1392 POWERPC_PERF_STOP_COUNT(altivec_hadamard8_diff16_num, 1);
1393     return score;
1394 }
1395
1396 static void vorbis_inverse_coupling_altivec(float *mag, float *ang,
1397                                             int blocksize)
1398 {
1399     int i;
1400     vector float m, a;
1401     vector bool int t0, t1;
1402     const vector unsigned int v_31 = //XXX
1403         vec_add(vec_add(vec_splat_u32(15),vec_splat_u32(15)),vec_splat_u32(1));
1404     for(i=0; i<blocksize; i+=4) {
1405         m = vec_ld(0, mag+i);
1406         a = vec_ld(0, ang+i);
1407         t0 = vec_cmple(m, (vector float)vec_splat_u32(0));
1408         t1 = vec_cmple(a, (vector float)vec_splat_u32(0));
1409         a = vec_xor(a, (vector float) vec_sl((vector unsigned int)t0, v_31));
1410         t0 = (vector bool int)vec_and(a, t1);
1411         t1 = (vector bool int)vec_andc(a, t1);
1412         a = vec_sub(m, (vector float)t1);
1413         m = vec_add(m, (vector float)t0);
1414         vec_stl(a, 0, ang+i);
1415         vec_stl(m, 0, mag+i);
1416     }
1417 }
1418
1419 /* next one assumes that ((line_size % 8) == 0) */
1420 void avg_pixels8_xy2_altivec(uint8_t *block, const uint8_t *pixels, int line_size, int h)
1421 {
1422 POWERPC_PERF_DECLARE(altivec_avg_pixels8_xy2_num, 1);
1423     register int i;
1424     register vector unsigned char pixelsv1, pixelsv2, pixelsavg;
1425     register vector unsigned char blockv, temp1, temp2, blocktemp;
1426     register vector unsigned short pixelssum1, pixelssum2, temp3;
1427
1428     register const vector unsigned char vczero = (const vector unsigned char)
1429                                         vec_splat_u8(0);
1430     register const vector unsigned short vctwo = (const vector unsigned short)
1431                                         vec_splat_u16(2);
1432
1433     temp1 = vec_ld(0, pixels);
1434     temp2 = vec_ld(16, pixels);
1435     pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(0, pixels));
1436     if ((((unsigned long)pixels) & 0x0000000F) ==  0x0000000F) {
1437         pixelsv2 = temp2;
1438     } else {
1439         pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(1, pixels));
1440     }
1441     pixelsv1 = vec_mergeh(vczero, pixelsv1);
1442     pixelsv2 = vec_mergeh(vczero, pixelsv2);
1443     pixelssum1 = vec_add((vector unsigned short)pixelsv1,
1444                          (vector unsigned short)pixelsv2);
1445     pixelssum1 = vec_add(pixelssum1, vctwo);
1446
1447 POWERPC_PERF_START_COUNT(altivec_avg_pixels8_xy2_num, 1);
1448     for (i = 0; i < h ; i++) {
1449         int rightside = ((unsigned long)block & 0x0000000F);
1450         blockv = vec_ld(0, block);
1451
1452         temp1 = vec_ld(line_size, pixels);
1453         temp2 = vec_ld(line_size + 16, pixels);
1454         pixelsv1 = vec_perm(temp1, temp2, vec_lvsl(line_size, pixels));
1455         if (((((unsigned long)pixels) + line_size) & 0x0000000F) ==  0x0000000F)
1456         {
1457             pixelsv2 = temp2;
1458         } else {
1459             pixelsv2 = vec_perm(temp1, temp2, vec_lvsl(line_size + 1, pixels));
1460         }
1461
1462         pixelsv1 = vec_mergeh(vczero, pixelsv1);
1463         pixelsv2 = vec_mergeh(vczero, pixelsv2);
1464         pixelssum2 = vec_add((vector unsigned short)pixelsv1,
1465                              (vector unsigned short)pixelsv2);
1466         temp3 = vec_add(pixelssum1, pixelssum2);
1467         temp3 = vec_sra(temp3, vctwo);
1468         pixelssum1 = vec_add(pixelssum2, vctwo);
1469         pixelsavg = vec_packsu(temp3, (vector unsigned short) vczero);
1470
1471         if (rightside) {
1472             blocktemp = vec_perm(blockv, pixelsavg, vcprm(0, 1, s0, s1));
1473         } else {
1474             blocktemp = vec_perm(blockv, pixelsavg, vcprm(s0, s1, 2, 3));
1475         }
1476
1477         blockv = vec_avg(blocktemp, blockv);
1478         vec_st(blockv, 0, block);
1479
1480         block += line_size;
1481         pixels += line_size;
1482     }
1483
1484 POWERPC_PERF_STOP_COUNT(altivec_avg_pixels8_xy2_num, 1);
1485 }
1486
1487 void dsputil_init_altivec(DSPContext* c, AVCodecContext *avctx)
1488 {
1489     c->pix_abs[0][1] = sad16_x2_altivec;
1490     c->pix_abs[0][2] = sad16_y2_altivec;
1491     c->pix_abs[0][3] = sad16_xy2_altivec;
1492     c->pix_abs[0][0] = sad16_altivec;
1493     c->pix_abs[1][0] = sad8_altivec;
1494     c->sad[0]= sad16_altivec;
1495     c->sad[1]= sad8_altivec;
1496     c->pix_norm1 = pix_norm1_altivec;
1497     c->sse[1]= sse8_altivec;
1498     c->sse[0]= sse16_altivec;
1499     c->pix_sum = pix_sum_altivec;
1500     c->diff_pixels = diff_pixels_altivec;
1501     c->get_pixels = get_pixels_altivec;
1502     c->add_bytes= add_bytes_altivec;
1503     c->put_pixels_tab[0][0] = put_pixels16_altivec;
1504     /* the two functions do the same thing, so use the same code */
1505     c->put_no_rnd_pixels_tab[0][0] = put_pixels16_altivec;
1506     c->avg_pixels_tab[0][0] = avg_pixels16_altivec;
1507     c->avg_pixels_tab[1][0] = avg_pixels8_altivec;
1508     c->avg_pixels_tab[1][3] = avg_pixels8_xy2_altivec;
1509     c->put_pixels_tab[1][3] = put_pixels8_xy2_altivec;
1510     c->put_no_rnd_pixels_tab[1][3] = put_no_rnd_pixels8_xy2_altivec;
1511     c->put_pixels_tab[0][3] = put_pixels16_xy2_altivec;
1512     c->put_no_rnd_pixels_tab[0][3] = put_no_rnd_pixels16_xy2_altivec;
1513
1514     c->hadamard8_diff[0] = hadamard8_diff16_altivec;
1515     c->hadamard8_diff[1] = hadamard8_diff8x8_altivec;
1516     if (ENABLE_VORBIS_DECODER)
1517         c->vorbis_inverse_coupling = vorbis_inverse_coupling_altivec;
1518 }