Fix compilation of non-MMX code with gcc 2.95
[ffmpeg.git] / libswscale / swscale_altivec_template.c
index d4a3820..d65c285 100644 (file)
@@ -1,24 +1,25 @@
 /*
-  AltiVec-enhanced yuv2yuvX
-
-    Copyright (C) 2004 Romain Dolbeau <romain@dolbeau.org>
-    based on the equivalent C code in "postproc/swscale.c"
-
-
-    This program 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.
-
-    This program 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 this program; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
+ * AltiVec-enhanced yuv2yuvX
+ *
+ * Copyright (C) 2004 Romain Dolbeau <romain@dolbeau.org>
+ * based on the equivalent C code in "postproc/swscale.c"
+ *
+ * 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 St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
 
 #ifdef CONFIG_DARWIN
 #define AVV(x...) (x)
@@ -36,13 +37,15 @@ altivec_packIntArrayToCharArray(int *val, uint8_t* dest, int dstW) {
   if ((unsigned long)dest % 16) {
     /* badly aligned store, we force store alignement */
     /* and will handle load misalignement on val w/ vec_perm */
+    vector unsigned char perm1;
+    vector signed int v1;
     for (i = 0 ; (i < dstW) &&
           (((unsigned long)dest + i) % 16) ; i++) {
       int t = val[i] >> 19;
       dest[i] = (t < 0) ? 0 : ((t > 255) ? 255 : t);
     }
-    vector unsigned char perm1 = vec_lvsl(i << 2, val);
-    vector signed int v1 = vec_ld(i << 2, val);
+    perm1 = vec_lvsl(i << 2, val);
+    v1 = vec_ld(i << 2, val);
     for ( ; i < (dstW - 15); i+=16) {
       int offset = i << 2;
       vector signed int v2 = vec_ld(offset + 16, val);
@@ -105,13 +108,13 @@ yuv2yuvX_altivec_real(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
     }
     
     for (j = 0; j < lumFilterSize; j++) {
-      vector signed short vLumFilter = vec_ld(j << 1, lumFilter);
-      vector unsigned char perm0 = vec_lvsl(j << 1, lumFilter);
+      vector signed short l1, vLumFilter = vec_ld(j << 1, lumFilter);
+      vector unsigned char perm, perm0 = vec_lvsl(j << 1, lumFilter);
       vLumFilter = vec_perm(vLumFilter, vLumFilter, perm0);
       vLumFilter = vec_splat(vLumFilter, 0); // lumFilter[j] is loaded 8 times in vLumFilter
       
-      vector unsigned char perm = vec_lvsl(0, lumSrc[j]);
-      vector signed short l1 = vec_ld(0, lumSrc[j]);
+      perm = vec_lvsl(0, lumSrc[j]);
+      l1 = vec_ld(0, lumSrc[j]);
       
       for (i = 0; i < (dstW - 7); i+=8) {
        int offset = i << 2;
@@ -156,14 +159,14 @@ yuv2yuvX_altivec_real(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
     }
     
     for (j = 0; j < chrFilterSize; j++) {
-      vector signed short vChrFilter = vec_ld(j << 1, chrFilter);
-      vector unsigned char perm0 = vec_lvsl(j << 1, chrFilter);
+      vector signed short l1, l1_V, vChrFilter = vec_ld(j << 1, chrFilter);
+      vector unsigned char perm, perm0 = vec_lvsl(j << 1, chrFilter);
       vChrFilter = vec_perm(vChrFilter, vChrFilter, perm0);
       vChrFilter = vec_splat(vChrFilter, 0); // chrFilter[j] is loaded 8 times in vChrFilter
       
-      vector unsigned char perm = vec_lvsl(0, chrSrc[j]);
-      vector signed short l1 = vec_ld(0, chrSrc[j]);
-      vector signed short l1_V = vec_ld(2048 << 1, chrSrc[j]);
+      perm = vec_lvsl(0, chrSrc[j]);
+      l1 = vec_ld(0, chrSrc[j]);
+      l1_V = vec_ld(2048 << 1, chrSrc[j]);
       
       for (i = 0; i < (chrDstW - 7); i+=8) {
        int offset = i << 2;
@@ -223,7 +226,7 @@ static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int
       for(j=0; j<filterSize; j++) {
        val += ((int)src[srcPos + j])*filter[filterSize*i + j];
       }
-      dst[i] = MIN(MAX(0, val>>7), (1<<15)-1);
+      dst[i] = FFMIN(FFMAX(0, val>>7), (1<<15)-1);
     }
   }
   else
@@ -231,22 +234,23 @@ static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int
   case 4:
     {
       for(i=0; i<dstW; i++) {
-       register int j;
        register int srcPos = filterPos[i];
 
        vector unsigned char src_v0 = vec_ld(srcPos, src);
-       vector unsigned char src_v1;
+       vector unsigned char src_v1, src_vF;
+       vector signed short src_v, filter_v;
+       vector signed int val_vEven, val_s;
        if ((((int)src + srcPos)% 16) > 12) {
          src_v1 = vec_ld(srcPos + 16, src);
        }
-       vector unsigned char src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
+       src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
 
-       vector signed short src_v = // vec_unpackh sign-extends...
+       src_v = // vec_unpackh sign-extends...
          (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
        // now put our elements in the even slots
        src_v = vec_mergeh(src_v, (vector signed short)vzero);
 
-       vector signed short filter_v = vec_ld(i << 3, filter);
+       filter_v = vec_ld(i << 3, filter);
         // the 3 above is 2 (filterSize == 4) + 1 (sizeof(short) == 2)
 
         // the neat trick : we only care for half the elements,
@@ -258,10 +262,10 @@ static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int
        else
          filter_v = vec_mergeh(filter_v,(vector signed short)vzero);
 
-       vector signed int val_vEven = vec_mule(src_v, filter_v);
-       vector signed int val_s = vec_sums(val_vEven, vzero);
+       val_vEven = vec_mule(src_v, filter_v);
+       val_s = vec_sums(val_vEven, vzero);
        vec_st(val_s, 0, tempo);
-       dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);
+       dst[i] = FFMIN(FFMAX(0, tempo[3]>>7), (1<<15)-1);
       }
     }
     break;
@@ -272,21 +276,23 @@ static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int
        register int srcPos = filterPos[i];
 
        vector unsigned char src_v0 = vec_ld(srcPos, src);
-       vector unsigned char src_v1;
+       vector unsigned char src_v1, src_vF;
+       vector signed short src_v, filter_v;
+       vector signed int val_v, val_s;
        if ((((int)src + srcPos)% 16) > 8) {
          src_v1 = vec_ld(srcPos + 16, src);
        }
-       vector unsigned char src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
+       src_vF = vec_perm(src_v0, src_v1, vec_lvsl(srcPos, src));
 
-       vector signed short src_v = // vec_unpackh sign-extends...
+       src_v = // vec_unpackh sign-extends...
          (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
-       vector signed short filter_v = vec_ld(i << 4, filter);
+       filter_v = vec_ld(i << 4, filter);
         // the 4 above is 3 (filterSize == 8) + 1 (sizeof(short) == 2)
 
-       vector signed int val_v = vec_msums(src_v, filter_v, (vector signed int)vzero);
-       vector signed int val_s = vec_sums(val_v, vzero);
+       val_v = vec_msums(src_v, filter_v, (vector signed int)vzero);
+       val_s = vec_sums(val_v, vzero);
        vec_st(val_s, 0, tempo);
-       dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);
+       dst[i] = FFMIN(FFMAX(0, tempo[3]>>7), (1<<15)-1);
       }
     }
     break;
@@ -315,7 +321,7 @@ static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int
        vector signed int val_s = vec_sums(val_v, vzero);
 
        vec_st(val_s, 0, tempo);
-       dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);
+       dst[i] = FFMIN(FFMAX(0, tempo[3]>>7), (1<<15)-1);
       }
     }
     break;
