support for both orderings of the slices (top->down / bottom->up)
[ffmpeg.git] / postproc / 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 }