Remove non cosmetic spaces inside parentheses.
[ffmpeg.git] / libswscale / yuv2rgb_altivec.c
index 78662f2..ebc9a64 100644 (file)
@@ -1,7 +1,7 @@
 /*
   marc.hoffman@analog.com    March 8, 2004
 
 /*
   marc.hoffman@analog.com    March 8, 2004
 
-  Altivec Acceleration for Color Space Conversion revision 0.2
+  AltiVec acceleration for colorspace conversion revision 0.2
 
   convert I420 YV12 to RGB in various formats,
     it rejects images that are not in 420 formats
 
   convert I420 YV12 to RGB in various formats,
     it rejects images that are not in 420 formats
 
   NOTE quartz vo driver ARGB32_to_RGB24 consumes 30% of the processor
 
 
   NOTE quartz vo driver ARGB32_to_RGB24 consumes 30% of the processor
 
-  Integrated luma prescaling adjustment for saturation/contrast/brightness adjustment. 
-
+  Integrated luma prescaling adjustment for saturation/contrast/brightness adjustment.
 */
 */
+
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -74,7 +92,6 @@
 #include "rgb2rgb.h"
 #include "swscale.h"
 #include "swscale_internal.h"
 #include "rgb2rgb.h"
 #include "swscale.h"
 #include "swscale_internal.h"
-#include "img_format.h" //FIXME try to reduce dependency of such stuff
 
 #undef PROFILE_THE_BEAST
 #undef INC_SCALING
 
 #undef PROFILE_THE_BEAST
 #undef INC_SCALING
@@ -122,70 +139,70 @@ typedef signed char   sbyte;
 static
 const vector unsigned char
   perm_rgb_0 = (const vector unsigned char)AVV(0x00,0x01,0x10,0x02,0x03,0x11,0x04,0x05,
 static
 const vector unsigned char
   perm_rgb_0 = (const vector unsigned char)AVV(0x00,0x01,0x10,0x02,0x03,0x11,0x04,0x05,
-                                     0x12,0x06,0x07,0x13,0x08,0x09,0x14,0x0a),
+                                               0x12,0x06,0x07,0x13,0x08,0x09,0x14,0x0a),
   perm_rgb_1 = (const vector unsigned char)AVV(0x0b,0x15,0x0c,0x0d,0x16,0x0e,0x0f,0x17,
   perm_rgb_1 = (const vector unsigned char)AVV(0x0b,0x15,0x0c,0x0d,0x16,0x0e,0x0f,0x17,
-                                     0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f),
+                                               0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f),
   perm_rgb_2 = (const vector unsigned char)AVV(0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
   perm_rgb_2 = (const vector unsigned char)AVV(0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
-                                     0x00,0x01,0x18,0x02,0x03,0x19,0x04,0x05),
+                                               0x00,0x01,0x18,0x02,0x03,0x19,0x04,0x05),
   perm_rgb_3 = (const vector unsigned char)AVV(0x1a,0x06,0x07,0x1b,0x08,0x09,0x1c,0x0a,
   perm_rgb_3 = (const vector unsigned char)AVV(0x1a,0x06,0x07,0x1b,0x08,0x09,0x1c,0x0a,
-                                     0x0b,0x1d,0x0c,0x0d,0x1e,0x0e,0x0f,0x1f);
-
-#define vec_merge3(x2,x1,x0,y0,y1,y2)    \
-do {                                    \
-  typeof(x0) o0,o2,o3;                  \
-      o0 = vec_mergeh (x0,x1);          \
-      y0 = vec_perm (o0, x2, perm_rgb_0);\
-      o2 = vec_perm (o0, x2, perm_rgb_1);\
-      o3 = vec_mergel (x0,x1);          \
-      y1 = vec_perm (o3,o2,perm_rgb_2);         \
-      y2 = vec_perm (o3,o2,perm_rgb_3);         \
+                                               0x0b,0x1d,0x0c,0x0d,0x1e,0x0e,0x0f,0x1f);
+
+#define vec_merge3(x2,x1,x0,y0,y1,y2)       \
+do {                                        \
+    typeof(x0) o0,o2,o3;                    \
+        o0 = vec_mergeh (x0,x1);            \
+        y0 = vec_perm (o0, x2, perm_rgb_0); \
+        o2 = vec_perm (o0, x2, perm_rgb_1); \
+        o3 = vec_mergel (x0,x1);            \
+        y1 = vec_perm (o3,o2,perm_rgb_2);   \
+        y2 = vec_perm (o3,o2,perm_rgb_3);   \
 } while(0)
 
 } while(0)
 
-#define vec_mstbgr24(x0,x1,x2,ptr)        \
-do {                                    \
-  typeof(x0) _0,_1,_2;                  \
-  vec_merge3 (x0,x1,x2,_0,_1,_2);       \
-  vec_st (_0, 0, ptr++);                \
-  vec_st (_1, 0, ptr++);                \
-  vec_st (_2, 0, ptr++);                \
+#define vec_mstbgr24(x0,x1,x2,ptr)      \
+do {                                    \
+    typeof(x0) _0,_1,_2;                \
+    vec_merge3 (x0,x1,x2,_0,_1,_2);     \
+    vec_st (_0, 0, ptr++);              \
+    vec_st (_1, 0, ptr++);              \
+    vec_st (_2, 0, ptr++);              \
 }  while (0);
 
 }  while (0);
 
-#define vec_mstrgb24(x0,x1,x2,ptr)       \
-do {                                    \
-  typeof(x0) _0,_1,_2;                  \
-  vec_merge3 (x2,x1,x0,_0,_1,_2);       \
-  vec_st (_0, 0, ptr++);                \
-  vec_st (_1, 0, ptr++);                \
-  vec_st (_2, 0, ptr++);                \
+#define vec_mstrgb24(x0,x1,x2,ptr)      \
+do {                                    \
+    typeof(x0) _0,_1,_2;                \
+    vec_merge3 (x2,x1,x0,_0,_1,_2);     \
+    vec_st (_0, 0, ptr++);              \
+    vec_st (_1, 0, ptr++);              \
+    vec_st (_2, 0, ptr++);              \
 }  while (0);
 
 /* pack the pixels in rgb0 format
    msb R
    lsb 0
 */
 }  while (0);
 
 /* pack the pixels in rgb0 format
    msb R
    lsb 0
 */