@@ -326,7 +332,7 @@ static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int
        register int j;
        register int srcPos = filterPos[i];
 
-        vector signed int val_v = (vector signed int)vzero;
+        vector signed int val_s, val_v = (vector signed int)vzero;
        vector signed short filter_v0R = vec_ld(i * 2 * filterSize, filter);
         vector unsigned char permF = vec_lvsl((i * 2 * filterSize), filter);
 
@@ -357,26 +363,27 @@ static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int
         if (j < (filterSize-7)) {
           // loading src_v0 is useless, it's already done above
           //vector unsigned char src_v0 = vec_ld(srcPos + j, src);
-          vector unsigned char src_v1;
+          vector unsigned char src_v1, src_vF;
+          vector signed short src_v, filter_v1R, filter_v;
           if ((((int)src + srcPos)% 16) > 8) {
             src_v1 = vec_ld(srcPos + j + 16, src);
           }
-          vector unsigned char src_vF = vec_perm(src_v0, src_v1, permS);
+          src_vF = vec_perm(src_v0, src_v1, permS);
           
-          vector signed short src_v = // vec_unpackh sign-extends...
+          src_v = // vec_unpackh sign-extends...
             (vector signed short)(vec_mergeh((vector unsigned char)vzero, src_vF));
           // loading filter_v0R is useless, it's already done above
           //vector signed short filter_v0R = vec_ld((i * 2 * filterSize) + j, filter);
-          vector signed short filter_v1R = vec_ld((i * 2 * filterSize) + (j * 2) + 16, filter);
-          vector signed short filter_v = vec_perm(filter_v0R, filter_v1R, permF);
+          filter_v1R = vec_ld((i * 2 * filterSize) + (j * 2) + 16, filter);
+          filter_v = vec_perm(filter_v0R, filter_v1R, permF);
           
           val_v = vec_msums(src_v, filter_v, val_v);
         }
 
-        vector signed int val_s = vec_sums(val_v, vzero);
+        val_s = vec_sums(val_v, vzero);
           
         vec_st(val_s, 0, tempo);
-        dst[i] = MIN(MAX(0, tempo[3]>>7), (1<<15)-1);        
+        dst[i] = FFMIN(FFMAX(0, tempo[3]>>7), (1<<15)-1);        
       }
       
     }