git.sesse.net Git - vlc/blob - modules/video_filter/swscale/swscale_altivec_template.c

   1 /*
   2   AltiVec-enhanced yuv2yuvX
   3
   4     Copyright (C) 2004 Romain Dolbeau <romain@dolbeau.org>
   5     based on the equivalent C code in "postproc/swscale.c"
   6
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program 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
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22
  23 #ifdef CONFIG_DARWIN
  24 #define AVV(x...) (x)
  25 #else
  26 #define AVV(x...) {x}
  27 #endif
  28
  29 static const vector signed int vzero =
  30   (const vector signed int)AVV(0, 0, 0, 0);
  31 static const vector unsigned int altivec_vectorShiftInt19 =
  32   (const vector unsigned int)AVV(19, 19, 19, 19);
  33
  34 static inline void
  35 altivec_packIntArrayToCharArray(int *val, uint8_t* dest, int dstW) {
  36   register int i;
  37   if ((unsigned long)dest % 16) {
  38     /* badly aligned store, we force store alignement */
  39     /* and will handle load misalignement on val w/ vec_perm */
  40     for (i = 0 ; (i < dstW) &&
  41            (((unsigned long)dest + i) % 16) ; i++) {
  42       int t = val[i] >> 19;
  43       dest[i] = (t < 0) ? 0 : ((t > 255) ? 255 : t);
  44     }
  45     vector unsigned char perm1 = vec_lvsl(i << 2, val);
  46     vector signed int v1 = vec_ld(i << 2, val);
  47     for ( ; i < (dstW - 15); i+=16) {
  48       int offset = i << 2;
  49       vector signed int v2 = vec_ld(offset + 16, val);
  50       vector signed int v3 = vec_ld(offset + 32, val);
  51       vector signed int v4 = vec_ld(offset + 48, val);
  52       vector signed int v5 = vec_ld(offset + 64, val);
  53       vector signed int v12 = vec_perm(v1,v2,perm1);
  54       vector signed int v23 = vec_perm(v2,v3,perm1);
  55       vector signed int v34 = vec_perm(v3,v4,perm1);
  56       vector signed int v45 = vec_perm(v4,v5,perm1);
  57
  58       vector signed int vA = vec_sra(v12, altivec_vectorShiftInt19);
  59       vector signed int vB = vec_sra(v23, altivec_vectorShiftInt19);
  60       vector signed int vC = vec_sra(v34, altivec_vectorShiftInt19);
  61       vector signed int vD = vec_sra(v45, altivec_vectorShiftInt19);
  62       vector unsigned short vs1 = vec_packsu(vA, vB);
  63       vector unsigned short vs2 = vec_packsu(vC, vD);
  64       vector unsigned char vf = vec_packsu(vs1, vs2);
  65       vec_st(vf, i, dest);
  66       v1 = v5;
  67     }
  68   } else { // dest is properly aligned, great
  69     for (i = 0; i < (dstW - 15); i+=16) {
  70       int offset = i << 2;
  71       vector signed int v1 = vec_ld(offset, val);
  72       vector signed int v2 = vec_ld(offset + 16, val);
  73       vector signed int v3 = vec_ld(offset + 32, val);
  74       vector signed int v4 = vec_ld(offset + 48, val);
  75       vector signed int v5 = vec_sra(v1, altivec_vectorShiftInt19);
  76       vector signed int v6 = vec_sra(v2, altivec_vectorShiftInt19);
  77       vector signed int v7 = vec_sra(v3, altivec_vectorShiftInt19);
  78       vector signed int v8 = vec_sra(v4, altivec_vectorShiftInt19);
  79       vector unsigned short vs1 = vec_packsu(v5, v6);
  80       vector unsigned short vs2 = vec_packsu(v7, v8);
  81       vector unsigned char vf = vec_packsu(vs1, vs2);
  82       vec_st(vf, i, dest);
  83     }
  84   }
  85   for ( ; i < dstW ; i++) {
  86     int t = val[i] >> 19;
  87     dest[i] = (t < 0) ? 0 : ((t > 255) ? 255 : t);
  88   }
  89 }
  90
  91 static inline void
  92 yuv2yuvX_altivec_real(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
  93                       int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
  94                       uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW)
  95 {
  96   const vector signed int vini = {(1 << 18), (1 << 18), (1 << 18), (1 << 18)};
  97   register int i, j;
  98   {
  99     int __attribute__ ((aligned (16))) val[dstW];
 100
 101     for (i = 0; i < (dstW -7); i+=4) {
 102       vec_st(vini, i << 2, val);
 103     }
 104     for (; i < dstW; i++) {
 105       val[i] = (1 << 18);
 106     }
 107
 108     for (j = 0; j < lumFilterSize; j++) {
 109       vector signed short vLumFilter = vec_ld(j << 1, lumFilter);
 110       vector unsigned char perm0 = vec_lvsl(j << 1, lumFilter);
 111       vLumFilter = vec_perm(vLumFilter, vLumFilter, perm0);
 112       vLumFilter = vec_splat(vLumFilter, 0); // lumFilter[j] is loaded 8 times in vLumFilter
 113
 114       vector unsigned char perm = vec_lvsl(0, lumSrc[j]);
 115       vector signed short l1 = vec_ld(0, lumSrc[j]);
 116
 117       for (i = 0; i < (dstW - 7); i+=8) {
 118         int offset = i << 2;
 119         vector signed short l2 = vec_ld((i << 1) + 16, lumSrc[j]);
 120
 121         vector signed int v1 = vec_ld(offset, val);
 122         vector signed int v2 = vec_ld(offset + 16, val);
 123
 124         vector signed short ls = vec_perm(l1, l2, perm); // lumSrc[j][i] ... lumSrc[j][i+7]
 125
 126         vector signed int i1 = vec_mule(vLumFilter, ls);
 127         vector signed int i2 = vec_mulo(vLumFilter, ls);
 128
 129         vector signed int vf1 = vec_mergeh(i1, i2);
 130         vector signed int vf2 = vec_mergel(i1, i2); // lumSrc[j][i] * lumFilter[j] ... lumSrc[j][i+7] * lumFilter[j]
 131
 132         vector signed int vo1 = vec_add(v1, vf1);
 133         vector signed int vo2 = vec_add(v2, vf2);
 134
 135         vec_st(vo1, offset, val);
 136         vec_st(vo2, offset + 16, val);
 137
 138         l1 = l2;
 139       }
 140       for ( ; i < dstW; i++) {
 141         val[i] += lumSrc[j][i] * lumFilter[j];
 142       }
 143     }
 144     altivec_packIntArrayToCharArray(val,dest,dstW);
 145   }
 146   if (uDest != 0) {
 147     int  __attribute__ ((aligned (16))) u[chrDstW];
 148     int  __attribute__ ((aligned (16))) v[chrDstW];
 149
 150     for (i = 0; i < (chrDstW -7); i+=4) {
 151       vec_st(vini, i << 2, u);
 152       vec_st(vini, i << 2, v);
 153     }
 154     for (; i < chrDstW; i++) {
 155       u[i] = (1 << 18);
 156       v[i] = (1 << 18);
 157     }
 158
 159     for (j = 0; j < chrFilterSize; j++) {
 160       vector signed short vChrFilter = vec_ld(j << 1, chrFilter);
 161       vector unsigned char perm0 = vec_lvsl(j << 1, chrFilter);
 162       vChrFilter = vec_perm(vChrFilter, vChrFilter, perm0);
 163       vChrFilter = vec_splat(vChrFilter, 0); // chrFilter[j] is loaded 8 times in vChrFilter
 164
 165       vector unsigned char perm = vec_lvsl(0, chrSrc[j]);
 166       vector signed short l1 = vec_ld(0, chrSrc[j]);
 167       vector signed short l1_V = vec_ld(2048 << 1, chrSrc[j]);
 168
 169       for (i = 0; i < (chrDstW - 7); i+=8) {
 170         int offset = i << 2;
 171         vector signed short l2 = vec_ld((i << 1) + 16, chrSrc[j]);
 172         vector signed short l2_V = vec_ld(((i + 2048) << 1) + 16, chrSrc[j]);
 173
 174         vector signed int v1 = vec_ld(offset, u);
 175         vector signed int v2 = vec_ld(offset + 16, u);
 176         vector signed int v1_V = vec_ld(offset, v);
 177         vector signed int v2_V = vec_ld(offset + 16, v);
 178
 179         vector signed short ls = vec_perm(l1, l2, perm); // chrSrc[j][i] ... chrSrc[j][i+7]
 180         vector signed short ls_V = vec_perm(l1_V, l2_V, perm); // chrSrc[j][i+2048] ... chrSrc[j][i+2055]
 181
 182         vector signed int i1 = vec_mule(vChrFilter, ls);
 183         vector signed int i2 = vec_mulo(vChrFilter, ls);
 184         vector signed int i1_V = vec_mule(vChrFilter, ls_V);
 185         vector signed int i2_V = vec_mulo(vChrFilter, ls_V);
 186
 187         vector signed int vf1 = vec_mergeh(i1, i2);
 188         vector signed int vf2 = vec_mergel(i1, i2); // chrSrc[j][i] * chrFilter[j] ... chrSrc[j][i+7] * chrFilter[j]
 189         vector signed int vf1_V = vec_mergeh(i1_V, i2_V);
 190         vector signed int vf2_V = vec_mergel(i1_V, i2_V); // chrSrc[j][i] * chrFilter[j] ... chrSrc[j][i+7] * chrFilter[j]
 191
 192         vector signed int vo1 = vec_add(v1, vf1);
 193         vector signed int vo2 = vec_add(v2, vf2);
 194         vector signed int vo1_V = vec_add(v1_V, vf1_V);
 195         vector signed int vo2_V = vec_add(v2_V, vf2_V);
 196
 197         vec_st(vo1, offset, u);
 198         vec_st(vo2, offset + 16, u);
 199         vec_st(vo1_V, offset, v);
 200         vec_st(vo2_V, offset + 16, v);
 201
 202         l1 = l2;
 203         l1_V = l2_V;
 204       }
 205       for ( ; i < chrDstW; i++) {
 206         u[i] += chrSrc[j][i] * chrFilter[j];
 207         v[i] += chrSrc[j][i + 2048] * chrFilter[j];
 208       }
 209     }
 210     altivec_packIntArrayToCharArray(u,uDest,chrDstW);
 211     altivec_packIntArrayToCharArray(v,vDest,chrDstW);
 212   }
 213 }
 214
 215 static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc, int16_t *filter, int16_t *filterPos, int filterSize) {
 216   register int i;
 217   int __attribute__ ((aligned (16))) tempo[4];
 218
 219   if (filterSize % 4) {
 220     for(i=0; i<dstW; i++) {
 221       register int j;
 222       register int srcPos = filterPos[i];
 223       register int val = 0;
 224       for(j=0; j<filterSize; j++) {
 225         val += ((int)src[srcPos + j])*filter[filterSize*i + j];
 226       }
 227       dst[i] = MIN(MAX(0, val>>7), (1<<15)-1);
 228     }
 229   }
 230   else
 231   switch (filterSize) {
 232   case 4:
 233     {
 234       for(i=0; i<dstW; i++) {
 235         register int j;
 236         register int srcPos = filterPos[i];
 237
 238         vector unsigned char src_v0 = vec_ld(srcPos, src);
 239         vector unsigned char src_v1;
 240         if ((((int)src + srcPos)% 16) > 12) {
 241           src_v1 = vec_ld(srcPos + 16, src);
 242         }
 243         vector unsigned char src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
 244
 245         vector signed short src_v = // vec_unpackh sign-extends...
 246           (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
 247         // now put our elements in the even slots
 248         src_v = vec_mergeh(src_v, (vector signed short)vzero);
 249
 250         vector signed short filter_v = vec_ld(i << 3, filter);
 251         // the 3 above is 2 (filterSize == 4) + 1 (sizeof(short) == 2)
 252
 253         // the neat trick : we only care for half the elements,
 254         // high or low depending on (i<<3)%16 (it's 0 or 8 here),
 255         // and we're going to use vec_mule, so we chose
 256         // carefully how to "unpack" the elements into the even slots
 257         if ((i << 3) % 16)
 258           filter_v = vec_mergel(filter_v,(vector signed short)vzero);
 259         else
 260           filter_v = vec_mergeh(filter_v,(vector signed short)vzero);
 261
 262         vector signed int val_vEven = vec_mule(src_v, filter_v);
 263         vector signed int val_s = vec_sums(val_vEven, vzero);
 264         vec_st(val_s, 0, tempo);
 265         dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);
 266       }
 267     }
 268     break;
 269
 270   case 8:
 271     {
 272       for(i=0; i<dstW; i++) {
 273         register int srcPos = filterPos[i];
 274
 275         vector unsigned char src_v0 = vec_ld(srcPos, src);
 276         vector unsigned char src_v1;
 277         if ((((int)src + srcPos)% 16) > 8) {
 278           src_v1 = vec_ld(srcPos + 16, src);
 279         }
 280         vector unsigned char src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
 281
 282         vector signed short src_v = // vec_unpackh sign-extends...
 283           (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
 284         vector signed short filter_v = vec_ld(i << 4, filter);
 285         // the 4 above is 3 (filterSize == 8) + 1 (sizeof(short) == 2)
 286
 287         vector signed int val_v = vec_msums(src_v, filter_v, (vector signed int)vzero);
 288         vector signed int val_s = vec_sums(val_v, vzero);
 289         vec_st(val_s, 0, tempo);
 290         dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);
 291       }
 292     }
 293     break;
 294
 295   case 16:
 296     {
 297       for(i=0; i<dstW; i++) {
 298         register int srcPos = filterPos[i];
 299
 300         vector unsigned char src_v0 = vec_ld(srcPos, src);
 301         vector unsigned char src_v1 = vec_ld(srcPos + 16, src);
 302         vector unsigned char src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
 303
 304         vector signed short src_vA = // vec_unpackh sign-extends...
 305           (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
 306         vector signed short src_vB = // vec_unpackh sign-extends...
 307           (vector signed short)(vec_mergel((vector unsigned char)vzero, src_vF));
 308
 309         vector signed short filter_v0 = vec_ld(i << 5, filter);
 310         vector signed short filter_v1 = vec_ld((i << 5) + 16, filter);
 311         // the 5 above are 4 (filterSize == 16) + 1 (sizeof(short) == 2)
 312
 313         vector signed int val_acc = vec_msums(src_vA, filter_v0, (vector signed int)vzero);
 314         vector signed int val_v = vec_msums(src_vB, filter_v1, val_acc);
 315
 316         vector signed int val_s = vec_sums(val_v, vzero);
 317
 318         vec_st(val_s, 0, tempo);
 319         dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);
 320       }
 321     }
 322     break;
 323
 324   default:
 325     {
 326       for(i=0; i<dstW; i++) {
 327         register int j;
 328         register int srcPos = filterPos[i];
 329
 330         vector signed int val_v = (vector signed int)vzero;
 331         vector signed short filter_v0R = vec_ld(i * 2 * filterSize, filter);
 332         vector unsigned char permF = vec_lvsl((i * 2 * filterSize), filter);
 333
 334         vector unsigned char src_v0 = vec_ld(srcPos, src);
 335         vector unsigned char permS = vec_lvsl(srcPos, src);
 336
 337         for (j = 0 ; j < filterSize - 15; j += 16) {
 338           vector unsigned char src_v1 = vec_ld(srcPos + j + 16, src);
 339           vector unsigned char src_vF = vec_perm(src_v0, src_v1, permS);
 340
 341           vector signed short src_vA = // vec_unpackh sign-extends...
 342             (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
 343           vector signed short src_vB = // vec_unpackh sign-extends...
 344             (vector signed short)(vec_mergel((vector unsigned char)vzero, src_vF));
 345
 346           vector signed short filter_v1R = vec_ld((i * 2 * filterSize) + (j * 2) + 16, filter);
 347           vector signed short filter_v2R = vec_ld((i * 2 * filterSize) + (j * 2) + 32, filter);
 348           vector signed short filter_v0 = vec_perm(filter_v0R, filter_v1R, permF);
 349           vector signed short filter_v1 = vec_perm(filter_v1R, filter_v2R, permF);
 350
 351           vector signed int val_acc = vec_msums(src_vA, filter_v0, val_v);
 352           val_v = vec_msums(src_vB, filter_v1, val_acc);
 353
 354           filter_v0R = filter_v2R;
 355           src_v0 = src_v1;
 356         }
 357
 358         if (j < (filterSize-7)) {
 359           // loading src_v0 is useless, it's already done above
 360           //vector unsigned char src_v0 = vec_ld(srcPos + j, src);
 361           vector unsigned char src_v1;
 362           if ((((int)src + srcPos)% 16) > 8) {
 363             src_v1 = vec_ld(srcPos + j + 16, src);
 364           }
 365           vector unsigned char src_vF = vec_perm(src_v0, src_v1, permS);
 366
 367           vector signed short src_v = // vec_unpackh sign-extends...
 368             (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
 369           // loading filter_v0R is useless, it's already done above
 370           //vector signed short filter_v0R = vec_ld((i * 2 * filterSize) + j, filter);
 371           vector signed short filter_v1R = vec_ld((i * 2 * filterSize) + (j * 2) + 16, filter);
 372           vector signed short filter_v = vec_perm(filter_v0R, filter_v1R, permF);
 373
 374           val_v = vec_msums(src_v, filter_v, val_v);
 375         }
 376
 377         vector signed int val_s = vec_sums(val_v, vzero);
 378
 379         vec_st(val_s, 0, tempo);
 380         dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);
 381       }
 382
 383     }
 384   }
 385 }
 386
 387 static inline int yv12toyuy2_unscaled_altivec(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
 388      int srcSliceH, uint8_t* dstParam[], int dstStride_a[]) {
 389   uint8_t *dst=dstParam[0] + dstStride_a[0]*srcSliceY;
 390   // yv12toyuy2( src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0] );
 391   uint8_t *ysrc = src[0];
 392   uint8_t *usrc = src[1];
 393   uint8_t *vsrc = src[2];
 394   const int width = c->srcW;
 395   const int height = srcSliceH;
 396   const int lumStride = srcStride[0];
 397   const int chromStride = srcStride[1];
 398   const int dstStride = dstStride_a[0];
 399   const vector unsigned char yperm = vec_lvsl(0, ysrc);
 400   const int vertLumPerChroma = 2;
 401   register unsigned int y;
 402
 403   /* this code assume:
 404
 405   1) dst is 16 bytes-aligned
 406   2) dstStride is a multiple of 16
 407   3) width is a multiple of 16
 408   4) lum&chrom stride are multiple of 8
 409   */
 410
 411   for(y=0; y<height; y++)
 412     {
 413       int i;
 414       for (i = 0; i < width - 31; i+= 32) {
 415         const unsigned int j = i >> 1;
 416         vector unsigned char v_yA = vec_ld(i, ysrc);
 417         vector unsigned char v_yB = vec_ld(i + 16, ysrc);
 418         vector unsigned char v_yC = vec_ld(i + 32, ysrc);
 419         vector unsigned char v_y1 = vec_perm(v_yA, v_yB, yperm);
 420         vector unsigned char v_y2 = vec_perm(v_yB, v_yC, yperm);
 421         vector unsigned char v_uA = vec_ld(j, usrc);
 422         vector unsigned char v_uB = vec_ld(j + 16, usrc);
 423         vector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(j, usrc));
 424         vector unsigned char v_vA = vec_ld(j, vsrc);
 425         vector unsigned char v_vB = vec_ld(j + 16, vsrc);
 426         vector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(j, vsrc));
 427         vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
 428         vector unsigned char v_uv_b = vec_mergel(v_u, v_v);
 429         vector unsigned char v_yuy2_0 = vec_mergeh(v_y1, v_uv_a);
 430         vector unsigned char v_yuy2_1 = vec_mergel(v_y1, v_uv_a);
 431         vector unsigned char v_yuy2_2 = vec_mergeh(v_y2, v_uv_b);
 432         vector unsigned char v_yuy2_3 = vec_mergel(v_y2, v_uv_b);
 433         vec_st(v_yuy2_0, (i << 1), dst);
 434         vec_st(v_yuy2_1, (i << 1) + 16, dst);
 435         vec_st(v_yuy2_2, (i << 1) + 32, dst);
 436         vec_st(v_yuy2_3, (i << 1) + 48, dst);
 437       }
 438       if (i < width) {
 439         const unsigned int j = i >> 1;
 440         vector unsigned char v_y1 = vec_ld(i, ysrc);
 441         vector unsigned char v_u = vec_ld(j, usrc);
 442         vector unsigned char v_v = vec_ld(j, vsrc);
 443         vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
 444         vector unsigned char v_yuy2_0 = vec_mergeh(v_y1, v_uv_a);
 445         vector unsigned char v_yuy2_1 = vec_mergel(v_y1, v_uv_a);
 446         vec_st(v_yuy2_0, (i << 1), dst);
 447         vec_st(v_yuy2_1, (i << 1) + 16, dst);
 448       }
 449       if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
 450         {
 451           usrc += chromStride;
 452           vsrc += chromStride;
 453         }
 454       ysrc += lumStride;
 455       dst += dstStride;
 456     }
 457
 458   return srcSliceH;
 459 }
 460
 461 static inline int yv12touyvy_unscaled_altivec(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
 462      int srcSliceH, uint8_t* dstParam[], int dstStride_a[]) {
 463   uint8_t *dst=dstParam[0] + dstStride_a[0]*srcSliceY;
 464   // yv12toyuy2( src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0] );
 465   uint8_t *ysrc = src[0];
 466   uint8_t *usrc = src[1];
 467   uint8_t *vsrc = src[2];
 468   const int width = c->srcW;
 469   const int height = srcSliceH;
 470   const int lumStride = srcStride[0];
 471   const int chromStride = srcStride[1];
 472   const int dstStride = dstStride_a[0];
 473   const int vertLumPerChroma = 2;
 474   const vector unsigned char yperm = vec_lvsl(0, ysrc);
 475   register unsigned int y;
 476
 477   /* this code assume:
 478
 479   1) dst is 16 bytes-aligned
 480   2) dstStride is a multiple of 16
 481   3) width is a multiple of 16
 482   4) lum&chrom stride are multiple of 8
 483   */
 484
 485   for(y=0; y<height; y++)
 486     {
 487       int i;
 488       for (i = 0; i < width - 31; i+= 32) {
 489         const unsigned int j = i >> 1;
 490         vector unsigned char v_yA = vec_ld(i, ysrc);
 491         vector unsigned char v_yB = vec_ld(i + 16, ysrc);
 492         vector unsigned char v_yC = vec_ld(i + 32, ysrc);
 493         vector unsigned char v_y1 = vec_perm(v_yA, v_yB, yperm);
 494         vector unsigned char v_y2 = vec_perm(v_yB, v_yC, yperm);
 495         vector unsigned char v_uA = vec_ld(j, usrc);
 496         vector unsigned char v_uB = vec_ld(j + 16, usrc);
 497         vector unsigned char v_u = vec_perm(v_uA, v_uB, vec_lvsl(j, usrc));
 498         vector unsigned char v_vA = vec_ld(j, vsrc);
 499         vector unsigned char v_vB = vec_ld(j + 16, vsrc);
 500         vector unsigned char v_v = vec_perm(v_vA, v_vB, vec_lvsl(j, vsrc));
 501         vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
 502         vector unsigned char v_uv_b = vec_mergel(v_u, v_v);
 503         vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
 504         vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
 505         vector unsigned char v_uyvy_2 = vec_mergeh(v_uv_b, v_y2);
 506         vector unsigned char v_uyvy_3 = vec_mergel(v_uv_b, v_y2);
 507         vec_st(v_uyvy_0, (i << 1), dst);
 508         vec_st(v_uyvy_1, (i << 1) + 16, dst);
 509         vec_st(v_uyvy_2, (i << 1) + 32, dst);
 510         vec_st(v_uyvy_3, (i << 1) + 48, dst);
 511       }
 512       if (i < width) {
 513         const unsigned int j = i >> 1;
 514         vector unsigned char v_y1 = vec_ld(i, ysrc);
 515         vector unsigned char v_u = vec_ld(j, usrc);
 516         vector unsigned char v_v = vec_ld(j, vsrc);
 517         vector unsigned char v_uv_a = vec_mergeh(v_u, v_v);
 518         vector unsigned char v_uyvy_0 = vec_mergeh(v_uv_a, v_y1);
 519         vector unsigned char v_uyvy_1 = vec_mergel(v_uv_a, v_y1);
 520         vec_st(v_uyvy_0, (i << 1), dst);
 521         vec_st(v_uyvy_1, (i << 1) + 16, dst);
 522       }
 523       if((y&(vertLumPerChroma-1))==(vertLumPerChroma-1) )
 524         {
 525           usrc += chromStride;
 526           vsrc += chromStride;
 527         }
 528       ysrc += lumStride;
 529       dst += dstStride;
 530     }
 531   return srcSliceH;
 532 }