-#define vec_mstrgb32(T,x0,x1,x2,x3,ptr)                                                       \
-do {                                                                                  \
-  T _0,_1,_2,_3;                                                                      \
-  _0 = vec_mergeh (x0,x1);                                                            \
-  _1 = vec_mergeh (x2,x3);                                                            \
-  _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1);            \
-  _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1);            \
-  vec_st (_2, 0*16, (T *)ptr);                                                        \
-  vec_st (_3, 1*16, (T *)ptr);                                                        \
-  _0 = vec_mergel (x0,x1);                                                            \
-  _1 = vec_mergel (x2,x3);                                                            \
-  _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1);           \
-  _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1);           \
-  vec_st (_2, 2*16, (T *)ptr);                                                        \
-  vec_st (_3, 3*16, (T *)ptr);                                                        \
-  ptr += 4;                                                                           \
+#define vec_mstrgb32(T,x0,x1,x2,x3,ptr)                                       \
+do {                                                                          \
+    T _0,_1,_2,_3;                                                            \
+    _0 = vec_mergeh (x0,x1);                                                  \
+    _1 = vec_mergeh (x2,x3);                                                  \
+    _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1); \
+    _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1); \
+    vec_st (_2, 0*16, (T *)ptr);                                              \
+    vec_st (_3, 1*16, (T *)ptr);                                              \
+    _0 = vec_mergel (x0,x1);                                                  \
+    _1 = vec_mergel (x2,x3);                                                  \
+    _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1); \
+    _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1); \
+    vec_st (_2, 2*16, (T *)ptr);                                              \
+    vec_st (_3, 3*16, (T *)ptr);                                              \
+    ptr += 4;                                                                 \
 }  while (0);
 
 /*
 
   | 1     0       1.4021   | | Y |
   | 1    -0.3441 -0.7142   |x| Cb|
 }  while (0);
 
 /*
 
   | 1     0       1.4021   | | Y |
   | 1    -0.3441 -0.7142   |x| Cb|
-  | 1     1.7718  0       | | Cr|
+  | 1     1.7718  0        | | Cr|
 
 
   Y:      [-128 127]
 
 
   Y:      [-128 127]
@@ -199,51 +216,51 @@ do {                                                                                     \
 
 
 #define vec_unh(x) \
 
 
 #define vec_unh(x) \
-  (vector signed short) \
-    vec_perm(x,(typeof(x))AVV(0),\
-             (vector unsigned char)AVV(0x10,0x00,0x10,0x01,0x10,0x02,0x10,0x03,\
-                                    0x10,0x04,0x10,0x05,0x10,0x06,0x10,0x07))
+    (vector signed short) \
+        vec_perm(x,(typeof(x))AVV(0),\
+                 (vector unsigned char)AVV(0x10,0x00,0x10,0x01,0x10,0x02,0x10,0x03,\
+                                           0x10,0x04,0x10,0x05,0x10,0x06,0x10,0x07))
 #define vec_unl(x) \
 #define vec_unl(x) \
-  (vector signed short) \
-    vec_perm(x,(typeof(x))AVV(0),\
-             (vector unsigned char)AVV(0x10,0x08,0x10,0x09,0x10,0x0A,0x10,0x0B,\
-                                    0x10,0x0C,0x10,0x0D,0x10,0x0E,0x10,0x0F))
+    (vector signed short) \
+        vec_perm(x,(typeof(x))AVV(0),\
+                 (vector unsigned char)AVV(0x10,0x08,0x10,0x09,0x10,0x0A,0x10,0x0B,\
+                                           0x10,0x0C,0x10,0x0D,0x10,0x0E,0x10,0x0F))
 
 #define vec_clip_s16(x) \
 
 #define vec_clip_s16(x) \
-  vec_max (vec_min (x, (vector signed short)AVV(235,235,235,235,235,235,235,235)),\
-                       (vector signed short)AVV(16, 16, 16, 16, 16, 16, 16, 16 ))
+    vec_max (vec_min (x, (vector signed short)AVV(235,235,235,235,235,235,235,235)),\
+                         (vector signed short)AVV( 16, 16, 16, 16, 16, 16, 16, 16))
 
 #define vec_packclp(x,y) \
 
 #define vec_packclp(x,y) \
-  (vector unsigned char)vec_packs \
-      ((vector unsigned short)vec_max (x,(vector signed short) AVV(0)), \
-       (vector unsigned short)vec_max (y,(vector signed short) AVV(0)))
+    (vector unsigned char)vec_packs \
+        ((vector unsigned short)vec_max (x,(vector signed short) AVV(0)), \
+         (vector unsigned short)vec_max (y,(vector signed short) AVV(0)))
 
 //#define out_pixels(a,b,c,ptr) vec_mstrgb32(typeof(a),((typeof (a))AVV(0)),a,a,a,ptr)
 
 
 static inline void cvtyuvtoRGB (SwsContext *c,
 
 //#define out_pixels(a,b,c,ptr) vec_mstrgb32(typeof(a),((typeof (a))AVV(0)),a,a,a,ptr)
 
 
 static inline void cvtyuvtoRGB (SwsContext *c,
-                          vector signed short Y, vector signed short U, vector signed short V,
-                          vector signed short *R, vector signed short *G, vector signed short *B)
+                                vector signed short Y, vector signed short U, vector signed short V,
+                                vector signed short *R, vector signed short *G, vector signed short *B)
 {
 {
-  vector signed   short vx,ux,uvx;
+    vector signed   short vx,ux,uvx;
 
 
-  Y = vec_mradds (Y, c->CY, c->OY);
-  U  = vec_sub (U,(vector signed short)
-                       vec_splat((vector signed short)AVV(128),0));
-  V  = vec_sub (V,(vector signed short)
-                       vec_splat((vector signed short)AVV(128),0));
+    Y = vec_mradds (Y, c->CY, c->OY);
+    U  = vec_sub (U,(vector signed short)
+                    vec_splat((vector signed short)AVV(128),0));
+    V  = vec_sub (V,(vector signed short)
+                    vec_splat((vector signed short)AVV(128),0));
 
 
-  //   ux  = (CBU*(u<<c->CSHIFT)+0x4000)>>15;
-  ux = vec_sl (U, c->CSHIFT);
-  *B = vec_mradds (ux, c->CBU, Y);
+    //   ux  = (CBU*(u<<c->CSHIFT)+0x4000)>>15;
+    ux = vec_sl (U, c->CSHIFT);
+    *B = vec_mradds (ux, c->CBU, Y);
 
 
-  // vx  = (CRV*(v<<c->CSHIFT)+0x4000)>>15;
-  vx = vec_sl (V, c->CSHIFT);
-  *R = vec_mradds (vx, c->CRV, Y);
+    // vx  = (CRV*(v<<c->CSHIFT)+0x4000)>>15;
+    vx = vec_sl (V, c->CSHIFT);
+    *R = vec_mradds (vx, c->CRV, Y);
 
 
-  // uvx = ((CGU*u) + (CGV*v))>>15;
-  uvx = vec_mradds (U, c->CGU, Y);
-  *G = vec_mradds (V, c->CGV, uvx);
+    // uvx = ((CGU*u) + (CGV*v))>>15;
+    uvx = vec_mradds (U, c->CGU, Y);
+    *G  = vec_mradds (V, c->CGV, uvx);
 }
 
 
 }
 
 
@@ -254,164 +271,168 @@ static inline void cvtyuvtoRGB (SwsContext *c,
 */
 
 
 */
 
 
-#define DEFCSP420_CVT(name,out_pixels)                                     \
-static int altivec_##name (SwsContext *c,                                  \
-                               unsigned char **in, int *instrides,        \
-                               int srcSliceY,  int srcSliceH,             \
-                               unsigned char **oplanes, int *outstrides)  \
-{                                                                         \
-  int w = c->srcW;                                                        \
-  int h = srcSliceH;                                                      \
-  int i,j;                                                                \
-  int instrides_scl[3];                                                           \
-  vector unsigned char y0,y1;                                             \
-                                                                          \
-  vector signed char  u,v;                                                \
-                                                                          \
-  vector signed short Y0,Y1,Y2,Y3;                                        \
-  vector signed short U,V;                                                \
-  vector signed short vx,ux,uvx;                                          \
-  vector signed short vx0,ux0,uvx0;                                       \
-  vector signed short vx1,ux1,uvx1;                                       \
-  vector signed short R0,G0,B0;                                                   \
-  vector signed short R1,G1,B1;                                                   \
-  vector unsigned char R,G,B;                                             \
-                                                                          \
-  vector unsigned char *y1ivP, *y2ivP, *uivP, *vivP;                      \
-  vector unsigned char align_perm;                                        \
-                                                                          \
-  vector signed short                                                     \
-    lCY  = c->CY,                                                         \
-    lOY  = c->OY,                                                         \
-    lCRV = c->CRV,                                                        \
-    lCBU = c->CBU,                                                        \
-    lCGU = c->CGU,                                                        \
-    lCGV = c->CGV;                                                        \
-                                                                          \
-  vector unsigned short lCSHIFT = c->CSHIFT;                              \
-                                                                          \
-  ubyte *y1i   = in[0];                                                           \
-  ubyte *y2i   = in[0]+instrides[0];                                      \
-  ubyte *ui    = in[1];                                                           \
-  ubyte *vi    = in[2];                                                           \
-                                                                          \
-  vector unsigned char *oute                                              \
-    = (vector unsigned char *)                                            \
-        (oplanes[0]+srcSliceY*outstrides[0]);                             \
-  vector unsigned char *outo                                              \
-    = (vector unsigned char *)                                            \
-        (oplanes[0]+srcSliceY*outstrides[0]+outstrides[0]);               \
-                                                                          \
-                                                                          \
-  instrides_scl[0] = instrides[0]*2-w;  /* the loop moves y{1,2}i by w */  \
-  instrides_scl[1] = instrides[1]-w/2;  /* the loop moves ui by w/2 */    \
-  instrides_scl[2] = instrides[2]-w/2;  /* the loop moves vi by w/2 */    \
-                                                                          \
-                                                                          \
-  for (i=0;i<h/2;i++) {                                                           \
-    vec_dstst (outo, (0x02000002|(((w*3+32)/32)<<16)), 0);                 \
-    vec_dstst (oute, (0x02000002|(((w*3+32)/32)<<16)), 1);                 \
-                                                                          \
-    for (j=0;j<w/16;j++) {                                                \
-                                                                          \
-      y1ivP = (vector unsigned char *)y1i;                                \
-      y2ivP = (vector unsigned char *)y2i;                                \
-      uivP = (vector unsigned char *)ui;                                  \
-      vivP = (vector unsigned char *)vi;                                  \
-                                                                          \
-      align_perm = vec_lvsl (0, y1i);                                     \
-      y0 = (vector unsigned char)vec_perm (y1ivP[0], y1ivP[1], align_perm);\
-                                                                          \
-      align_perm = vec_lvsl (0, y2i);                                     \
-      y1 = (vector unsigned char)vec_perm (y2ivP[0], y2ivP[1], align_perm);\
-                                                                          \
-      align_perm = vec_lvsl (0, ui);                                      \
-      u = (vector signed char)vec_perm (uivP[0], uivP[1], align_perm);    \
-                                                                          \
-      align_perm = vec_lvsl (0, vi);                                      \
-      v = (vector signed char)vec_perm (vivP[0], vivP[1], align_perm);    \
-                                                                          \
-      u  = (vector signed char)                                                   \
-               vec_sub (u,(vector signed char)                            \
-                               vec_splat((vector signed char)AVV(128),0));\
-      v  = (vector signed char)                                                   \
-               vec_sub (v,(vector signed char)                            \
-                               vec_splat((vector signed char)AVV(128),0));\
-                                                                          \
-      U  = vec_unpackh (u);                                               \
-      V  = vec_unpackh (v);                                               \
-                                                                          \
-                                                                          \
-       Y0 = vec_unh (y0);                                                 \
-       Y1 = vec_unl (y0);                                                 \
-       Y2 = vec_unh (y1);                                                 \
-       Y3 = vec_unl (y1);                                                 \
-                                                                          \
-        Y0 = vec_mradds (Y0, lCY, lOY);                                           \
-        Y1 = vec_mradds (Y1, lCY, lOY);                                           \
-        Y2 = vec_mradds (Y2, lCY, lOY);                                           \
-        Y3 = vec_mradds (Y3, lCY, lOY);                                           \
-                                                                          \
-       /*   ux  = (CBU*(u<<CSHIFT)+0x4000)>>15 */                         \
-       ux = vec_sl (U, lCSHIFT);                                          \
-       ux = vec_mradds (ux, lCBU, (vector signed short)AVV(0));                   \
-       ux0  = vec_mergeh (ux,ux);                                         \
-       ux1  = vec_mergel (ux,ux);                                         \
-                                                                          \
-       /* vx  = (CRV*(v<<CSHIFT)+0x4000)>>15;  */                         \
-       vx = vec_sl (V, lCSHIFT);                                          \
-       vx = vec_mradds (vx, lCRV, (vector signed short)AVV(0));                   \
-       vx0  = vec_mergeh (vx,vx);                                         \
-       vx1  = vec_mergel (vx,vx);                                         \
-                                                                          \
-       /* uvx = ((CGU*u) + (CGV*v))>>15 */                                \
-       uvx = vec_mradds (U, lCGU, (vector signed short)AVV(0));                   \
-       uvx = vec_mradds (V, lCGV, uvx);                                   \
-       uvx0 = vec_mergeh (uvx,uvx);                                       \
-       uvx1 = vec_mergel (uvx,uvx);                                       \
-                                                                          \
-       R0 = vec_add (Y0,vx0);                                             \
-       G0 = vec_add (Y0,uvx0);                                            \
-       B0 = vec_add (Y0,ux0);                                             \
-       R1 = vec_add (Y1,vx1);                                             \
-       G1 = vec_add (Y1,uvx1);                                            \
-       B1 = vec_add (Y1,ux1);                                             \
-                                                                          \
-       R  = vec_packclp (R0,R1);                                          \
-       G  = vec_packclp (G0,G1);                                          \
-       B  = vec_packclp (B0,B1);                                          \
-                                                                          \
-       out_pixels(R,G,B,oute);                                            \
-                                                                          \
-       R0 = vec_add (Y2,vx0);                                             \
-       G0 = vec_add (Y2,uvx0);                                            \
-       B0 = vec_add (Y2,ux0);                                             \
-       R1 = vec_add (Y3,vx1);                                             \
-       G1 = vec_add (Y3,uvx1);                                            \
-       B1 = vec_add (Y3,ux1);                                             \
-       R  = vec_packclp (R0,R1);                                          \
-       G  = vec_packclp (G0,G1);                                          \
-       B  = vec_packclp (B0,B1);                                          \
-                                                                          \
-                                                                          \
-       out_pixels(R,G,B,outo);                                            \
-                                                                          \
-      y1i  += 16;                                                         \
-      y2i  += 16;                                                         \
-      ui   += 8;                                                          \
-      vi   += 8;                                                          \
-                                                                          \
-    }                                                                     \
-                                                                          \
-    outo += (outstrides[0])>>4;                                                   \
-    oute += (outstrides[0])>>4;                                                   \
-                                                                          \
-    ui    += instrides_scl[1];                                            \
-    vi    += instrides_scl[2];                                            \
-    y1i   += instrides_scl[0];                                            \
-    y2i   += instrides_scl[0];                                            \
-  }                                                                       \
-  return srcSliceH;                                                       \
+#define DEFCSP420_CVT(name,out_pixels)                                  \
+static int altivec_##name (SwsContext *c,                               \
+                           unsigned char **in, int *instrides,          \
+                           int srcSliceY,        int srcSliceH,         \
+                           unsigned char **oplanes, int *outstrides)    \
+{                                                                       \
+    int w = c->srcW;                                                    \
+    int h = srcSliceH;                                                  \
+    int i,j;                                                            \
+    int instrides_scl[3];                                               \
+    vector unsigned char y0,y1;                                         \
+                                                                        \
+    vector signed char  u,v;                                            \
+                                                                        \
+    vector signed short Y0,Y1,Y2,Y3;                                    \
+    vector signed short U,V;                                            \
+    vector signed short vx,ux,uvx;                                      \
+    vector signed short vx0,ux0,uvx0;                                   \
+    vector signed short vx1,ux1,uvx1;                                   \
+    vector signed short R0,G0,B0;                                       \
+    vector signed short R1,G1,B1;                                       \
+    vector unsigned char R,G,B;                                         \
+                                                                        \
+    vector unsigned char *y1ivP, *y2ivP, *uivP, *vivP;                  \
+    vector unsigned char align_perm;                                    \
+                                                                        \
+    vector signed short                                                 \
+        lCY  = c->CY,                                                   \
+        lOY  = c->OY,                                                   \
+        lCRV = c->CRV,                                                  \
+        lCBU = c->CBU,                                                  \
+        lCGU = c->CGU,                                                  \
+        lCGV = c->CGV;                                                  \
+                                                                        \
+    vector unsigned short lCSHIFT = c->CSHIFT;                          \
+                                                                        \
+    ubyte *y1i   = in[0];                                               \
+    ubyte *y2i   = in[0]+instrides[0];                                  \
+    ubyte *ui    = in[1];                                               \
+    ubyte *vi    = in[2];                                               \
+                                                                        \
+    vector unsigned char *oute                                          \
+        = (vector unsigned char *)                                      \
+            (oplanes[0]+srcSliceY*outstrides[0]);                       \
+    vector unsigned char *outo                                          \
+        = (vector unsigned char *)                                      \
+            (oplanes[0]+srcSliceY*outstrides[0]+outstrides[0]);         \
+                                                                        \
+                                                                        \
+    instrides_scl[0] = instrides[0]*2-w;  /* the loop moves y{1,2}i by w */ \
+    instrides_scl[1] = instrides[1]-w/2;  /* the loop moves ui by w/2 */    \
+    instrides_scl[2] = instrides[2]-w/2;  /* the loop moves vi by w/2 */    \
+                                                                        \
+                                                                        \
+    for (i=0;i<h/2;i++) {                                               \
+        vec_dstst (outo, (0x02000002|(((w*3+32)/32)<<16)), 0);          \
+        vec_dstst (oute, (0x02000002|(((w*3+32)/32)<<16)), 1);          \
+                                                                        \
+        for (j=0;j<w/16;j++) {                                          \
+                                                                        \
+            y1ivP = (vector unsigned char *)y1i;                        \
+            y2ivP = (vector unsigned char *)y2i;                        \
+            uivP  = (vector unsigned char *)ui;                         \
+            vivP  = (vector unsigned char *)vi;                         \
+                                                                        \
+            align_perm = vec_lvsl (0, y1i);                             \
+            y0 = (vector unsigned char)                                 \
+                 vec_perm (y1ivP[0], y1ivP[1], align_perm);             \
+                                                                        \
+            align_perm = vec_lvsl (0, y2i);                             \
+            y1 = (vector unsigned char)                                 \
+                 vec_perm (y2ivP[0], y2ivP[1], align_perm);             \
+                                                                        \
+            align_perm = vec_lvsl (0, ui);                              \
+            u = (vector signed char)                                    \
+                vec_perm (uivP[0], uivP[1], align_perm);                \
+                                                                        \
+            align_perm = vec_lvsl (0, vi);                              \
+            v = (vector signed char)                                    \
+                vec_perm (vivP[0], vivP[1], align_perm);                \
+                                                                        \
+            u  = (vector signed char)                                   \
+                 vec_sub (u,(vector signed char)                        \
+                          vec_splat((vector signed char)AVV(128),0));   \
+            v  = (vector signed char)                                   \
+                 vec_sub (v,(vector signed char)                        \
+                          vec_splat((vector signed char)AVV(128),0));   \
+                                                                        \
+            U  = vec_unpackh (u);                                       \
+            V  = vec_unpackh (v);                                       \
+                                                                        \
+                                                                        \
+            Y0 = vec_unh (y0);                                          \
+            Y1 = vec_unl (y0);                                          \
+            Y2 = vec_unh (y1);                                          \
+            Y3 = vec_unl (y1);                                          \
+                                                                        \
+            Y0 = vec_mradds (Y0, lCY, lOY);                             \
+            Y1 = vec_mradds (Y1, lCY, lOY);                             \
+            Y2 = vec_mradds (Y2, lCY, lOY);                             \
+            Y3 = vec_mradds (Y3, lCY, lOY);                             \
+                                                                        \
+            /*   ux  = (CBU*(u<<CSHIFT)+0x4000)>>15 */                  \
+            ux = vec_sl (U, lCSHIFT);                                   \
+            ux = vec_mradds (ux, lCBU, (vector signed short)AVV(0));    \
+            ux0  = vec_mergeh (ux,ux);                                  \
+            ux1  = vec_mergel (ux,ux);                                  \
+                                                                        \
+            /* vx  = (CRV*(v<<CSHIFT)+0x4000)>>15;        */            \
+            vx = vec_sl (V, lCSHIFT);                                   \
+            vx = vec_mradds (vx, lCRV, (vector signed short)AVV(0));    \
+            vx0  = vec_mergeh (vx,vx);                                  \
+            vx1  = vec_mergel (vx,vx);                                  \
+                                                                        \
+            /* uvx = ((CGU*u) + (CGV*v))>>15 */                         \
+            uvx = vec_mradds (U, lCGU, (vector signed short)AVV(0));    \
+            uvx = vec_mradds (V, lCGV, uvx);                            \
+            uvx0 = vec_mergeh (uvx,uvx);                                \
+            uvx1 = vec_mergel (uvx,uvx);                                \
+                                                                        \
+            R0 = vec_add (Y0,vx0);                                      \
+            G0 = vec_add (Y0,uvx0);                                     \
+            B0 = vec_add (Y0,ux0);                                      \
+            R1 = vec_add (Y1,vx1);                                      \
+            G1 = vec_add (Y1,uvx1);                                     \
+            B1 = vec_add (Y1,ux1);                                      \
+                                                                        \
+            R  = vec_packclp (R0,R1);                                   \
+            G  = vec_packclp (G0,G1);                                   \
+            B  = vec_packclp (B0,B1);                                   \
+                                                                        \
+            out_pixels(R,G,B,oute);                                     \
+                                                                        \
+            R0 = vec_add (Y2,vx0);                                      \
+            G0 = vec_add (Y2,uvx0);                                     \
+            B0 = vec_add (Y2,ux0);                                      \
+            R1 = vec_add (Y3,vx1);                                      \
+            G1 = vec_add (Y3,uvx1);                                     \
+            B1 = vec_add (Y3,ux1);                                      \
+            R  = vec_packclp (R0,R1);                                   \
+            G  = vec_packclp (G0,G1);                                   \
+            B  = vec_packclp (B0,B1);                                   \
+                                                                        \
+                                                                        \
+            out_pixels(R,G,B,outo);                                     \
+                                                                        \
+            y1i  += 16;                                                 \
+            y2i  += 16;                                                 \
+            ui   += 8;                                                  \
+            vi   += 8;                                                  \
+                                                                        \
+        }                                                               \
+                                                                        \
+        outo  += (outstrides[0])>>4;                                    \
+        oute  += (outstrides[0])>>4;                                    \
+                                                                        \
+        ui    += instrides_scl[1];                                      \
+        vi    += instrides_scl[2];                                      \
+        y1i   += instrides_scl[0];                                      \
+        y2i   += instrides_scl[0];                                      \
+    }                                                                   \
+    return srcSliceH;                                                   \
 }
 
 
 }
 
 
@@ -426,151 +447,151 @@ DEFCSP420_CVT (yuv2_abgr, out_abgr)
 #if 1
 DEFCSP420_CVT (yuv2_bgra, out_bgra)
 #else
 #if 1
 DEFCSP420_CVT (yuv2_bgra, out_bgra)
 #else
-static int altivec_yuv2_bgra32 (SwsContext *c,                                  
-                               unsigned char **in, int *instrides,        
-                               int srcSliceY,  int srcSliceH,             
-                               unsigned char **oplanes, int *outstrides)  
-{                                                                         
-  int w = c->srcW;                                                        
-  int h = srcSliceH;                                                      
-  int i,j;                                                                
-  int instrides_scl[3];                                                           
-  vector unsigned char y0,y1;                                             
-                                                                          
-  vector signed char  u,v;                                                
-                                                                          
-  vector signed short Y0,Y1,Y2,Y3;                                        
-  vector signed short U,V;                                                
-  vector signed short vx,ux,uvx;                                          
-  vector signed short vx0,ux0,uvx0;                                       
-  vector signed short vx1,ux1,uvx1;                                       
-  vector signed short R0,G0,B0;                                                   
-  vector signed short R1,G1,B1;                                                   
-  vector unsigned char R,G,B;                                             
-                                                                          
-  vector unsigned char *uivP, *vivP;                                      
-  vector unsigned char align_perm;                                        
-                                                                          
-  vector signed short                                                     
-    lCY  = c->CY,                                                         
-    lOY  = c->OY,                                                         
-    lCRV = c->CRV,                                                        
-    lCBU = c->CBU,                                                        
-    lCGU = c->CGU,                                                        
-    lCGV = c->CGV;                                                        
-                                                                          
-  vector unsigned short lCSHIFT = c->CSHIFT;                              
-                                                                          
-  ubyte *y1i   = in[0];                                                           
-  ubyte *y2i   = in[0]+w;                                                 
-  ubyte *ui    = in[1];                                                           
-  ubyte *vi    = in[2];                                                           
-                                                                          
-  vector unsigned char *oute                                              
-    = (vector unsigned char *)                                            
-        (oplanes[0]+srcSliceY*outstrides[0]);                             
-  vector unsigned char *outo                                              
-    = (vector unsigned char *)                                            
-        (oplanes[0]+srcSliceY*outstrides[0]+outstrides[0]);               
-                                                                          
-                                                                          
-  instrides_scl[0] = instrides[0];                                        
-  instrides_scl[1] = instrides[1]-w/2;  /* the loop moves ui by w/2 */    
-  instrides_scl[2] = instrides[2]-w/2;  /* the loop moves vi by w/2 */    
-                                                                          
-                                                                          
-  for (i=0;i<h/2;i++) {                                                           
-    vec_dstst (outo, (0x02000002|(((w*3+32)/32)<<16)), 0);                 
-    vec_dstst (oute, (0x02000002|(((w*3+32)/32)<<16)), 1);                 
-                                                                          
-    for (j=0;j<w/16;j++) {                                                
-                                                                          
-      y0 = vec_ldl (0,y1i);                                               
-      y1 = vec_ldl (0,y2i);                                               
-      uivP = (vector unsigned char *)ui;                                  
-      vivP = (vector unsigned char *)vi;                                  
-                                                                          
-      align_perm = vec_lvsl (0, ui);                                      
-      u = (vector signed char)vec_perm (uivP[0], uivP[1], align_perm);    
-                                                                          
-      align_perm = vec_lvsl (0, vi);                                      
-      v = (vector signed char)vec_perm (vivP[0], vivP[1], align_perm);
-      u  = (vector signed char)
-               vec_sub (u,(vector signed char)
-                               vec_splat((vector signed char)AVV(128),0));
-      
-      v  = (vector signed char)
-               vec_sub (v, (vector signed char)
-                               vec_splat((vector signed char)AVV(128),0));
-      
-      U  = vec_unpackh (u);                                               
-      V  = vec_unpackh (v);                                               
-                                                                          
-                                                                          
-       Y0 = vec_unh (y0);                                                 
-       Y1 = vec_unl (y0);                                                 
-       Y2 = vec_unh (y1);                                                 
-       Y3 = vec_unl (y1);                                                 
-                                                                          
-        Y0 = vec_mradds (Y0, lCY, lOY);                                           
-        Y1 = vec_mradds (Y1, lCY, lOY);                                           
-        Y2 = vec_mradds (Y2, lCY, lOY);                                           
-        Y3 = vec_mradds (Y3, lCY, lOY);                                           
-                                                                          
-       /*   ux  = (CBU*(u<<CSHIFT)+0x4000)>>15 */                         
-       ux = vec_sl (U, lCSHIFT);                                          
-       ux = vec_mradds (ux, lCBU, (vector signed short)AVV(0));
-       ux0  = vec_mergeh (ux,ux);                                         
-       ux1  = vec_mergel (ux,ux);                                         
-                                                                          
-       /* vx  = (CRV*(v<<CSHIFT)+0x4000)>>15;  */                         
-       vx = vec_sl (V, lCSHIFT);                                          
-       vx = vec_mradds (vx, lCRV, (vector signed short)AVV(0));
-       vx0  = vec_mergeh (vx,vx);
-       vx1  = vec_mergel (vx,vx);
-       /* uvx = ((CGU*u) + (CGV*v))>>15 */
-       uvx = vec_mradds (U, lCGU, (vector signed short)AVV(0));
-       uvx = vec_mradds (V, lCGV, uvx);
-       uvx0 = vec_mergeh (uvx,uvx);
-       uvx1 = vec_mergel (uvx,uvx);
-       R0 = vec_add (Y0,vx0);
-       G0 = vec_add (Y0,uvx0);
-       B0 = vec_add (Y0,ux0);
-       R1 = vec_add (Y1,vx1);
-       G1 = vec_add (Y1,uvx1);
-       B1 = vec_add (Y1,ux1);
-       R  = vec_packclp (R0,R1);
-       G  = vec_packclp (G0,G1);
-       B  = vec_packclp (B0,B1);
-       
-       out_argb(R,G,B,oute);
-       R0 = vec_add (Y2,vx0);
-       G0 = vec_add (Y2,uvx0);
-       B0 = vec_add (Y2,ux0);
-       R1 = vec_add (Y3,vx1);
-       G1 = vec_add (Y3,uvx1);
-       B1 = vec_add (Y3,ux1);
-       R  = vec_packclp (R0,R1);
-       G  = vec_packclp (G0,G1);
-       B  = vec_packclp (B0,B1);
-       
-       out_argb(R,G,B,outo);
-       y1i  += 16;                                                        
-       y2i  += 16;                                                        
-       ui   += 8;
-       vi   += 8;                                                         
-                                                                          
-    }                                                                     
-                                                                          
-    outo += (outstrides[0])>>4;                                                   
-    oute += (outstrides[0])>>4;                                                   
-                                                                          
-    ui    += instrides_scl[1];                                            
-    vi    += instrides_scl[2];                                            
-    y1i   += instrides_scl[0];                                            
-    y2i   += instrides_scl[0];                                            
-  }                                                                       
-  return srcSliceH;                                                       
+static int altivec_yuv2_bgra32 (SwsContext *c,
+                                unsigned char **in, int *instrides,
+                                int srcSliceY,        int srcSliceH,
+                                unsigned char **oplanes, int *outstrides)
+{
+    int w = c->srcW;
+    int h = srcSliceH;
+    int i,j;
+    int instrides_scl[3];
+    vector unsigned char y0,y1;
+
+    vector signed char  u,v;
+
+    vector signed short Y0,Y1,Y2,Y3;
+    vector signed short U,V;
+    vector signed short vx,ux,uvx;
+    vector signed short vx0,ux0,uvx0;
+    vector signed short vx1,ux1,uvx1;
+    vector signed short R0,G0,B0;
+    vector signed short R1,G1,B1;
+    vector unsigned char R,G,B;
+
+    vector unsigned char *uivP, *vivP;
+    vector unsigned char align_perm;
+
+    vector signed short
+        lCY  = c->CY,
+        lOY  = c->OY,
+        lCRV = c->CRV,
+        lCBU = c->CBU,
+        lCGU = c->CGU,
+        lCGV = c->CGV;
+
+    vector unsigned short lCSHIFT = c->CSHIFT;
+
+    ubyte *y1i   = in[0];
+    ubyte *y2i   = in[0]+w;
+    ubyte *ui    = in[1];
+    ubyte *vi    = in[2];
+
+    vector unsigned char *oute
+        = (vector unsigned char *)
+          (oplanes[0]+srcSliceY*outstrides[0]);
+    vector unsigned char *outo
+        = (vector unsigned char *)
+          (oplanes[0]+srcSliceY*outstrides[0]+outstrides[0]);
+
+
+    instrides_scl[0] = instrides[0];
+    instrides_scl[1] = instrides[1]-w/2;  /* the loop moves ui by w/2 */
+    instrides_scl[2] = instrides[2]-w/2;  /* the loop moves vi by w/2 */
+
+
+    for (i=0;i<h/2;i++) {
+        vec_dstst (outo, (0x02000002|(((w*3+32)/32)<<16)), 0);
+        vec_dstst (oute, (0x02000002|(((w*3+32)/32)<<16)), 1);
+
+        for (j=0;j<w/16;j++) {
+
+            y0 = vec_ldl (0,y1i);
+            y1 = vec_ldl (0,y2i);
+            uivP = (vector unsigned char *)ui;
+            vivP = (vector unsigned char *)vi;
+
+            align_perm = vec_lvsl (0, ui);
+            u  = (vector signed char)vec_perm (uivP[0], uivP[1], align_perm);
+
+            align_perm = vec_lvsl (0, vi);
+            v  = (vector signed char)vec_perm (vivP[0], vivP[1], align_perm);
+            u  = (vector signed char)
+                 vec_sub (u,(vector signed char)
+                          vec_splat((vector signed char)AVV(128),0));
+
+            v  = (vector signed char)
+                 vec_sub (v, (vector signed char)
+                          vec_splat((vector signed char)AVV(128),0));
+
+            U  = vec_unpackh (u);
+            V  = vec_unpackh (v);
+
+
+            Y0 = vec_unh (y0);
+            Y1 = vec_unl (y0);
+            Y2 = vec_unh (y1);
+            Y3 = vec_unl (y1);
+
+            Y0 = vec_mradds (Y0, lCY, lOY);
+            Y1 = vec_mradds (Y1, lCY, lOY);
+            Y2 = vec_mradds (Y2, lCY, lOY);
+            Y3 = vec_mradds (Y3, lCY, lOY);
+
+            /*   ux  = (CBU*(u<<CSHIFT)+0x4000)>>15 */
+            ux = vec_sl (U, lCSHIFT);
+            ux = vec_mradds (ux, lCBU, (vector signed short)AVV(0));
+            ux0  = vec_mergeh (ux,ux);
+            ux1  = vec_mergel (ux,ux);
+
+            /* vx  = (CRV*(v<<CSHIFT)+0x4000)>>15;        */
+            vx = vec_sl (V, lCSHIFT);
+            vx = vec_mradds (vx, lCRV, (vector signed short)AVV(0));
+            vx0  = vec_mergeh (vx,vx);
+            vx1  = vec_mergel (vx,vx);
+            /* uvx = ((CGU*u) + (CGV*v))>>15 */
+            uvx = vec_mradds (U, lCGU, (vector signed short)AVV(0));
+            uvx = vec_mradds (V, lCGV, uvx);
+            uvx0 = vec_mergeh (uvx,uvx);
+            uvx1 = vec_mergel (uvx,uvx);
+            R0 = vec_add (Y0,vx0);
+            G0 = vec_add (Y0,uvx0);
+            B0 = vec_add (Y0,ux0);
+            R1 = vec_add (Y1,vx1);
+            G1 = vec_add (Y1,uvx1);
+            B1 = vec_add (Y1,ux1);
+            R  = vec_packclp (R0,R1);
+            G  = vec_packclp (G0,G1);
+            B  = vec_packclp (B0,B1);
+
+            out_argb(R,G,B,oute);
+            R0 = vec_add (Y2,vx0);
+            G0 = vec_add (Y2,uvx0);
+            B0 = vec_add (Y2,ux0);
+            R1 = vec_add (Y3,vx1);
+            G1 = vec_add (Y3,uvx1);
+            B1 = vec_add (Y3,ux1);
+            R  = vec_packclp (R0,R1);
+            G  = vec_packclp (G0,G1);
+            B  = vec_packclp (B0,B1);
+
+            out_argb(R,G,B,outo);
+            y1i  += 16;
+            y2i  += 16;
+            ui   += 8;
+            vi   += 8;
+
+        }
+
+        outo  += (outstrides[0])>>4;
+        oute  += (outstrides[0])>>4;
+
+        ui    += instrides_scl[1];
+        vi    += instrides_scl[2];
+        y1i   += instrides_scl[0];
+        y2i   += instrides_scl[0];
+    }
+    return srcSliceH;
 }
 
 #endif
 }
 
 #endif
@@ -586,78 +607,77 @@ DEFCSP420_CVT (yuv2_bgr24,  out_bgr24)
 // 0123 4567 89ab cdef
 static
 const vector unsigned char
 // 0123 4567 89ab cdef
 static
 const vector unsigned char
-  demux_u = (const vector unsigned char)AVV(0x10,0x00,0x10,0x00,
-                                  0x10,0x04,0x10,0x04,
-                                  0x10,0x08,0x10,0x08,
-                                  0x10,0x0c,0x10,0x0c),
-  demux_v = (const vector unsigned char)AVV(0x10,0x02,0x10,0x02,
-                                  0x10,0x06,0x10,0x06,
-                                  0x10,0x0A,0x10,0x0A,
-                                  0x10,0x0E,0x10,0x0E),
-  demux_y = (const vector unsigned char)AVV(0x10,0x01,0x10,0x03,
-                                  0x10,0x05,0x10,0x07,
-                                  0x10,0x09,0x10,0x0B,
-                                  0x10,0x0D,0x10,0x0F);
+    demux_u = (const vector unsigned char)AVV(0x10,0x00,0x10,0x00,
+                                              0x10,0x04,0x10,0x04,
+                                              0x10,0x08,0x10,0x08,
+                                              0x10,0x0c,0x10,0x0c),
+    demux_v = (const vector unsigned char)AVV(0x10,0x02,0x10,0x02,
+                                              0x10,0x06,0x10,0x06,
+                                              0x10,0x0A,0x10,0x0A,
+                                              0x10,0x0E,0x10,0x0E),
+    demux_y = (const vector unsigned char)AVV(0x10,0x01,0x10,0x03,
+                                              0x10,0x05,0x10,0x07,
+                                              0x10,0x09,0x10,0x0B,
+                                              0x10,0x0D,0x10,0x0F);
 
 /*
   this is so I can play live CCIR raw video
 */
 static int altivec_uyvy_rgb32 (SwsContext *c,
 
 /*
   this is so I can play live CCIR raw video
 */
 static int altivec_uyvy_rgb32 (SwsContext *c,
-                              unsigned char **in, int *instrides,
-                              int srcSliceY,   int srcSliceH,
-                              unsigned char **oplanes, int *outstrides)
+                               unsigned char **in, int *instrides,
+                               int srcSliceY,        int srcSliceH,
+                               unsigned char **oplanes, int *outstrides)
 {
 {
-  int w = c->srcW;
-  int h = srcSliceH;
-  int i,j;
-  vector unsigned char uyvy;
-  vector signed   short Y,U,V;
-  vector signed   short vx,ux,uvx;
-  vector signed   short R0,G0,B0,R1,G1,B1;
-  vector unsigned char  R,G,B;
-  vector unsigned char *out;
-  ubyte *img;
+    int w = c->srcW;
+    int h = srcSliceH;
+    int i,j;
+    vector unsigned char uyvy;
+    vector signed   short Y,U,V;
+    vector signed   short R0,G0,B0,R1,G1,B1;
+    vector unsigned char  R,G,B;
+    vector unsigned char *out;
+    ubyte *img;
 
 
-  img = in[0];
-  out = (vector unsigned char *)(oplanes[0]+srcSliceY*outstrides[0]);
+    img = in[0];
+    out = (vector unsigned char *)(oplanes[0]+srcSliceY*outstrides[0]);
 
 
-  for (i=0;i<h;i++) {
-    for (j=0;j<w/16;j++) {
-      uyvy = vec_ld (0, img);
-      U = (vector signed short)
-       vec_perm (uyvy, (vector unsigned char)AVV(0), demux_u);
+    for (i=0;i<h;i++) {
+        for (j=0;j<w/16;j++) {
+            uyvy = vec_ld (0, img);
+            U = (vector signed short)
+                vec_perm (uyvy, (vector unsigned char)AVV(0), demux_u);
 
 
-      V = (vector signed short)
-       vec_perm (uyvy, (vector unsigned char)AVV(0), demux_v);
+            V = (vector signed short)
+                vec_perm (uyvy, (vector unsigned char)AVV(0), demux_v);
 
 
-      Y = (vector signed short)
-       vec_perm (uyvy, (vector unsigned char)AVV(0), demux_y);
+            Y = (vector signed short)
+                vec_perm (uyvy, (vector unsigned char)AVV(0), demux_y);
 
 
-      cvtyuvtoRGB (c, Y,U,V,&R0,&G0,&B0);
+            cvtyuvtoRGB (c, Y,U,V,&R0,&G0,&B0);
 
 
-      uyvy = vec_ld (16, img);
-      U = (vector signed short)
-       vec_perm (uyvy, (vector unsigned char)AVV(0), demux_u);
+            uyvy = vec_ld (16, img);
+            U = (vector signed short)
+                vec_perm (uyvy, (vector unsigned char)AVV(0), demux_u);
 
 
-      V = (vector signed short)
-       vec_perm (uyvy, (vector unsigned char)AVV(0), demux_v);
+            V = (vector signed short)
+                vec_perm (uyvy, (vector unsigned char)AVV(0), demux_v);
 
 
-      Y = (vector signed short)
-       vec_perm (uyvy, (vector unsigned char)AVV(0), demux_y);
+            Y = (vector signed short)
+                vec_perm (uyvy, (vector unsigned char)AVV(0), demux_y);
 
 
-      cvtyuvtoRGB (c, Y,U,V,&R1,&G1,&B1);
+            cvtyuvtoRGB (c, Y,U,V,&R1,&G1,&B1);
 
 
-      R  = vec_packclp (R0,R1);
-      G  = vec_packclp (G0,G1);
-      B  = vec_packclp (B0,B1);
+            R  = vec_packclp (R0,R1);
+            G  = vec_packclp (G0,G1);
+            B  = vec_packclp (B0,B1);
 
 
-      //      vec_mstbgr24 (R,G,B, out);
-      out_rgba (R,G,B,out);
+            //      vec_mstbgr24 (R,G,B, out);
+            out_rgba (R,G,B,out);
 
 
-      img += 32;
+            img += 32;
+        }
     }
     }
-  }
-  return srcSliceH;
+    return srcSliceH;
 }
 
 
 }
 
 
@@ -670,283 +690,278 @@ static int altivec_uyvy_rgb32 (SwsContext *c,
 */
 SwsFunc yuv2rgb_init_altivec (SwsContext *c)
 {
 */
 SwsFunc yuv2rgb_init_altivec (SwsContext *c)
 {
-  if (!(c->flags & SWS_CPU_CAPS_ALTIVEC))    
-    return NULL;
+    if (!(c->flags & SWS_CPU_CAPS_ALTIVEC))
+        return NULL;
 
 
-  /*
-    and this seems not to matter too much I tried a bunch of 
-    videos with abnormal widths and mplayer crashes else where.
-    mplayer -vo x11 -rawvideo on:w=350:h=240 raw-350x240.eyuv 
-    boom with X11 bad match.
-    
-  */
-  if ((c->srcW & 0xf) != 0)    return NULL;
-
-  switch (c->srcFormat) {
-  case IMGFMT_YVU9:
-  case IMGFMT_IF09:
-  case IMGFMT_YV12:
-  case IMGFMT_I420:
-  case IMGFMT_IYUV:
-  case IMGFMT_CLPL:
-  case IMGFMT_Y800:
-  case IMGFMT_Y8:
-  case IMGFMT_NV12:
-  case IMGFMT_NV21:
-    if ((c->srcH & 0x1) != 0)
-      return NULL;
-
-    switch(c->dstFormat){
-    case IMGFMT_RGB24:
-      MSG_WARN("ALTIVEC: Color Space RGB24\n");
-      return altivec_yuv2_rgb24;
-    case IMGFMT_BGR24:
-      MSG_WARN("ALTIVEC: Color Space BGR24\n");
-      return altivec_yuv2_bgr24;
-    case IMGFMT_ARGB:
-      MSG_WARN("ALTIVEC: Color Space ARGB\n");
-      return altivec_yuv2_argb;
-    case IMGFMT_ABGR:
-      MSG_WARN("ALTIVEC: Color Space ABGR\n");
-      return altivec_yuv2_abgr;
-    case IMGFMT_RGBA:
-      MSG_WARN("ALTIVEC: Color Space RGBA\n");
-      return altivec_yuv2_rgba;
-    case IMGFMT_BGRA:
-      MSG_WARN("ALTIVEC: Color Space BGRA\n");
-      return altivec_yuv2_bgra;
-    default: return NULL;
-    }
-    break;
-
-  case IMGFMT_UYVY:
-    switch(c->dstFormat){
-    case IMGFMT_RGB32:
-      MSG_WARN("ALTIVEC: Color Space UYVY -> RGB32\n");
-      return altivec_uyvy_rgb32;
-    default: return NULL;
-    }
-    break;
+    /*
+      and this seems not to matter too much I tried a bunch of
+      videos with abnormal widths and mplayer crashes else where.
+      mplayer -vo x11 -rawvideo on:w=350:h=240 raw-350x240.eyuv
+      boom with X11 bad match.
 
 
-  }
-  return NULL;
+    */
+    if ((c->srcW & 0xf) != 0)    return NULL;
+
+    switch (c->srcFormat) {
+    case PIX_FMT_YUV410P:
+    case PIX_FMT_YUV420P:
+    /*case IMGFMT_CLPL:        ??? */
+    case PIX_FMT_GRAY8:
+    case PIX_FMT_NV12:
+    case PIX_FMT_NV21:
+        if ((c->srcH & 0x1) != 0)
+            return NULL;
+
+        switch(c->dstFormat){
+        case PIX_FMT_RGB24:
+            av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space RGB24\n");
+            return altivec_yuv2_rgb24;
+        case PIX_FMT_BGR24:
+            av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space BGR24\n");
+            return altivec_yuv2_bgr24;
+        case PIX_FMT_ARGB:
+            av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space ARGB\n");
+            return altivec_yuv2_argb;
+        case PIX_FMT_ABGR:
+            av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space ABGR\n");
+            return altivec_yuv2_abgr;
+        case PIX_FMT_RGBA:
+            av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space RGBA\n");
+            return altivec_yuv2_rgba;
+        case PIX_FMT_BGRA:
+            av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space BGRA\n");
+            return altivec_yuv2_bgra;
+        default: return NULL;
+        }
+        break;
+
+    case PIX_FMT_UYVY422:
+        switch(c->dstFormat){
+        case PIX_FMT_BGR32:
+            av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space UYVY -> RGB32\n");
+            return altivec_uyvy_rgb32;
+        default: return NULL;
+        }
+        break;
+
+    }
+    return NULL;
 }
 
 static uint16_t roundToInt16(int64_t f){
 }
 
 static uint16_t roundToInt16(int64_t f){
-       int r= (f + (1<<15))>>16;
-            if(r<-0x7FFF) return 0x8000;
-       else if(r> 0x7FFF) return 0x7FFF;
-       else               return r;
+    int r= (f + (1<<15))>>16;
+         if (r<-0x7FFF) return 0x8000;
+    else if (r> 0x7FFF) return 0x7FFF;
+    else                return r;
 }
 
 void yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4],int brightness,int contrast, int saturation)
 {
 }
 
 void yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4],int brightness,int contrast, int saturation)
 {
-  union {
-       signed short tmp[8] __attribute__ ((aligned(16)));
-       vector signed short vec;
-       } buf;
-
-  buf.tmp[0] =  ( (0xffffLL) * contrast>>8 )>>9;                       //cy
-  buf.tmp[1] =  -256*brightness;                                       //oy
-  buf.tmp[2] =  (inv_table[0]>>3) *(contrast>>16)*(saturation>>16);    //crv
-  buf.tmp[3] =  (inv_table[1]>>3) *(contrast>>16)*(saturation>>16);    //cbu
-  buf.tmp[4] = -((inv_table[2]>>1)*(contrast>>16)*(saturation>>16));   //cgu
-  buf.tmp[5] = -((inv_table[3]>>1)*(contrast>>16)*(saturation>>16));   //cgv
-
-
-  c->CSHIFT = (vector unsigned short)vec_splat_u16(2);
-  c->CY  = vec_splat ((vector signed short)buf.vec, 0);
-  c->OY  = vec_splat ((vector signed short)buf.vec, 1);
-  c->CRV  = vec_splat ((vector signed short)buf.vec, 2);
-  c->CBU  = vec_splat ((vector signed short)buf.vec, 3);
-  c->CGU  = vec_splat ((vector signed short)buf.vec, 4);
-  c->CGV  = vec_splat ((vector signed short)buf.vec, 5);
+    union {
+        signed short tmp[8] __attribute__ ((aligned(16)));
+        vector signed short vec;
+    } buf;
+
+    buf.tmp[0] =  ((0xffffLL) * contrast>>8)>>9;                        //cy
+    buf.tmp[1] =  -256*brightness;                                      //oy
+    buf.tmp[2] =  (inv_table[0]>>3) *(contrast>>16)*(saturation>>16);   //crv
+    buf.tmp[3] =  (inv_table[1]>>3) *(contrast>>16)*(saturation>>16);   //cbu
+    buf.tmp[4] = -((inv_table[2]>>1)*(contrast>>16)*(saturation>>16));  //cgu
+    buf.tmp[5] = -((inv_table[3]>>1)*(contrast>>16)*(saturation>>16));  //cgv
+
+
+    c->CSHIFT = (vector unsigned short)vec_splat_u16(2);
+    c->CY   = vec_splat ((vector signed short)buf.vec, 0);
+    c->OY   = vec_splat ((vector signed short)buf.vec, 1);
+    c->CRV  = vec_splat ((vector signed short)buf.vec, 2);
+    c->CBU  = vec_splat ((vector signed short)buf.vec, 3);
+    c->CGU  = vec_splat ((vector signed short)buf.vec, 4);
+    c->CGV  = vec_splat ((vector signed short)buf.vec, 5);
 #if 0
 #if 0
-{
-int i;
-char *v[6]={"cy","oy","crv","cbu","cgu","cgv"};
-for (i=0; i<6;i++)
-  printf("%s %d ", v[i],buf.tmp[i] );
-  printf("\n");
-}
+    {
+    int i;
+    char *v[6]={"cy","oy","crv","cbu","cgu","cgv"};
+    for (i=0; i<6; i++)
+        printf("%s %d ", v[i],buf.tmp[i] );
+        printf("\n");
+    }
 #endif
 #endif
- return;
   return;
 }
 
 
 void
 altivec_yuv2packedX (SwsContext *c,
 }
 
 
 void
 altivec_yuv2packedX (SwsContext *c,
-                      int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
-                      int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
-                      uint8_t *dest, int dstW, int dstY)
+                     int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
+                     int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
+                     uint8_t *dest, int dstW, int dstY)
 {
 {
-  int i,j;
-  short *f;
-  vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;
-  vector signed short R0,G0,B0,R1,G1,B1;
-
-  vector unsigned char R,G,B,pels[3];
-  vector unsigned char *out,*nout;
-
-  vector signed short   RND = vec_splat_s16(1<<3);
-  vector unsigned short SCL = vec_splat_u16(4);
-  unsigned long scratch[16] __attribute__ ((aligned (16)));
-
-  vector signed short *YCoeffs, *CCoeffs;
-
-  YCoeffs = c->vYCoeffsBank+dstY*lumFilterSize;
-  CCoeffs = c->vCCoeffsBank+dstY*chrFilterSize;
-
-  out = (vector unsigned char *)dest;
-
-  for(i=0; i<dstW; i+=16){
-    Y0 = RND;
-    Y1 = RND;
-    /* extract 16 coeffs from lumSrc */
-    for(j=0; j<lumFilterSize; j++) {
-      X0 = vec_ld (0,  &lumSrc[j][i]);
-      X1 = vec_ld (16, &lumSrc[j][i]);
-      Y0 = vec_mradds (X0, YCoeffs[j], Y0);
-      Y1 = vec_mradds (X1, YCoeffs[j], Y1);
-    }
+    int i,j;
+    vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;
+    vector signed short R0,G0,B0,R1,G1,B1;
 
 
-    U = RND;
-    V = RND;
-    /* extract 8 coeffs from U,V */
-    for(j=0; j<chrFilterSize; j++) {
-      X  = vec_ld (0, &chrSrc[j][i/2]);
-      U  = vec_mradds (X, CCoeffs[j], U);
-      X  = vec_ld (0, &chrSrc[j][i/2+2048]);
-      V  = vec_mradds (X, CCoeffs[j], V);
-    }
+    vector unsigned char R,G,B;
+    vector unsigned char *out,*nout;
 
 
-    /* scale and clip signals */
-    Y0 = vec_sra (Y0, SCL);
-    Y1 = vec_sra (Y1, SCL);
-    U  = vec_sra (U,  SCL);
-    V  = vec_sra (V,  SCL);
+    vector signed short   RND = vec_splat_s16(1<<3);
+    vector unsigned short SCL = vec_splat_u16(4);
+    unsigned long scratch[16] __attribute__ ((aligned (16)));
 
 
-    Y0 = vec_clip_s16 (Y0);
-    Y1 = vec_clip_s16 (Y1);
-    U  = vec_clip_s16 (U);
-    V  = vec_clip_s16 (V);
+    vector signed short *YCoeffs, *CCoeffs;
 
 
-    /* now we have
-      Y0= y0 y1 y2 y3 y4 y5 y6 y7     Y1= y8 y9 y10 y11 y12 y13 y14 y15
-      U= u0 u1 u2 u3 u4 u5 u6 u7      V= v0 v1 v2 v3 v4 v5 v6 v7
+    YCoeffs = c->vYCoeffsBank+dstY*lumFilterSize;
+    CCoeffs = c->vCCoeffsBank+dstY*chrFilterSize;
 
 
-      Y0= y0 y1 y2 y3 y4 y5 y6 y7    Y1= y8 y9 y10 y11 y12 y13 y14 y15
-      U0= u0 u0 u1 u1 u2 u2 u3 u3    U1= u4 u4 u5 u5 u6 u6 u7 u7
-      V0= v0 v0 v1 v1 v2 v2 v3 v3    V1= v4 v4 v5 v5 v6 v6 v7 v7
-    */
+    out = (vector unsigned char *)dest;
 
 
-    U0 = vec_mergeh (U,U);
-    V0 = vec_mergeh (V,V);
-
-    U1 = vec_mergel (U,U);
-    V1 = vec_mergel (V,V);
-
-    cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
-    cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
-
-    R  = vec_packclp (R0,R1);
-    G  = vec_packclp (G0,G1);
-    B  = vec_packclp (B0,B1);
-
-    switch(c->dstFormat) {
-      case IMGFMT_ABGR: out_abgr (R,G,B,out); break;
-      case IMGFMT_BGRA: out_bgra (R,G,B,out); break;
-      case IMGFMT_RGBA: out_rgba (R,G,B,out); break;
-      case IMGFMT_ARGB: out_argb (R,G,B,out); break;
-      case IMGFMT_RGB24: out_rgb24 (R,G,B,out); break;
-      case IMGFMT_BGR24: out_bgr24 (R,G,B,out); break;
-      default:
-        {
-          /* If this is reached, the caller should have called yuv2packedXinC
-             instead. */
-          static int printed_error_message;
-          if(!printed_error_message) {
-            MSG_ERR("altivec_yuv2packedX doesn't support %s output\n",
-                    sws_format_name(c->dstFormat));
-            printed_error_message=1;
-          }
-          return;
+    for (i=0; i<dstW; i+=16){
+        Y0 = RND;
+        Y1 = RND;
+        /* extract 16 coeffs from lumSrc */
+        for (j=0; j<lumFilterSize; j++) {
+            X0 = vec_ld (0,  &lumSrc[j][i]);
+            X1 = vec_ld (16, &lumSrc[j][i]);
+            Y0 = vec_mradds (X0, YCoeffs[j], Y0);
+            Y1 = vec_mradds (X1, YCoeffs[j], Y1);
         }
         }
-    }
-  }
-
-  if (i < dstW) {
-    i -= 16;
-
-    Y0 = RND;
-    Y1 = RND;
-    /* extract 16 coeffs from lumSrc */
-    for(j=0; j<lumFilterSize; j++) {
-      X0 = vec_ld (0,  &lumSrc[j][i]);
-      X1 = vec_ld (16, &lumSrc[j][i]);
-      Y0 = vec_mradds (X0, YCoeffs[j], Y0);
-      Y1 = vec_mradds (X1, YCoeffs[j], Y1);
-    }
 
 
-    U = RND;
-    V = RND;
-    /* extract 8 coeffs from U,V */
-    for(j=0; j<chrFilterSize; j++) {
-      X  = vec_ld (0, &chrSrc[j][i/2]);
-      U  = vec_mradds (X, CCoeffs[j], U);
-      X  = vec_ld (0, &chrSrc[j][i/2+2048]);
-      V  = vec_mradds (X, CCoeffs[j], V);
-    }
+        U = RND;
+        V = RND;
+        /* extract 8 coeffs from U,V */
+        for (j=0; j<chrFilterSize; j++) {
+            X  = vec_ld (0, &chrSrc[j][i/2]);
+            U  = vec_mradds (X, CCoeffs[j], U);
+            X  = vec_ld (0, &chrSrc[j][i/2+2048]);
+            V  = vec_mradds (X, CCoeffs[j], V);
+        }
 
 
-    /* scale and clip signals */
-    Y0 = vec_sra (Y0, SCL);
-    Y1 = vec_sra (Y1, SCL);
-    U  = vec_sra (U,  SCL);
-    V  = vec_sra (V,  SCL);
+        /* scale and clip signals */
+        Y0 = vec_sra (Y0, SCL);
+        Y1 = vec_sra (Y1, SCL);
+        U  = vec_sra (U,  SCL);
+        V  = vec_sra (V,  SCL);
+
+        Y0 = vec_clip_s16 (Y0);
+        Y1 = vec_clip_s16 (Y1);
+        U  = vec_clip_s16 (U);
+        V  = vec_clip_s16 (V);
+
+        /* now we have
+          Y0= y0 y1 y2 y3 y4 y5 y6 y7     Y1= y8 y9 y10 y11 y12 y13 y14 y15
+          U= u0 u1 u2 u3 u4 u5 u6 u7      V= v0 v1 v2 v3 v4 v5 v6 v7
+
+          Y0= y0 y1 y2 y3 y4 y5 y6 y7    Y1= y8 y9 y10 y11 y12 y13 y14 y15
+          U0= u0 u0 u1 u1 u2 u2 u3 u3    U1= u4 u4 u5 u5 u6 u6 u7 u7
+          V0= v0 v0 v1 v1 v2 v2 v3 v3    V1= v4 v4 v5 v5 v6 v6 v7 v7
+        */
+
+        U0 = vec_mergeh (U,U);
+        V0 = vec_mergeh (V,V);
+
+        U1 = vec_mergel (U,U);
+        V1 = vec_mergel (V,V);
+
+        cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
+        cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
+
+        R  = vec_packclp (R0,R1);
+        G  = vec_packclp (G0,G1);
+        B  = vec_packclp (B0,B1);
+
+        switch(c->dstFormat) {
+            case PIX_FMT_ABGR:  out_abgr  (R,G,B,out); break;
+            case PIX_FMT_BGRA:  out_bgra  (R,G,B,out); break;
+            case PIX_FMT_RGBA:  out_rgba  (R,G,B,out); break;
+            case PIX_FMT_ARGB:  out_argb  (R,G,B,out); break;
+            case PIX_FMT_RGB24: out_rgb24 (R,G,B,out); break;
+            case PIX_FMT_BGR24: out_bgr24 (R,G,B,out); break;
+            default:
+            {
+                /* If this is reached, the caller should have called yuv2packedXinC
+                   instead. */
+                static int printed_error_message;
+                if (!printed_error_message) {
+                    av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
+                           sws_format_name(c->dstFormat));
+                    printed_error_message=1;
+                }
+                return;
+            }
+        }
+    }
 
 
-    Y0 = vec_clip_s16 (Y0);
-    Y1 = vec_clip_s16 (Y1);
-    U  = vec_clip_s16 (U);
-    V  = vec_clip_s16 (V);
+    if (i < dstW) {
+        i -= 16;
+
+        Y0 = RND;
+        Y1 = RND;
+        /* extract 16 coeffs from lumSrc */
+        for (j=0; j<lumFilterSize; j++) {
+            X0 = vec_ld (0,  &lumSrc[j][i]);
+            X1 = vec_ld (16, &lumSrc[j][i]);
+            Y0 = vec_mradds (X0, YCoeffs[j], Y0);
+            Y1 = vec_mradds (X1, YCoeffs[j], Y1);
+        }
 
 
-    /* now we have
-       Y0= y0 y1 y2 y3 y4 y5 y6 y7     Y1= y8 y9 y10 y11 y12 y13 y14 y15
-       U= u0 u1 u2 u3 u4 u5 u6 u7      V= v0 v1 v2 v3 v4 v5 v6 v7
+        U = RND;
+        V = RND;
+        /* extract 8 coeffs from U,V */
+        for (j=0; j<chrFilterSize; j++) {
+            X  = vec_ld (0, &chrSrc[j][i/2]);
+            U  = vec_mradds (X, CCoeffs[j], U);
+            X  = vec_ld (0, &chrSrc[j][i/2+2048]);
+            V  = vec_mradds (X, CCoeffs[j], V);
+        }
 
 
-       Y0= y0 y1 y2 y3 y4 y5 y6 y7    Y1= y8 y9 y10 y11 y12 y13 y14 y15
-       U0= u0 u0 u1 u1 u2 u2 u3 u3    U1= u4 u4 u5 u5 u6 u6 u7 u7
-       V0= v0 v0 v1 v1 v2 v2 v3 v3    V1= v4 v4 v5 v5 v6 v6 v7 v7
-    */
+        /* scale and clip signals */
+        Y0 = vec_sra (Y0, SCL);
+        Y1 = vec_sra (Y1, SCL);
+        U  = vec_sra (U,  SCL);
+        V  = vec_sra (V,  SCL);
+
+        Y0 = vec_clip_s16 (Y0);
+        Y1 = vec_clip_s16 (Y1);
+        U  = vec_clip_s16 (U);
+        V  = vec_clip_s16 (V);
+
+        /* now we have
+           Y0= y0 y1 y2 y3 y4 y5 y6 y7     Y1= y8 y9 y10 y11 y12 y13 y14 y15
+           U = u0 u1 u2 u3 u4 u5 u6 u7     V = v0 v1 v2 v3 v4 v5 v6 v7
+
+           Y0= y0 y1 y2 y3 y4 y5 y6 y7    Y1= y8 y9 y10 y11 y12 y13 y14 y15
+           U0= u0 u0 u1 u1 u2 u2 u3 u3    U1= u4 u4 u5 u5 u6 u6 u7 u7
+           V0= v0 v0 v1 v1 v2 v2 v3 v3    V1= v4 v4 v5 v5 v6 v6 v7 v7
+        */
+
+        U0 = vec_mergeh (U,U);
+        V0 = vec_mergeh (V,V);
+
+        U1 = vec_mergel (U,U);
+        V1 = vec_mergel (V,V);
+
+        cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
+        cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
+
+        R  = vec_packclp (R0,R1);
+        G  = vec_packclp (G0,G1);
+        B  = vec_packclp (B0,B1);
+
+        nout = (vector unsigned char *)scratch;
+        switch(c->dstFormat) {
+            case PIX_FMT_ABGR:  out_abgr  (R,G,B,nout); break;
+            case PIX_FMT_BGRA:  out_bgra  (R,G,B,nout); break;
+            case PIX_FMT_RGBA:  out_rgba  (R,G,B,nout); break;
+            case PIX_FMT_ARGB:  out_argb  (R,G,B,nout); break;
+            case PIX_FMT_RGB24: out_rgb24 (R,G,B,nout); break;
+            case PIX_FMT_BGR24: out_bgr24 (R,G,B,nout); break;
+            default:
+                /* Unreachable, I think. */
+                av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
+                       sws_format_name(c->dstFormat));
+                return;
+        }
 
 
-    U0 = vec_mergeh (U,U);
-    V0 = vec_mergeh (V,V);
-
-    U1 = vec_mergel (U,U);
-    V1 = vec_mergel (V,V);
-
-    cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
-    cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
-
-    R  = vec_packclp (R0,R1);
-    G  = vec_packclp (G0,G1);
-    B  = vec_packclp (B0,B1);
-
-    nout = (vector unsigned char *)scratch;
-    switch(c->dstFormat) {
-      case IMGFMT_ABGR: out_abgr (R,G,B,nout); break;
-      case IMGFMT_BGRA: out_bgra (R,G,B,nout); break;
-      case IMGFMT_RGBA: out_rgba (R,G,B,nout); break;
-      case IMGFMT_ARGB: out_argb (R,G,B,nout); break;
-      case IMGFMT_RGB24: out_rgb24 (R,G,B,nout); break;
-      case IMGFMT_BGR24: out_bgr24 (R,G,B,nout); break;
-      default:
-        /* Unreachable, I think. */
-        MSG_ERR("altivec_yuv2packedX doesn't support %s output\n",
-                sws_format_name(c->dstFormat));
-        return;
+        memcpy (&((uint32_t*)dest)[i], scratch, (dstW-i)/4);
     }
 
     }
 
-    memcpy (&((uint32_t*)dest)[i], scratch, (dstW-i)/4);
-  }
-
 }
 }